From 3f33fdfcaf2e6c1d6a6b71851ab01014aa1c9d9d Mon Sep 17 00:00:00 2001 From: Alex Goth <64845621+GAlexIHU@users.noreply.github.com> Date: Mon, 6 Jul 2026 16:38:15 +0200 Subject: [PATCH 1/3] fix(ledger): add internal foreign keys --- openmeter/ent/db/client.go | 320 ++++ openmeter/ent/db/ledgeraccount.go | 18 +- .../ent/db/ledgeraccount/ledgeraccount.go | 30 + openmeter/ent/db/ledgeraccount/where.go | 23 + openmeter/ent/db/ledgeraccount_create.go | 32 + openmeter/ent/db/ledgeraccount_query.go | 78 +- openmeter/ent/db/ledgeraccount_update.go | 163 ++ openmeter/ent/db/ledgerbreakagerecord.go | 210 ++- .../ledgerbreakagerecord.go | 256 +++ .../ent/db/ledgerbreakagerecord/where.go | 254 +++ .../ent/db/ledgerbreakagerecord_create.go | 310 ++- .../ent/db/ledgerbreakagerecord_query.go | 870 ++++++++- .../ent/db/ledgerbreakagerecord_update.go | 390 +++- openmeter/ent/db/ledgercustomeraccount.go | 31 +- .../ledgercustomeraccount.go | 24 + .../ent/db/ledgercustomeraccount/where.go | 24 + .../ent/db/ledgercustomeraccount_create.go | 28 +- .../ent/db/ledgercustomeraccount_query.go | 103 +- .../ent/db/ledgercustomeraccount_update.go | 22 + openmeter/ent/db/ledgerentry.go | 18 +- openmeter/ent/db/ledgerentry/ledgerentry.go | 30 + openmeter/ent/db/ledgerentry/where.go | 23 + openmeter/ent/db/ledgerentry_create.go | 32 + openmeter/ent/db/ledgerentry_query.go | 110 +- openmeter/ent/db/ledgerentry_update.go | 163 ++ openmeter/ent/db/ledgersubaccount.go | 34 +- .../db/ledgersubaccount/ledgersubaccount.go | 60 + openmeter/ent/db/ledgersubaccount/where.go | 46 + openmeter/ent/db/ledgersubaccount_create.go | 63 + openmeter/ent/db/ledgersubaccount_query.go | 185 +- openmeter/ent/db/ledgersubaccount_update.go | 325 ++++ openmeter/ent/db/ledgertransaction.go | 34 +- .../db/ledgertransaction/ledgertransaction.go | 60 + openmeter/ent/db/ledgertransaction/where.go | 46 + openmeter/ent/db/ledgertransaction_create.go | 63 + openmeter/ent/db/ledgertransaction_query.go | 184 +- openmeter/ent/db/ledgertransaction_update.go | 325 ++++ openmeter/ent/db/ledgertransactiongroup.go | 34 +- .../ledgertransactiongroup.go | 60 + .../ent/db/ledgertransactiongroup/where.go | 46 + .../ent/db/ledgertransactiongroup_create.go | 63 + .../ent/db/ledgertransactiongroup_query.go | 180 +- .../ent/db/ledgertransactiongroup_update.go | 325 ++++ openmeter/ent/db/migrate/schema.go | 94 +- openmeter/ent/db/mutation.go | 1678 +++++++++++++++-- openmeter/ent/schema/ledger_account.go | 3 + .../ent/schema/ledger_breakage_record.go | 60 + .../ent/schema/ledger_customer_account.go | 15 +- openmeter/ent/schema/ledger_entry.go | 2 + openmeter/ent/schema/ledger_transaction.go | 4 + .../ent/schema/ledger_transaction_group.go | 4 + .../ledger/breakage/adapter/record_test.go | 51 +- ...706130134_add_ledger_internal_fks.down.sql | 4 + ...60706130134_add_ledger_internal_fks.up.sql | 6 + tools/migrate/migrations/atlas.sum | 7 +- 55 files changed, 7250 insertions(+), 373 deletions(-) create mode 100644 tools/migrate/migrations/20260706130134_add_ledger_internal_fks.down.sql create mode 100644 tools/migrate/migrations/20260706130134_add_ledger_internal_fks.up.sql diff --git a/openmeter/ent/db/client.go b/openmeter/ent/db/client.go index 30761d8bf7..00b2ab3fec 100644 --- a/openmeter/ent/db/client.go +++ b/openmeter/ent/db/client.go @@ -11188,6 +11188,22 @@ func (c *LedgerAccountClient) QuerySubAccountRoutes(_m *LedgerAccount) *LedgerSu return query } +// QueryCustomerAccounts queries the customer_accounts edge of a LedgerAccount. +func (c *LedgerAccountClient) QueryCustomerAccounts(_m *LedgerAccount) *LedgerCustomerAccountQuery { + query := (&LedgerCustomerAccountClient{config: c.config}).Query() + query.path = func(context.Context) (fromV *sql.Selector, _ error) { + id := _m.ID + step := sqlgraph.NewStep( + sqlgraph.From(ledgeraccount.Table, ledgeraccount.FieldID, id), + sqlgraph.To(ledgercustomeraccount.Table, ledgercustomeraccount.FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, ledgeraccount.CustomerAccountsTable, ledgeraccount.CustomerAccountsColumn), + ) + fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step) + return fromV, nil + } + return query +} + // Hooks returns the client hooks. func (c *LedgerAccountClient) Hooks() []Hook { return c.hooks.LedgerAccount @@ -11321,6 +11337,182 @@ func (c *LedgerBreakageRecordClient) GetX(ctx context.Context, id string) *Ledge return obj } +// QuerySourceTransactionGroup queries the source_transaction_group edge of a LedgerBreakageRecord. +func (c *LedgerBreakageRecordClient) QuerySourceTransactionGroup(_m *LedgerBreakageRecord) *LedgerTransactionGroupQuery { + query := (&LedgerTransactionGroupClient{config: c.config}).Query() + query.path = func(context.Context) (fromV *sql.Selector, _ error) { + id := _m.ID + step := sqlgraph.NewStep( + sqlgraph.From(ledgerbreakagerecord.Table, ledgerbreakagerecord.FieldID, id), + sqlgraph.To(ledgertransactiongroup.Table, ledgertransactiongroup.FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, ledgerbreakagerecord.SourceTransactionGroupTable, ledgerbreakagerecord.SourceTransactionGroupColumn), + ) + fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step) + return fromV, nil + } + return query +} + +// QuerySourceTransaction queries the source_transaction edge of a LedgerBreakageRecord. +func (c *LedgerBreakageRecordClient) QuerySourceTransaction(_m *LedgerBreakageRecord) *LedgerTransactionQuery { + query := (&LedgerTransactionClient{config: c.config}).Query() + query.path = func(context.Context) (fromV *sql.Selector, _ error) { + id := _m.ID + step := sqlgraph.NewStep( + sqlgraph.From(ledgerbreakagerecord.Table, ledgerbreakagerecord.FieldID, id), + sqlgraph.To(ledgertransaction.Table, ledgertransaction.FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, ledgerbreakagerecord.SourceTransactionTable, ledgerbreakagerecord.SourceTransactionColumn), + ) + fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step) + return fromV, nil + } + return query +} + +// QuerySourceEntry queries the source_entry edge of a LedgerBreakageRecord. +func (c *LedgerBreakageRecordClient) QuerySourceEntry(_m *LedgerBreakageRecord) *LedgerEntryQuery { + query := (&LedgerEntryClient{config: c.config}).Query() + query.path = func(context.Context) (fromV *sql.Selector, _ error) { + id := _m.ID + step := sqlgraph.NewStep( + sqlgraph.From(ledgerbreakagerecord.Table, ledgerbreakagerecord.FieldID, id), + sqlgraph.To(ledgerentry.Table, ledgerentry.FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, ledgerbreakagerecord.SourceEntryTable, ledgerbreakagerecord.SourceEntryColumn), + ) + fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step) + return fromV, nil + } + return query +} + +// QueryBreakageTransactionGroup queries the breakage_transaction_group edge of a LedgerBreakageRecord. +func (c *LedgerBreakageRecordClient) QueryBreakageTransactionGroup(_m *LedgerBreakageRecord) *LedgerTransactionGroupQuery { + query := (&LedgerTransactionGroupClient{config: c.config}).Query() + query.path = func(context.Context) (fromV *sql.Selector, _ error) { + id := _m.ID + step := sqlgraph.NewStep( + sqlgraph.From(ledgerbreakagerecord.Table, ledgerbreakagerecord.FieldID, id), + sqlgraph.To(ledgertransactiongroup.Table, ledgertransactiongroup.FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, ledgerbreakagerecord.BreakageTransactionGroupTable, ledgerbreakagerecord.BreakageTransactionGroupColumn), + ) + fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step) + return fromV, nil + } + return query +} + +// QueryBreakageTransaction queries the breakage_transaction edge of a LedgerBreakageRecord. +func (c *LedgerBreakageRecordClient) QueryBreakageTransaction(_m *LedgerBreakageRecord) *LedgerTransactionQuery { + query := (&LedgerTransactionClient{config: c.config}).Query() + query.path = func(context.Context) (fromV *sql.Selector, _ error) { + id := _m.ID + step := sqlgraph.NewStep( + sqlgraph.From(ledgerbreakagerecord.Table, ledgerbreakagerecord.FieldID, id), + sqlgraph.To(ledgertransaction.Table, ledgertransaction.FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, ledgerbreakagerecord.BreakageTransactionTable, ledgerbreakagerecord.BreakageTransactionColumn), + ) + fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step) + return fromV, nil + } + return query +} + +// QueryFboSubAccount queries the fbo_sub_account edge of a LedgerBreakageRecord. +func (c *LedgerBreakageRecordClient) QueryFboSubAccount(_m *LedgerBreakageRecord) *LedgerSubAccountQuery { + query := (&LedgerSubAccountClient{config: c.config}).Query() + query.path = func(context.Context) (fromV *sql.Selector, _ error) { + id := _m.ID + step := sqlgraph.NewStep( + sqlgraph.From(ledgerbreakagerecord.Table, ledgerbreakagerecord.FieldID, id), + sqlgraph.To(ledgersubaccount.Table, ledgersubaccount.FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, ledgerbreakagerecord.FboSubAccountTable, ledgerbreakagerecord.FboSubAccountColumn), + ) + fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step) + return fromV, nil + } + return query +} + +// QueryBreakageSubAccount queries the breakage_sub_account edge of a LedgerBreakageRecord. +func (c *LedgerBreakageRecordClient) QueryBreakageSubAccount(_m *LedgerBreakageRecord) *LedgerSubAccountQuery { + query := (&LedgerSubAccountClient{config: c.config}).Query() + query.path = func(context.Context) (fromV *sql.Selector, _ error) { + id := _m.ID + step := sqlgraph.NewStep( + sqlgraph.From(ledgerbreakagerecord.Table, ledgerbreakagerecord.FieldID, id), + sqlgraph.To(ledgersubaccount.Table, ledgersubaccount.FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, ledgerbreakagerecord.BreakageSubAccountTable, ledgerbreakagerecord.BreakageSubAccountColumn), + ) + fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step) + return fromV, nil + } + return query +} + +// QueryPlannedReleases queries the planned_releases edge of a LedgerBreakageRecord. +func (c *LedgerBreakageRecordClient) QueryPlannedReleases(_m *LedgerBreakageRecord) *LedgerBreakageRecordQuery { + query := (&LedgerBreakageRecordClient{config: c.config}).Query() + query.path = func(context.Context) (fromV *sql.Selector, _ error) { + id := _m.ID + step := sqlgraph.NewStep( + sqlgraph.From(ledgerbreakagerecord.Table, ledgerbreakagerecord.FieldID, id), + sqlgraph.To(ledgerbreakagerecord.Table, ledgerbreakagerecord.FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, ledgerbreakagerecord.PlannedReleasesTable, ledgerbreakagerecord.PlannedReleasesColumn), + ) + fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step) + return fromV, nil + } + return query +} + +// QueryReleaseReopens queries the release_reopens edge of a LedgerBreakageRecord. +func (c *LedgerBreakageRecordClient) QueryReleaseReopens(_m *LedgerBreakageRecord) *LedgerBreakageRecordQuery { + query := (&LedgerBreakageRecordClient{config: c.config}).Query() + query.path = func(context.Context) (fromV *sql.Selector, _ error) { + id := _m.ID + step := sqlgraph.NewStep( + sqlgraph.From(ledgerbreakagerecord.Table, ledgerbreakagerecord.FieldID, id), + sqlgraph.To(ledgerbreakagerecord.Table, ledgerbreakagerecord.FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, ledgerbreakagerecord.ReleaseReopensTable, ledgerbreakagerecord.ReleaseReopensColumn), + ) + fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step) + return fromV, nil + } + return query +} + +// QueryPlan queries the plan edge of a LedgerBreakageRecord. +func (c *LedgerBreakageRecordClient) QueryPlan(_m *LedgerBreakageRecord) *LedgerBreakageRecordQuery { + query := (&LedgerBreakageRecordClient{config: c.config}).Query() + query.path = func(context.Context) (fromV *sql.Selector, _ error) { + id := _m.ID + step := sqlgraph.NewStep( + sqlgraph.From(ledgerbreakagerecord.Table, ledgerbreakagerecord.FieldID, id), + sqlgraph.To(ledgerbreakagerecord.Table, ledgerbreakagerecord.FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, ledgerbreakagerecord.PlanTable, ledgerbreakagerecord.PlanColumn), + ) + fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step) + return fromV, nil + } + return query +} + +// QueryRelease queries the release edge of a LedgerBreakageRecord. +func (c *LedgerBreakageRecordClient) QueryRelease(_m *LedgerBreakageRecord) *LedgerBreakageRecordQuery { + query := (&LedgerBreakageRecordClient{config: c.config}).Query() + query.path = func(context.Context) (fromV *sql.Selector, _ error) { + id := _m.ID + step := sqlgraph.NewStep( + sqlgraph.From(ledgerbreakagerecord.Table, ledgerbreakagerecord.FieldID, id), + sqlgraph.To(ledgerbreakagerecord.Table, ledgerbreakagerecord.FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, ledgerbreakagerecord.ReleaseTable, ledgerbreakagerecord.ReleaseColumn), + ) + fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step) + return fromV, nil + } + return query +} + // Hooks returns the client hooks. func (c *LedgerBreakageRecordClient) Hooks() []Hook { return c.hooks.LedgerBreakageRecord @@ -11454,6 +11646,22 @@ func (c *LedgerCustomerAccountClient) GetX(ctx context.Context, id string) *Ledg return obj } +// QueryAccount queries the account edge of a LedgerCustomerAccount. +func (c *LedgerCustomerAccountClient) QueryAccount(_m *LedgerCustomerAccount) *LedgerAccountQuery { + query := (&LedgerAccountClient{config: c.config}).Query() + query.path = func(context.Context) (fromV *sql.Selector, _ error) { + id := _m.ID + step := sqlgraph.NewStep( + sqlgraph.From(ledgercustomeraccount.Table, ledgercustomeraccount.FieldID, id), + sqlgraph.To(ledgeraccount.Table, ledgeraccount.FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, ledgercustomeraccount.AccountTable, ledgercustomeraccount.AccountColumn), + ) + fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step) + return fromV, nil + } + return query +} + // Hooks returns the client hooks. func (c *LedgerCustomerAccountClient) Hooks() []Hook { return c.hooks.LedgerCustomerAccount @@ -11619,6 +11827,22 @@ func (c *LedgerEntryClient) QuerySubAccount(_m *LedgerEntry) *LedgerSubAccountQu return query } +// QuerySourceBreakageRecords queries the source_breakage_records edge of a LedgerEntry. +func (c *LedgerEntryClient) QuerySourceBreakageRecords(_m *LedgerEntry) *LedgerBreakageRecordQuery { + query := (&LedgerBreakageRecordClient{config: c.config}).Query() + query.path = func(context.Context) (fromV *sql.Selector, _ error) { + id := _m.ID + step := sqlgraph.NewStep( + sqlgraph.From(ledgerentry.Table, ledgerentry.FieldID, id), + sqlgraph.To(ledgerbreakagerecord.Table, ledgerbreakagerecord.FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, ledgerentry.SourceBreakageRecordsTable, ledgerentry.SourceBreakageRecordsColumn), + ) + fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step) + return fromV, nil + } + return query +} + // Hooks returns the client hooks. func (c *LedgerEntryClient) Hooks() []Hook { return c.hooks.LedgerEntry @@ -11800,6 +12024,38 @@ func (c *LedgerSubAccountClient) QueryEntries(_m *LedgerSubAccount) *LedgerEntry return query } +// QueryFboBreakageRecords queries the fbo_breakage_records edge of a LedgerSubAccount. +func (c *LedgerSubAccountClient) QueryFboBreakageRecords(_m *LedgerSubAccount) *LedgerBreakageRecordQuery { + query := (&LedgerBreakageRecordClient{config: c.config}).Query() + query.path = func(context.Context) (fromV *sql.Selector, _ error) { + id := _m.ID + step := sqlgraph.NewStep( + sqlgraph.From(ledgersubaccount.Table, ledgersubaccount.FieldID, id), + sqlgraph.To(ledgerbreakagerecord.Table, ledgerbreakagerecord.FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, ledgersubaccount.FboBreakageRecordsTable, ledgersubaccount.FboBreakageRecordsColumn), + ) + fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step) + return fromV, nil + } + return query +} + +// QueryBreakageRecords queries the breakage_records edge of a LedgerSubAccount. +func (c *LedgerSubAccountClient) QueryBreakageRecords(_m *LedgerSubAccount) *LedgerBreakageRecordQuery { + query := (&LedgerBreakageRecordClient{config: c.config}).Query() + query.path = func(context.Context) (fromV *sql.Selector, _ error) { + id := _m.ID + step := sqlgraph.NewStep( + sqlgraph.From(ledgersubaccount.Table, ledgersubaccount.FieldID, id), + sqlgraph.To(ledgerbreakagerecord.Table, ledgerbreakagerecord.FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, ledgersubaccount.BreakageRecordsTable, ledgersubaccount.BreakageRecordsColumn), + ) + fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step) + return fromV, nil + } + return query +} + // Hooks returns the client hooks. func (c *LedgerSubAccountClient) Hooks() []Hook { return c.hooks.LedgerSubAccount @@ -12130,6 +12386,38 @@ func (c *LedgerTransactionClient) QueryEntries(_m *LedgerTransaction) *LedgerEnt return query } +// QuerySourceBreakageRecords queries the source_breakage_records edge of a LedgerTransaction. +func (c *LedgerTransactionClient) QuerySourceBreakageRecords(_m *LedgerTransaction) *LedgerBreakageRecordQuery { + query := (&LedgerBreakageRecordClient{config: c.config}).Query() + query.path = func(context.Context) (fromV *sql.Selector, _ error) { + id := _m.ID + step := sqlgraph.NewStep( + sqlgraph.From(ledgertransaction.Table, ledgertransaction.FieldID, id), + sqlgraph.To(ledgerbreakagerecord.Table, ledgerbreakagerecord.FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, ledgertransaction.SourceBreakageRecordsTable, ledgertransaction.SourceBreakageRecordsColumn), + ) + fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step) + return fromV, nil + } + return query +} + +// QueryBreakageRecords queries the breakage_records edge of a LedgerTransaction. +func (c *LedgerTransactionClient) QueryBreakageRecords(_m *LedgerTransaction) *LedgerBreakageRecordQuery { + query := (&LedgerBreakageRecordClient{config: c.config}).Query() + query.path = func(context.Context) (fromV *sql.Selector, _ error) { + id := _m.ID + step := sqlgraph.NewStep( + sqlgraph.From(ledgertransaction.Table, ledgertransaction.FieldID, id), + sqlgraph.To(ledgerbreakagerecord.Table, ledgerbreakagerecord.FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, ledgertransaction.BreakageRecordsTable, ledgertransaction.BreakageRecordsColumn), + ) + fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step) + return fromV, nil + } + return query +} + // Hooks returns the client hooks. func (c *LedgerTransactionClient) Hooks() []Hook { return c.hooks.LedgerTransaction @@ -12279,6 +12567,38 @@ func (c *LedgerTransactionGroupClient) QueryTransactions(_m *LedgerTransactionGr return query } +// QuerySourceBreakageRecords queries the source_breakage_records edge of a LedgerTransactionGroup. +func (c *LedgerTransactionGroupClient) QuerySourceBreakageRecords(_m *LedgerTransactionGroup) *LedgerBreakageRecordQuery { + query := (&LedgerBreakageRecordClient{config: c.config}).Query() + query.path = func(context.Context) (fromV *sql.Selector, _ error) { + id := _m.ID + step := sqlgraph.NewStep( + sqlgraph.From(ledgertransactiongroup.Table, ledgertransactiongroup.FieldID, id), + sqlgraph.To(ledgerbreakagerecord.Table, ledgerbreakagerecord.FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, ledgertransactiongroup.SourceBreakageRecordsTable, ledgertransactiongroup.SourceBreakageRecordsColumn), + ) + fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step) + return fromV, nil + } + return query +} + +// QueryBreakageRecords queries the breakage_records edge of a LedgerTransactionGroup. +func (c *LedgerTransactionGroupClient) QueryBreakageRecords(_m *LedgerTransactionGroup) *LedgerBreakageRecordQuery { + query := (&LedgerBreakageRecordClient{config: c.config}).Query() + query.path = func(context.Context) (fromV *sql.Selector, _ error) { + id := _m.ID + step := sqlgraph.NewStep( + sqlgraph.From(ledgertransactiongroup.Table, ledgertransactiongroup.FieldID, id), + sqlgraph.To(ledgerbreakagerecord.Table, ledgerbreakagerecord.FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, ledgertransactiongroup.BreakageRecordsTable, ledgertransactiongroup.BreakageRecordsColumn), + ) + fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step) + return fromV, nil + } + return query +} + // Hooks returns the client hooks. func (c *LedgerTransactionGroupClient) Hooks() []Hook { return c.hooks.LedgerTransactionGroup diff --git a/openmeter/ent/db/ledgeraccount.go b/openmeter/ent/db/ledgeraccount.go index b03d42eb73..735e1c96da 100644 --- a/openmeter/ent/db/ledgeraccount.go +++ b/openmeter/ent/db/ledgeraccount.go @@ -44,9 +44,11 @@ type LedgerAccountEdges struct { SubAccounts []*LedgerSubAccount `json:"sub_accounts,omitempty"` // SubAccountRoutes holds the value of the sub_account_routes edge. SubAccountRoutes []*LedgerSubAccountRoute `json:"sub_account_routes,omitempty"` + // CustomerAccounts holds the value of the customer_accounts edge. + CustomerAccounts []*LedgerCustomerAccount `json:"customer_accounts,omitempty"` // loadedTypes holds the information for reporting if a // type was loaded (or requested) in eager-loading or not. - loadedTypes [2]bool + loadedTypes [3]bool } // SubAccountsOrErr returns the SubAccounts value or an error if the edge @@ -67,6 +69,15 @@ func (e LedgerAccountEdges) SubAccountRoutesOrErr() ([]*LedgerSubAccountRoute, e return nil, &NotLoadedError{edge: "sub_account_routes"} } +// CustomerAccountsOrErr returns the CustomerAccounts value or an error if the edge +// was not loaded in eager-loading. +func (e LedgerAccountEdges) CustomerAccountsOrErr() ([]*LedgerCustomerAccount, error) { + if e.loadedTypes[2] { + return e.CustomerAccounts, nil + } + return nil, &NotLoadedError{edge: "customer_accounts"} +} + // scanValues returns the types for scanning values from sql.Rows. func (*LedgerAccount) scanValues(columns []string) ([]any, error) { values := make([]any, len(columns)) @@ -161,6 +172,11 @@ func (_m *LedgerAccount) QuerySubAccountRoutes() *LedgerSubAccountRouteQuery { return NewLedgerAccountClient(_m.config).QuerySubAccountRoutes(_m) } +// QueryCustomerAccounts queries the "customer_accounts" edge of the LedgerAccount entity. +func (_m *LedgerAccount) QueryCustomerAccounts() *LedgerCustomerAccountQuery { + return NewLedgerAccountClient(_m.config).QueryCustomerAccounts(_m) +} + // Update returns a builder for updating this LedgerAccount. // Note that you need to call LedgerAccount.Unwrap() before calling this method if this LedgerAccount // was returned from a transaction, and the transaction was committed or rolled back. diff --git a/openmeter/ent/db/ledgeraccount/ledgeraccount.go b/openmeter/ent/db/ledgeraccount/ledgeraccount.go index ffc9f505ec..936b108235 100644 --- a/openmeter/ent/db/ledgeraccount/ledgeraccount.go +++ b/openmeter/ent/db/ledgeraccount/ledgeraccount.go @@ -30,6 +30,8 @@ const ( EdgeSubAccounts = "sub_accounts" // EdgeSubAccountRoutes holds the string denoting the sub_account_routes edge name in mutations. EdgeSubAccountRoutes = "sub_account_routes" + // EdgeCustomerAccounts holds the string denoting the customer_accounts edge name in mutations. + EdgeCustomerAccounts = "customer_accounts" // Table holds the table name of the ledgeraccount in the database. Table = "ledger_accounts" // SubAccountsTable is the table that holds the sub_accounts relation/edge. @@ -46,6 +48,13 @@ const ( SubAccountRoutesInverseTable = "ledger_sub_account_routes" // SubAccountRoutesColumn is the table column denoting the sub_account_routes relation/edge. SubAccountRoutesColumn = "account_id" + // CustomerAccountsTable is the table that holds the customer_accounts relation/edge. + CustomerAccountsTable = "ledger_customer_accounts" + // CustomerAccountsInverseTable is the table name for the LedgerCustomerAccount entity. + // It exists in this package in order to avoid circular dependency with the "ledgercustomeraccount" package. + CustomerAccountsInverseTable = "ledger_customer_accounts" + // CustomerAccountsColumn is the table column denoting the customer_accounts relation/edge. + CustomerAccountsColumn = "account_id" ) // Columns holds all SQL columns for ledgeraccount fields. @@ -142,6 +151,20 @@ func BySubAccountRoutes(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption sqlgraph.OrderByNeighborTerms(s, newSubAccountRoutesStep(), append([]sql.OrderTerm{term}, terms...)...) } } + +// ByCustomerAccountsCount orders the results by customer_accounts count. +func ByCustomerAccountsCount(opts ...sql.OrderTermOption) OrderOption { + return func(s *sql.Selector) { + sqlgraph.OrderByNeighborsCount(s, newCustomerAccountsStep(), opts...) + } +} + +// ByCustomerAccounts orders the results by customer_accounts terms. +func ByCustomerAccounts(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption { + return func(s *sql.Selector) { + sqlgraph.OrderByNeighborTerms(s, newCustomerAccountsStep(), append([]sql.OrderTerm{term}, terms...)...) + } +} func newSubAccountsStep() *sqlgraph.Step { return sqlgraph.NewStep( sqlgraph.From(Table, FieldID), @@ -156,3 +179,10 @@ func newSubAccountRoutesStep() *sqlgraph.Step { sqlgraph.Edge(sqlgraph.O2M, false, SubAccountRoutesTable, SubAccountRoutesColumn), ) } +func newCustomerAccountsStep() *sqlgraph.Step { + return sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.To(CustomerAccountsInverseTable, FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, CustomerAccountsTable, CustomerAccountsColumn), + ) +} diff --git a/openmeter/ent/db/ledgeraccount/where.go b/openmeter/ent/db/ledgeraccount/where.go index 72fa6ff56f..15423ba3ed 100644 --- a/openmeter/ent/db/ledgeraccount/where.go +++ b/openmeter/ent/db/ledgeraccount/where.go @@ -427,6 +427,29 @@ func HasSubAccountRoutesWith(preds ...predicate.LedgerSubAccountRoute) predicate }) } +// HasCustomerAccounts applies the HasEdge predicate on the "customer_accounts" edge. +func HasCustomerAccounts() predicate.LedgerAccount { + return predicate.LedgerAccount(func(s *sql.Selector) { + step := sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, CustomerAccountsTable, CustomerAccountsColumn), + ) + sqlgraph.HasNeighbors(s, step) + }) +} + +// HasCustomerAccountsWith applies the HasEdge predicate on the "customer_accounts" edge with a given conditions (other predicates). +func HasCustomerAccountsWith(preds ...predicate.LedgerCustomerAccount) predicate.LedgerAccount { + return predicate.LedgerAccount(func(s *sql.Selector) { + step := newCustomerAccountsStep() + sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) { + for _, p := range preds { + p(s) + } + }) + }) +} + // And groups predicates with the AND operator between them. func And(predicates ...predicate.LedgerAccount) predicate.LedgerAccount { return predicate.LedgerAccount(sql.AndPredicates(predicates...)) diff --git a/openmeter/ent/db/ledgeraccount_create.go b/openmeter/ent/db/ledgeraccount_create.go index 567234b636..0deaa0cd08 100644 --- a/openmeter/ent/db/ledgeraccount_create.go +++ b/openmeter/ent/db/ledgeraccount_create.go @@ -13,6 +13,7 @@ import ( "entgo.io/ent/dialect/sql/sqlgraph" "entgo.io/ent/schema/field" "github.com/openmeterio/openmeter/openmeter/ent/db/ledgeraccount" + "github.com/openmeterio/openmeter/openmeter/ent/db/ledgercustomeraccount" "github.com/openmeterio/openmeter/openmeter/ent/db/ledgersubaccount" "github.com/openmeterio/openmeter/openmeter/ent/db/ledgersubaccountroute" "github.com/openmeterio/openmeter/openmeter/ledger" @@ -131,6 +132,21 @@ func (_c *LedgerAccountCreate) AddSubAccountRoutes(v ...*LedgerSubAccountRoute) return _c.AddSubAccountRouteIDs(ids...) } +// AddCustomerAccountIDs adds the "customer_accounts" edge to the LedgerCustomerAccount entity by IDs. +func (_c *LedgerAccountCreate) AddCustomerAccountIDs(ids ...string) *LedgerAccountCreate { + _c.mutation.AddCustomerAccountIDs(ids...) + return _c +} + +// AddCustomerAccounts adds the "customer_accounts" edges to the LedgerCustomerAccount entity. +func (_c *LedgerAccountCreate) AddCustomerAccounts(v ...*LedgerCustomerAccount) *LedgerAccountCreate { + ids := make([]string, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _c.AddCustomerAccountIDs(ids...) +} + // Mutation returns the LedgerAccountMutation object of the builder. func (_c *LedgerAccountCreate) Mutation() *LedgerAccountMutation { return _c.mutation @@ -296,6 +312,22 @@ func (_c *LedgerAccountCreate) createSpec() (*LedgerAccount, *sqlgraph.CreateSpe } _spec.Edges = append(_spec.Edges, edge) } + if nodes := _c.mutation.CustomerAccountsIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgeraccount.CustomerAccountsTable, + Columns: []string{ledgeraccount.CustomerAccountsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgercustomeraccount.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges = append(_spec.Edges, edge) + } return _node, _spec } diff --git a/openmeter/ent/db/ledgeraccount_query.go b/openmeter/ent/db/ledgeraccount_query.go index bdc5d9016c..a751976d85 100644 --- a/openmeter/ent/db/ledgeraccount_query.go +++ b/openmeter/ent/db/ledgeraccount_query.go @@ -14,6 +14,7 @@ import ( "entgo.io/ent/dialect/sql/sqlgraph" "entgo.io/ent/schema/field" "github.com/openmeterio/openmeter/openmeter/ent/db/ledgeraccount" + "github.com/openmeterio/openmeter/openmeter/ent/db/ledgercustomeraccount" "github.com/openmeterio/openmeter/openmeter/ent/db/ledgersubaccount" "github.com/openmeterio/openmeter/openmeter/ent/db/ledgersubaccountroute" "github.com/openmeterio/openmeter/openmeter/ent/db/predicate" @@ -28,6 +29,7 @@ type LedgerAccountQuery struct { predicates []predicate.LedgerAccount withSubAccounts *LedgerSubAccountQuery withSubAccountRoutes *LedgerSubAccountRouteQuery + withCustomerAccounts *LedgerCustomerAccountQuery modifiers []func(*sql.Selector) // intermediate query (i.e. traversal path). sql *sql.Selector @@ -109,6 +111,28 @@ func (_q *LedgerAccountQuery) QuerySubAccountRoutes() *LedgerSubAccountRouteQuer return query } +// QueryCustomerAccounts chains the current query on the "customer_accounts" edge. +func (_q *LedgerAccountQuery) QueryCustomerAccounts() *LedgerCustomerAccountQuery { + query := (&LedgerCustomerAccountClient{config: _q.config}).Query() + query.path = func(ctx context.Context) (fromU *sql.Selector, err error) { + if err := _q.prepareQuery(ctx); err != nil { + return nil, err + } + selector := _q.sqlQuery(ctx) + if err := selector.Err(); err != nil { + return nil, err + } + step := sqlgraph.NewStep( + sqlgraph.From(ledgeraccount.Table, ledgeraccount.FieldID, selector), + sqlgraph.To(ledgercustomeraccount.Table, ledgercustomeraccount.FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, ledgeraccount.CustomerAccountsTable, ledgeraccount.CustomerAccountsColumn), + ) + fromU = sqlgraph.SetNeighbors(_q.driver.Dialect(), step) + return fromU, nil + } + return query +} + // First returns the first LedgerAccount entity from the query. // Returns a *NotFoundError when no LedgerAccount was found. func (_q *LedgerAccountQuery) First(ctx context.Context) (*LedgerAccount, error) { @@ -303,6 +327,7 @@ func (_q *LedgerAccountQuery) Clone() *LedgerAccountQuery { predicates: append([]predicate.LedgerAccount{}, _q.predicates...), withSubAccounts: _q.withSubAccounts.Clone(), withSubAccountRoutes: _q.withSubAccountRoutes.Clone(), + withCustomerAccounts: _q.withCustomerAccounts.Clone(), // clone intermediate query. sql: _q.sql.Clone(), path: _q.path, @@ -331,6 +356,17 @@ func (_q *LedgerAccountQuery) WithSubAccountRoutes(opts ...func(*LedgerSubAccoun return _q } +// WithCustomerAccounts tells the query-builder to eager-load the nodes that are connected to +// the "customer_accounts" edge. The optional arguments are used to configure the query builder of the edge. +func (_q *LedgerAccountQuery) WithCustomerAccounts(opts ...func(*LedgerCustomerAccountQuery)) *LedgerAccountQuery { + query := (&LedgerCustomerAccountClient{config: _q.config}).Query() + for _, opt := range opts { + opt(query) + } + _q.withCustomerAccounts = query + return _q +} + // 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. // @@ -409,9 +445,10 @@ func (_q *LedgerAccountQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([ var ( nodes = []*LedgerAccount{} _spec = _q.querySpec() - loadedTypes = [2]bool{ + loadedTypes = [3]bool{ _q.withSubAccounts != nil, _q.withSubAccountRoutes != nil, + _q.withCustomerAccounts != nil, } ) _spec.ScanValues = func(columns []string) ([]any, error) { @@ -451,6 +488,15 @@ func (_q *LedgerAccountQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([ return nil, err } } + if query := _q.withCustomerAccounts; query != nil { + if err := _q.loadCustomerAccounts(ctx, query, nodes, + func(n *LedgerAccount) { n.Edges.CustomerAccounts = []*LedgerCustomerAccount{} }, + func(n *LedgerAccount, e *LedgerCustomerAccount) { + n.Edges.CustomerAccounts = append(n.Edges.CustomerAccounts, e) + }); err != nil { + return nil, err + } + } return nodes, nil } @@ -514,6 +560,36 @@ func (_q *LedgerAccountQuery) loadSubAccountRoutes(ctx context.Context, query *L } return nil } +func (_q *LedgerAccountQuery) loadCustomerAccounts(ctx context.Context, query *LedgerCustomerAccountQuery, nodes []*LedgerAccount, init func(*LedgerAccount), assign func(*LedgerAccount, *LedgerCustomerAccount)) error { + fks := make([]driver.Value, 0, len(nodes)) + nodeids := make(map[string]*LedgerAccount) + for i := range nodes { + fks = append(fks, nodes[i].ID) + nodeids[nodes[i].ID] = nodes[i] + if init != nil { + init(nodes[i]) + } + } + if len(query.ctx.Fields) > 0 { + query.ctx.AppendFieldOnce(ledgercustomeraccount.FieldAccountID) + } + query.Where(predicate.LedgerCustomerAccount(func(s *sql.Selector) { + s.Where(sql.InValues(s.C(ledgeraccount.CustomerAccountsColumn), fks...)) + })) + neighbors, err := query.All(ctx) + if err != nil { + return err + } + for _, n := range neighbors { + fk := n.AccountID + node, ok := nodeids[fk] + if !ok { + return fmt.Errorf(`unexpected referenced foreign-key "account_id" returned %v for node %v`, fk, n.ID) + } + assign(node, n) + } + return nil +} func (_q *LedgerAccountQuery) sqlCount(ctx context.Context) (int, error) { _spec := _q.querySpec() diff --git a/openmeter/ent/db/ledgeraccount_update.go b/openmeter/ent/db/ledgeraccount_update.go index 551171cdc7..7f39a2d782 100644 --- a/openmeter/ent/db/ledgeraccount_update.go +++ b/openmeter/ent/db/ledgeraccount_update.go @@ -12,6 +12,7 @@ import ( "entgo.io/ent/dialect/sql/sqlgraph" "entgo.io/ent/schema/field" "github.com/openmeterio/openmeter/openmeter/ent/db/ledgeraccount" + "github.com/openmeterio/openmeter/openmeter/ent/db/ledgercustomeraccount" "github.com/openmeterio/openmeter/openmeter/ent/db/ledgersubaccount" "github.com/openmeterio/openmeter/openmeter/ent/db/ledgersubaccountroute" "github.com/openmeterio/openmeter/openmeter/ent/db/predicate" @@ -99,6 +100,21 @@ func (_u *LedgerAccountUpdate) AddSubAccountRoutes(v ...*LedgerSubAccountRoute) return _u.AddSubAccountRouteIDs(ids...) } +// AddCustomerAccountIDs adds the "customer_accounts" edge to the LedgerCustomerAccount entity by IDs. +func (_u *LedgerAccountUpdate) AddCustomerAccountIDs(ids ...string) *LedgerAccountUpdate { + _u.mutation.AddCustomerAccountIDs(ids...) + return _u +} + +// AddCustomerAccounts adds the "customer_accounts" edges to the LedgerCustomerAccount entity. +func (_u *LedgerAccountUpdate) AddCustomerAccounts(v ...*LedgerCustomerAccount) *LedgerAccountUpdate { + ids := make([]string, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _u.AddCustomerAccountIDs(ids...) +} + // Mutation returns the LedgerAccountMutation object of the builder. func (_u *LedgerAccountUpdate) Mutation() *LedgerAccountMutation { return _u.mutation @@ -146,6 +162,27 @@ func (_u *LedgerAccountUpdate) RemoveSubAccountRoutes(v ...*LedgerSubAccountRout return _u.RemoveSubAccountRouteIDs(ids...) } +// ClearCustomerAccounts clears all "customer_accounts" edges to the LedgerCustomerAccount entity. +func (_u *LedgerAccountUpdate) ClearCustomerAccounts() *LedgerAccountUpdate { + _u.mutation.ClearCustomerAccounts() + return _u +} + +// RemoveCustomerAccountIDs removes the "customer_accounts" edge to LedgerCustomerAccount entities by IDs. +func (_u *LedgerAccountUpdate) RemoveCustomerAccountIDs(ids ...string) *LedgerAccountUpdate { + _u.mutation.RemoveCustomerAccountIDs(ids...) + return _u +} + +// RemoveCustomerAccounts removes "customer_accounts" edges to LedgerCustomerAccount entities. +func (_u *LedgerAccountUpdate) RemoveCustomerAccounts(v ...*LedgerCustomerAccount) *LedgerAccountUpdate { + ids := make([]string, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _u.RemoveCustomerAccountIDs(ids...) +} + // Save executes the query and returns the number of nodes affected by the update operation. func (_u *LedgerAccountUpdate) Save(ctx context.Context) (int, error) { _u.defaults() @@ -296,6 +333,51 @@ func (_u *LedgerAccountUpdate) sqlSave(ctx context.Context) (_node int, err erro } _spec.Edges.Add = append(_spec.Edges.Add, edge) } + if _u.mutation.CustomerAccountsCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgeraccount.CustomerAccountsTable, + Columns: []string{ledgeraccount.CustomerAccountsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgercustomeraccount.FieldID, field.TypeString), + }, + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := _u.mutation.RemovedCustomerAccountsIDs(); len(nodes) > 0 && !_u.mutation.CustomerAccountsCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgeraccount.CustomerAccountsTable, + Columns: []string{ledgeraccount.CustomerAccountsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgercustomeraccount.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := _u.mutation.CustomerAccountsIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgeraccount.CustomerAccountsTable, + Columns: []string{ledgeraccount.CustomerAccountsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgercustomeraccount.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Add = append(_spec.Edges.Add, edge) + } if _node, err = sqlgraph.UpdateNodes(ctx, _u.driver, _spec); err != nil { if _, ok := err.(*sqlgraph.NotFoundError); ok { err = &NotFoundError{ledgeraccount.Label} @@ -384,6 +466,21 @@ func (_u *LedgerAccountUpdateOne) AddSubAccountRoutes(v ...*LedgerSubAccountRout return _u.AddSubAccountRouteIDs(ids...) } +// AddCustomerAccountIDs adds the "customer_accounts" edge to the LedgerCustomerAccount entity by IDs. +func (_u *LedgerAccountUpdateOne) AddCustomerAccountIDs(ids ...string) *LedgerAccountUpdateOne { + _u.mutation.AddCustomerAccountIDs(ids...) + return _u +} + +// AddCustomerAccounts adds the "customer_accounts" edges to the LedgerCustomerAccount entity. +func (_u *LedgerAccountUpdateOne) AddCustomerAccounts(v ...*LedgerCustomerAccount) *LedgerAccountUpdateOne { + ids := make([]string, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _u.AddCustomerAccountIDs(ids...) +} + // Mutation returns the LedgerAccountMutation object of the builder. func (_u *LedgerAccountUpdateOne) Mutation() *LedgerAccountMutation { return _u.mutation @@ -431,6 +528,27 @@ func (_u *LedgerAccountUpdateOne) RemoveSubAccountRoutes(v ...*LedgerSubAccountR return _u.RemoveSubAccountRouteIDs(ids...) } +// ClearCustomerAccounts clears all "customer_accounts" edges to the LedgerCustomerAccount entity. +func (_u *LedgerAccountUpdateOne) ClearCustomerAccounts() *LedgerAccountUpdateOne { + _u.mutation.ClearCustomerAccounts() + return _u +} + +// RemoveCustomerAccountIDs removes the "customer_accounts" edge to LedgerCustomerAccount entities by IDs. +func (_u *LedgerAccountUpdateOne) RemoveCustomerAccountIDs(ids ...string) *LedgerAccountUpdateOne { + _u.mutation.RemoveCustomerAccountIDs(ids...) + return _u +} + +// RemoveCustomerAccounts removes "customer_accounts" edges to LedgerCustomerAccount entities. +func (_u *LedgerAccountUpdateOne) RemoveCustomerAccounts(v ...*LedgerCustomerAccount) *LedgerAccountUpdateOne { + ids := make([]string, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _u.RemoveCustomerAccountIDs(ids...) +} + // Where appends a list predicates to the LedgerAccountUpdate builder. func (_u *LedgerAccountUpdateOne) Where(ps ...predicate.LedgerAccount) *LedgerAccountUpdateOne { _u.mutation.Where(ps...) @@ -611,6 +729,51 @@ func (_u *LedgerAccountUpdateOne) sqlSave(ctx context.Context) (_node *LedgerAcc } _spec.Edges.Add = append(_spec.Edges.Add, edge) } + if _u.mutation.CustomerAccountsCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgeraccount.CustomerAccountsTable, + Columns: []string{ledgeraccount.CustomerAccountsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgercustomeraccount.FieldID, field.TypeString), + }, + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := _u.mutation.RemovedCustomerAccountsIDs(); len(nodes) > 0 && !_u.mutation.CustomerAccountsCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgeraccount.CustomerAccountsTable, + Columns: []string{ledgeraccount.CustomerAccountsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgercustomeraccount.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := _u.mutation.CustomerAccountsIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgeraccount.CustomerAccountsTable, + Columns: []string{ledgeraccount.CustomerAccountsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgercustomeraccount.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Add = append(_spec.Edges.Add, edge) + } _node = &LedgerAccount{config: _u.config} _spec.Assign = _node.assignValues _spec.ScanValues = _node.scanValues diff --git a/openmeter/ent/db/ledgerbreakagerecord.go b/openmeter/ent/db/ledgerbreakagerecord.go index 078175fad5..e7706562b8 100644 --- a/openmeter/ent/db/ledgerbreakagerecord.go +++ b/openmeter/ent/db/ledgerbreakagerecord.go @@ -12,6 +12,10 @@ import ( "entgo.io/ent/dialect/sql" "github.com/alpacahq/alpacadecimal" "github.com/openmeterio/openmeter/openmeter/ent/db/ledgerbreakagerecord" + "github.com/openmeterio/openmeter/openmeter/ent/db/ledgerentry" + "github.com/openmeterio/openmeter/openmeter/ent/db/ledgersubaccount" + "github.com/openmeterio/openmeter/openmeter/ent/db/ledgertransaction" + "github.com/openmeterio/openmeter/openmeter/ent/db/ledgertransactiongroup" "github.com/openmeterio/openmeter/openmeter/ledger" "github.com/openmeterio/openmeter/pkg/currencyx" "github.com/openmeterio/openmeter/pkg/models" @@ -65,10 +69,159 @@ type LedgerBreakageRecord struct { // PlanID holds the value of the "plan_id" field. PlanID *string `json:"plan_id,omitempty"` // ReleaseID holds the value of the "release_id" field. - ReleaseID *string `json:"release_id,omitempty"` + ReleaseID *string `json:"release_id,omitempty"` + // Edges holds the relations/edges for other nodes in the graph. + // The values are being populated by the LedgerBreakageRecordQuery when eager-loading is set. + Edges LedgerBreakageRecordEdges `json:"edges"` selectValues sql.SelectValues } +// LedgerBreakageRecordEdges holds the relations/edges for other nodes in the graph. +type LedgerBreakageRecordEdges struct { + // SourceTransactionGroup holds the value of the source_transaction_group edge. + SourceTransactionGroup *LedgerTransactionGroup `json:"source_transaction_group,omitempty"` + // SourceTransaction holds the value of the source_transaction edge. + SourceTransaction *LedgerTransaction `json:"source_transaction,omitempty"` + // SourceEntry holds the value of the source_entry edge. + SourceEntry *LedgerEntry `json:"source_entry,omitempty"` + // BreakageTransactionGroup holds the value of the breakage_transaction_group edge. + BreakageTransactionGroup *LedgerTransactionGroup `json:"breakage_transaction_group,omitempty"` + // BreakageTransaction holds the value of the breakage_transaction edge. + BreakageTransaction *LedgerTransaction `json:"breakage_transaction,omitempty"` + // FboSubAccount holds the value of the fbo_sub_account edge. + FboSubAccount *LedgerSubAccount `json:"fbo_sub_account,omitempty"` + // BreakageSubAccount holds the value of the breakage_sub_account edge. + BreakageSubAccount *LedgerSubAccount `json:"breakage_sub_account,omitempty"` + // PlannedReleases holds the value of the planned_releases edge. + PlannedReleases []*LedgerBreakageRecord `json:"planned_releases,omitempty"` + // ReleaseReopens holds the value of the release_reopens edge. + ReleaseReopens []*LedgerBreakageRecord `json:"release_reopens,omitempty"` + // Plan holds the value of the plan edge. + Plan *LedgerBreakageRecord `json:"plan,omitempty"` + // Release holds the value of the release edge. + Release *LedgerBreakageRecord `json:"release,omitempty"` + // loadedTypes holds the information for reporting if a + // type was loaded (or requested) in eager-loading or not. + loadedTypes [11]bool +} + +// SourceTransactionGroupOrErr returns the SourceTransactionGroup value or an error if the edge +// was not loaded in eager-loading, or loaded but was not found. +func (e LedgerBreakageRecordEdges) SourceTransactionGroupOrErr() (*LedgerTransactionGroup, error) { + if e.SourceTransactionGroup != nil { + return e.SourceTransactionGroup, nil + } else if e.loadedTypes[0] { + return nil, &NotFoundError{label: ledgertransactiongroup.Label} + } + return nil, &NotLoadedError{edge: "source_transaction_group"} +} + +// SourceTransactionOrErr returns the SourceTransaction value or an error if the edge +// was not loaded in eager-loading, or loaded but was not found. +func (e LedgerBreakageRecordEdges) SourceTransactionOrErr() (*LedgerTransaction, error) { + if e.SourceTransaction != nil { + return e.SourceTransaction, nil + } else if e.loadedTypes[1] { + return nil, &NotFoundError{label: ledgertransaction.Label} + } + return nil, &NotLoadedError{edge: "source_transaction"} +} + +// SourceEntryOrErr returns the SourceEntry value or an error if the edge +// was not loaded in eager-loading, or loaded but was not found. +func (e LedgerBreakageRecordEdges) SourceEntryOrErr() (*LedgerEntry, error) { + if e.SourceEntry != nil { + return e.SourceEntry, nil + } else if e.loadedTypes[2] { + return nil, &NotFoundError{label: ledgerentry.Label} + } + return nil, &NotLoadedError{edge: "source_entry"} +} + +// BreakageTransactionGroupOrErr returns the BreakageTransactionGroup value or an error if the edge +// was not loaded in eager-loading, or loaded but was not found. +func (e LedgerBreakageRecordEdges) BreakageTransactionGroupOrErr() (*LedgerTransactionGroup, error) { + if e.BreakageTransactionGroup != nil { + return e.BreakageTransactionGroup, nil + } else if e.loadedTypes[3] { + return nil, &NotFoundError{label: ledgertransactiongroup.Label} + } + return nil, &NotLoadedError{edge: "breakage_transaction_group"} +} + +// BreakageTransactionOrErr returns the BreakageTransaction value or an error if the edge +// was not loaded in eager-loading, or loaded but was not found. +func (e LedgerBreakageRecordEdges) BreakageTransactionOrErr() (*LedgerTransaction, error) { + if e.BreakageTransaction != nil { + return e.BreakageTransaction, nil + } else if e.loadedTypes[4] { + return nil, &NotFoundError{label: ledgertransaction.Label} + } + return nil, &NotLoadedError{edge: "breakage_transaction"} +} + +// FboSubAccountOrErr returns the FboSubAccount value or an error if the edge +// was not loaded in eager-loading, or loaded but was not found. +func (e LedgerBreakageRecordEdges) FboSubAccountOrErr() (*LedgerSubAccount, error) { + if e.FboSubAccount != nil { + return e.FboSubAccount, nil + } else if e.loadedTypes[5] { + return nil, &NotFoundError{label: ledgersubaccount.Label} + } + return nil, &NotLoadedError{edge: "fbo_sub_account"} +} + +// BreakageSubAccountOrErr returns the BreakageSubAccount value or an error if the edge +// was not loaded in eager-loading, or loaded but was not found. +func (e LedgerBreakageRecordEdges) BreakageSubAccountOrErr() (*LedgerSubAccount, error) { + if e.BreakageSubAccount != nil { + return e.BreakageSubAccount, nil + } else if e.loadedTypes[6] { + return nil, &NotFoundError{label: ledgersubaccount.Label} + } + return nil, &NotLoadedError{edge: "breakage_sub_account"} +} + +// PlannedReleasesOrErr returns the PlannedReleases value or an error if the edge +// was not loaded in eager-loading. +func (e LedgerBreakageRecordEdges) PlannedReleasesOrErr() ([]*LedgerBreakageRecord, error) { + if e.loadedTypes[7] { + return e.PlannedReleases, nil + } + return nil, &NotLoadedError{edge: "planned_releases"} +} + +// ReleaseReopensOrErr returns the ReleaseReopens value or an error if the edge +// was not loaded in eager-loading. +func (e LedgerBreakageRecordEdges) ReleaseReopensOrErr() ([]*LedgerBreakageRecord, error) { + if e.loadedTypes[8] { + return e.ReleaseReopens, nil + } + return nil, &NotLoadedError{edge: "release_reopens"} +} + +// PlanOrErr returns the Plan value or an error if the edge +// was not loaded in eager-loading, or loaded but was not found. +func (e LedgerBreakageRecordEdges) PlanOrErr() (*LedgerBreakageRecord, error) { + if e.Plan != nil { + return e.Plan, nil + } else if e.loadedTypes[9] { + return nil, &NotFoundError{label: ledgerbreakagerecord.Label} + } + return nil, &NotLoadedError{edge: "plan"} +} + +// ReleaseOrErr returns the Release value or an error if the edge +// was not loaded in eager-loading, or loaded but was not found. +func (e LedgerBreakageRecordEdges) ReleaseOrErr() (*LedgerBreakageRecord, error) { + if e.Release != nil { + return e.Release, nil + } else if e.loadedTypes[10] { + return nil, &NotFoundError{label: ledgerbreakagerecord.Label} + } + return nil, &NotLoadedError{edge: "release"} +} + // scanValues returns the types for scanning values from sql.Rows. func (*LedgerBreakageRecord) scanValues(columns []string) ([]any, error) { values := make([]any, len(columns)) @@ -259,6 +412,61 @@ func (_m *LedgerBreakageRecord) Value(name string) (ent.Value, error) { return _m.selectValues.Get(name) } +// QuerySourceTransactionGroup queries the "source_transaction_group" edge of the LedgerBreakageRecord entity. +func (_m *LedgerBreakageRecord) QuerySourceTransactionGroup() *LedgerTransactionGroupQuery { + return NewLedgerBreakageRecordClient(_m.config).QuerySourceTransactionGroup(_m) +} + +// QuerySourceTransaction queries the "source_transaction" edge of the LedgerBreakageRecord entity. +func (_m *LedgerBreakageRecord) QuerySourceTransaction() *LedgerTransactionQuery { + return NewLedgerBreakageRecordClient(_m.config).QuerySourceTransaction(_m) +} + +// QuerySourceEntry queries the "source_entry" edge of the LedgerBreakageRecord entity. +func (_m *LedgerBreakageRecord) QuerySourceEntry() *LedgerEntryQuery { + return NewLedgerBreakageRecordClient(_m.config).QuerySourceEntry(_m) +} + +// QueryBreakageTransactionGroup queries the "breakage_transaction_group" edge of the LedgerBreakageRecord entity. +func (_m *LedgerBreakageRecord) QueryBreakageTransactionGroup() *LedgerTransactionGroupQuery { + return NewLedgerBreakageRecordClient(_m.config).QueryBreakageTransactionGroup(_m) +} + +// QueryBreakageTransaction queries the "breakage_transaction" edge of the LedgerBreakageRecord entity. +func (_m *LedgerBreakageRecord) QueryBreakageTransaction() *LedgerTransactionQuery { + return NewLedgerBreakageRecordClient(_m.config).QueryBreakageTransaction(_m) +} + +// QueryFboSubAccount queries the "fbo_sub_account" edge of the LedgerBreakageRecord entity. +func (_m *LedgerBreakageRecord) QueryFboSubAccount() *LedgerSubAccountQuery { + return NewLedgerBreakageRecordClient(_m.config).QueryFboSubAccount(_m) +} + +// QueryBreakageSubAccount queries the "breakage_sub_account" edge of the LedgerBreakageRecord entity. +func (_m *LedgerBreakageRecord) QueryBreakageSubAccount() *LedgerSubAccountQuery { + return NewLedgerBreakageRecordClient(_m.config).QueryBreakageSubAccount(_m) +} + +// QueryPlannedReleases queries the "planned_releases" edge of the LedgerBreakageRecord entity. +func (_m *LedgerBreakageRecord) QueryPlannedReleases() *LedgerBreakageRecordQuery { + return NewLedgerBreakageRecordClient(_m.config).QueryPlannedReleases(_m) +} + +// QueryReleaseReopens queries the "release_reopens" edge of the LedgerBreakageRecord entity. +func (_m *LedgerBreakageRecord) QueryReleaseReopens() *LedgerBreakageRecordQuery { + return NewLedgerBreakageRecordClient(_m.config).QueryReleaseReopens(_m) +} + +// QueryPlan queries the "plan" edge of the LedgerBreakageRecord entity. +func (_m *LedgerBreakageRecord) QueryPlan() *LedgerBreakageRecordQuery { + return NewLedgerBreakageRecordClient(_m.config).QueryPlan(_m) +} + +// QueryRelease queries the "release" edge of the LedgerBreakageRecord entity. +func (_m *LedgerBreakageRecord) QueryRelease() *LedgerBreakageRecordQuery { + return NewLedgerBreakageRecordClient(_m.config).QueryRelease(_m) +} + // Update returns a builder for updating this LedgerBreakageRecord. // Note that you need to call LedgerBreakageRecord.Unwrap() before calling this method if this LedgerBreakageRecord // was returned from a transaction, and the transaction was committed or rolled back. diff --git a/openmeter/ent/db/ledgerbreakagerecord/ledgerbreakagerecord.go b/openmeter/ent/db/ledgerbreakagerecord/ledgerbreakagerecord.go index 9f484e9fa2..9d1cb85721 100644 --- a/openmeter/ent/db/ledgerbreakagerecord/ledgerbreakagerecord.go +++ b/openmeter/ent/db/ledgerbreakagerecord/ledgerbreakagerecord.go @@ -7,6 +7,7 @@ import ( "time" "entgo.io/ent/dialect/sql" + "entgo.io/ent/dialect/sql/sqlgraph" "github.com/openmeterio/openmeter/openmeter/ledger" ) @@ -59,8 +60,95 @@ const ( FieldPlanID = "plan_id" // FieldReleaseID holds the string denoting the release_id field in the database. FieldReleaseID = "release_id" + // EdgeSourceTransactionGroup holds the string denoting the source_transaction_group edge name in mutations. + EdgeSourceTransactionGroup = "source_transaction_group" + // EdgeSourceTransaction holds the string denoting the source_transaction edge name in mutations. + EdgeSourceTransaction = "source_transaction" + // EdgeSourceEntry holds the string denoting the source_entry edge name in mutations. + EdgeSourceEntry = "source_entry" + // EdgeBreakageTransactionGroup holds the string denoting the breakage_transaction_group edge name in mutations. + EdgeBreakageTransactionGroup = "breakage_transaction_group" + // EdgeBreakageTransaction holds the string denoting the breakage_transaction edge name in mutations. + EdgeBreakageTransaction = "breakage_transaction" + // EdgeFboSubAccount holds the string denoting the fbo_sub_account edge name in mutations. + EdgeFboSubAccount = "fbo_sub_account" + // EdgeBreakageSubAccount holds the string denoting the breakage_sub_account edge name in mutations. + EdgeBreakageSubAccount = "breakage_sub_account" + // EdgePlannedReleases holds the string denoting the planned_releases edge name in mutations. + EdgePlannedReleases = "planned_releases" + // EdgeReleaseReopens holds the string denoting the release_reopens edge name in mutations. + EdgeReleaseReopens = "release_reopens" + // EdgePlan holds the string denoting the plan edge name in mutations. + EdgePlan = "plan" + // EdgeRelease holds the string denoting the release edge name in mutations. + EdgeRelease = "release" // Table holds the table name of the ledgerbreakagerecord in the database. Table = "ledger_breakage_records" + // SourceTransactionGroupTable is the table that holds the source_transaction_group relation/edge. + SourceTransactionGroupTable = "ledger_breakage_records" + // SourceTransactionGroupInverseTable is the table name for the LedgerTransactionGroup entity. + // It exists in this package in order to avoid circular dependency with the "ledgertransactiongroup" package. + SourceTransactionGroupInverseTable = "ledger_transaction_groups" + // SourceTransactionGroupColumn is the table column denoting the source_transaction_group relation/edge. + SourceTransactionGroupColumn = "source_transaction_group_id" + // SourceTransactionTable is the table that holds the source_transaction relation/edge. + SourceTransactionTable = "ledger_breakage_records" + // SourceTransactionInverseTable is the table name for the LedgerTransaction entity. + // It exists in this package in order to avoid circular dependency with the "ledgertransaction" package. + SourceTransactionInverseTable = "ledger_transactions" + // SourceTransactionColumn is the table column denoting the source_transaction relation/edge. + SourceTransactionColumn = "source_transaction_id" + // SourceEntryTable is the table that holds the source_entry relation/edge. + SourceEntryTable = "ledger_breakage_records" + // SourceEntryInverseTable is the table name for the LedgerEntry entity. + // It exists in this package in order to avoid circular dependency with the "ledgerentry" package. + SourceEntryInverseTable = "ledger_entries" + // SourceEntryColumn is the table column denoting the source_entry relation/edge. + SourceEntryColumn = "source_entry_id" + // BreakageTransactionGroupTable is the table that holds the breakage_transaction_group relation/edge. + BreakageTransactionGroupTable = "ledger_breakage_records" + // BreakageTransactionGroupInverseTable is the table name for the LedgerTransactionGroup entity. + // It exists in this package in order to avoid circular dependency with the "ledgertransactiongroup" package. + BreakageTransactionGroupInverseTable = "ledger_transaction_groups" + // BreakageTransactionGroupColumn is the table column denoting the breakage_transaction_group relation/edge. + BreakageTransactionGroupColumn = "breakage_transaction_group_id" + // BreakageTransactionTable is the table that holds the breakage_transaction relation/edge. + BreakageTransactionTable = "ledger_breakage_records" + // BreakageTransactionInverseTable is the table name for the LedgerTransaction entity. + // It exists in this package in order to avoid circular dependency with the "ledgertransaction" package. + BreakageTransactionInverseTable = "ledger_transactions" + // BreakageTransactionColumn is the table column denoting the breakage_transaction relation/edge. + BreakageTransactionColumn = "breakage_transaction_id" + // FboSubAccountTable is the table that holds the fbo_sub_account relation/edge. + FboSubAccountTable = "ledger_breakage_records" + // FboSubAccountInverseTable is the table name for the LedgerSubAccount entity. + // It exists in this package in order to avoid circular dependency with the "ledgersubaccount" package. + FboSubAccountInverseTable = "ledger_sub_accounts" + // FboSubAccountColumn is the table column denoting the fbo_sub_account relation/edge. + FboSubAccountColumn = "fbo_sub_account_id" + // BreakageSubAccountTable is the table that holds the breakage_sub_account relation/edge. + BreakageSubAccountTable = "ledger_breakage_records" + // BreakageSubAccountInverseTable is the table name for the LedgerSubAccount entity. + // It exists in this package in order to avoid circular dependency with the "ledgersubaccount" package. + BreakageSubAccountInverseTable = "ledger_sub_accounts" + // BreakageSubAccountColumn is the table column denoting the breakage_sub_account relation/edge. + BreakageSubAccountColumn = "breakage_sub_account_id" + // PlannedReleasesTable is the table that holds the planned_releases relation/edge. + PlannedReleasesTable = "ledger_breakage_records" + // PlannedReleasesColumn is the table column denoting the planned_releases relation/edge. + PlannedReleasesColumn = "plan_id" + // ReleaseReopensTable is the table that holds the release_reopens relation/edge. + ReleaseReopensTable = "ledger_breakage_records" + // ReleaseReopensColumn is the table column denoting the release_reopens relation/edge. + ReleaseReopensColumn = "release_id" + // PlanTable is the table that holds the plan relation/edge. + PlanTable = "ledger_breakage_records" + // PlanColumn is the table column denoting the plan relation/edge. + PlanColumn = "plan_id" + // ReleaseTable is the table that holds the release relation/edge. + ReleaseTable = "ledger_breakage_records" + // ReleaseColumn is the table column denoting the release relation/edge. + ReleaseColumn = "release_id" ) // Columns holds all SQL columns for ledgerbreakagerecord fields. @@ -257,3 +345,171 @@ func ByPlanID(opts ...sql.OrderTermOption) OrderOption { func ByReleaseID(opts ...sql.OrderTermOption) OrderOption { return sql.OrderByField(FieldReleaseID, opts...).ToFunc() } + +// BySourceTransactionGroupField orders the results by source_transaction_group field. +func BySourceTransactionGroupField(field string, opts ...sql.OrderTermOption) OrderOption { + return func(s *sql.Selector) { + sqlgraph.OrderByNeighborTerms(s, newSourceTransactionGroupStep(), sql.OrderByField(field, opts...)) + } +} + +// BySourceTransactionField orders the results by source_transaction field. +func BySourceTransactionField(field string, opts ...sql.OrderTermOption) OrderOption { + return func(s *sql.Selector) { + sqlgraph.OrderByNeighborTerms(s, newSourceTransactionStep(), sql.OrderByField(field, opts...)) + } +} + +// BySourceEntryField orders the results by source_entry field. +func BySourceEntryField(field string, opts ...sql.OrderTermOption) OrderOption { + return func(s *sql.Selector) { + sqlgraph.OrderByNeighborTerms(s, newSourceEntryStep(), sql.OrderByField(field, opts...)) + } +} + +// ByBreakageTransactionGroupField orders the results by breakage_transaction_group field. +func ByBreakageTransactionGroupField(field string, opts ...sql.OrderTermOption) OrderOption { + return func(s *sql.Selector) { + sqlgraph.OrderByNeighborTerms(s, newBreakageTransactionGroupStep(), sql.OrderByField(field, opts...)) + } +} + +// ByBreakageTransactionField orders the results by breakage_transaction field. +func ByBreakageTransactionField(field string, opts ...sql.OrderTermOption) OrderOption { + return func(s *sql.Selector) { + sqlgraph.OrderByNeighborTerms(s, newBreakageTransactionStep(), sql.OrderByField(field, opts...)) + } +} + +// ByFboSubAccountField orders the results by fbo_sub_account field. +func ByFboSubAccountField(field string, opts ...sql.OrderTermOption) OrderOption { + return func(s *sql.Selector) { + sqlgraph.OrderByNeighborTerms(s, newFboSubAccountStep(), sql.OrderByField(field, opts...)) + } +} + +// ByBreakageSubAccountField orders the results by breakage_sub_account field. +func ByBreakageSubAccountField(field string, opts ...sql.OrderTermOption) OrderOption { + return func(s *sql.Selector) { + sqlgraph.OrderByNeighborTerms(s, newBreakageSubAccountStep(), sql.OrderByField(field, opts...)) + } +} + +// ByPlannedReleasesCount orders the results by planned_releases count. +func ByPlannedReleasesCount(opts ...sql.OrderTermOption) OrderOption { + return func(s *sql.Selector) { + sqlgraph.OrderByNeighborsCount(s, newPlannedReleasesStep(), opts...) + } +} + +// ByPlannedReleases orders the results by planned_releases terms. +func ByPlannedReleases(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption { + return func(s *sql.Selector) { + sqlgraph.OrderByNeighborTerms(s, newPlannedReleasesStep(), append([]sql.OrderTerm{term}, terms...)...) + } +} + +// ByReleaseReopensCount orders the results by release_reopens count. +func ByReleaseReopensCount(opts ...sql.OrderTermOption) OrderOption { + return func(s *sql.Selector) { + sqlgraph.OrderByNeighborsCount(s, newReleaseReopensStep(), opts...) + } +} + +// ByReleaseReopens orders the results by release_reopens terms. +func ByReleaseReopens(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption { + return func(s *sql.Selector) { + sqlgraph.OrderByNeighborTerms(s, newReleaseReopensStep(), append([]sql.OrderTerm{term}, terms...)...) + } +} + +// ByPlanField orders the results by plan field. +func ByPlanField(field string, opts ...sql.OrderTermOption) OrderOption { + return func(s *sql.Selector) { + sqlgraph.OrderByNeighborTerms(s, newPlanStep(), sql.OrderByField(field, opts...)) + } +} + +// ByReleaseField orders the results by release field. +func ByReleaseField(field string, opts ...sql.OrderTermOption) OrderOption { + return func(s *sql.Selector) { + sqlgraph.OrderByNeighborTerms(s, newReleaseStep(), sql.OrderByField(field, opts...)) + } +} +func newSourceTransactionGroupStep() *sqlgraph.Step { + return sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.To(SourceTransactionGroupInverseTable, FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, SourceTransactionGroupTable, SourceTransactionGroupColumn), + ) +} +func newSourceTransactionStep() *sqlgraph.Step { + return sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.To(SourceTransactionInverseTable, FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, SourceTransactionTable, SourceTransactionColumn), + ) +} +func newSourceEntryStep() *sqlgraph.Step { + return sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.To(SourceEntryInverseTable, FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, SourceEntryTable, SourceEntryColumn), + ) +} +func newBreakageTransactionGroupStep() *sqlgraph.Step { + return sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.To(BreakageTransactionGroupInverseTable, FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, BreakageTransactionGroupTable, BreakageTransactionGroupColumn), + ) +} +func newBreakageTransactionStep() *sqlgraph.Step { + return sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.To(BreakageTransactionInverseTable, FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, BreakageTransactionTable, BreakageTransactionColumn), + ) +} +func newFboSubAccountStep() *sqlgraph.Step { + return sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.To(FboSubAccountInverseTable, FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, FboSubAccountTable, FboSubAccountColumn), + ) +} +func newBreakageSubAccountStep() *sqlgraph.Step { + return sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.To(BreakageSubAccountInverseTable, FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, BreakageSubAccountTable, BreakageSubAccountColumn), + ) +} +func newPlannedReleasesStep() *sqlgraph.Step { + return sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.To(Table, FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, PlannedReleasesTable, PlannedReleasesColumn), + ) +} +func newReleaseReopensStep() *sqlgraph.Step { + return sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.To(Table, FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, ReleaseReopensTable, ReleaseReopensColumn), + ) +} +func newPlanStep() *sqlgraph.Step { + return sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.To(Table, FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, PlanTable, PlanColumn), + ) +} +func newReleaseStep() *sqlgraph.Step { + return sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.To(Table, FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, ReleaseTable, ReleaseColumn), + ) +} diff --git a/openmeter/ent/db/ledgerbreakagerecord/where.go b/openmeter/ent/db/ledgerbreakagerecord/where.go index a8a8f7f6a4..9013293bbf 100644 --- a/openmeter/ent/db/ledgerbreakagerecord/where.go +++ b/openmeter/ent/db/ledgerbreakagerecord/where.go @@ -6,6 +6,7 @@ import ( "time" "entgo.io/ent/dialect/sql" + "entgo.io/ent/dialect/sql/sqlgraph" "github.com/alpacahq/alpacadecimal" "github.com/openmeterio/openmeter/openmeter/ent/db/predicate" "github.com/openmeterio/openmeter/openmeter/ledger" @@ -1407,6 +1408,259 @@ func ReleaseIDContainsFold(v string) predicate.LedgerBreakageRecord { return predicate.LedgerBreakageRecord(sql.FieldContainsFold(FieldReleaseID, v)) } +// HasSourceTransactionGroup applies the HasEdge predicate on the "source_transaction_group" edge. +func HasSourceTransactionGroup() predicate.LedgerBreakageRecord { + return predicate.LedgerBreakageRecord(func(s *sql.Selector) { + step := sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, SourceTransactionGroupTable, SourceTransactionGroupColumn), + ) + sqlgraph.HasNeighbors(s, step) + }) +} + +// HasSourceTransactionGroupWith applies the HasEdge predicate on the "source_transaction_group" edge with a given conditions (other predicates). +func HasSourceTransactionGroupWith(preds ...predicate.LedgerTransactionGroup) predicate.LedgerBreakageRecord { + return predicate.LedgerBreakageRecord(func(s *sql.Selector) { + step := newSourceTransactionGroupStep() + sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) { + for _, p := range preds { + p(s) + } + }) + }) +} + +// HasSourceTransaction applies the HasEdge predicate on the "source_transaction" edge. +func HasSourceTransaction() predicate.LedgerBreakageRecord { + return predicate.LedgerBreakageRecord(func(s *sql.Selector) { + step := sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, SourceTransactionTable, SourceTransactionColumn), + ) + sqlgraph.HasNeighbors(s, step) + }) +} + +// HasSourceTransactionWith applies the HasEdge predicate on the "source_transaction" edge with a given conditions (other predicates). +func HasSourceTransactionWith(preds ...predicate.LedgerTransaction) predicate.LedgerBreakageRecord { + return predicate.LedgerBreakageRecord(func(s *sql.Selector) { + step := newSourceTransactionStep() + sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) { + for _, p := range preds { + p(s) + } + }) + }) +} + +// HasSourceEntry applies the HasEdge predicate on the "source_entry" edge. +func HasSourceEntry() predicate.LedgerBreakageRecord { + return predicate.LedgerBreakageRecord(func(s *sql.Selector) { + step := sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, SourceEntryTable, SourceEntryColumn), + ) + sqlgraph.HasNeighbors(s, step) + }) +} + +// HasSourceEntryWith applies the HasEdge predicate on the "source_entry" edge with a given conditions (other predicates). +func HasSourceEntryWith(preds ...predicate.LedgerEntry) predicate.LedgerBreakageRecord { + return predicate.LedgerBreakageRecord(func(s *sql.Selector) { + step := newSourceEntryStep() + sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) { + for _, p := range preds { + p(s) + } + }) + }) +} + +// HasBreakageTransactionGroup applies the HasEdge predicate on the "breakage_transaction_group" edge. +func HasBreakageTransactionGroup() predicate.LedgerBreakageRecord { + return predicate.LedgerBreakageRecord(func(s *sql.Selector) { + step := sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, BreakageTransactionGroupTable, BreakageTransactionGroupColumn), + ) + sqlgraph.HasNeighbors(s, step) + }) +} + +// HasBreakageTransactionGroupWith applies the HasEdge predicate on the "breakage_transaction_group" edge with a given conditions (other predicates). +func HasBreakageTransactionGroupWith(preds ...predicate.LedgerTransactionGroup) predicate.LedgerBreakageRecord { + return predicate.LedgerBreakageRecord(func(s *sql.Selector) { + step := newBreakageTransactionGroupStep() + sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) { + for _, p := range preds { + p(s) + } + }) + }) +} + +// HasBreakageTransaction applies the HasEdge predicate on the "breakage_transaction" edge. +func HasBreakageTransaction() predicate.LedgerBreakageRecord { + return predicate.LedgerBreakageRecord(func(s *sql.Selector) { + step := sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, BreakageTransactionTable, BreakageTransactionColumn), + ) + sqlgraph.HasNeighbors(s, step) + }) +} + +// HasBreakageTransactionWith applies the HasEdge predicate on the "breakage_transaction" edge with a given conditions (other predicates). +func HasBreakageTransactionWith(preds ...predicate.LedgerTransaction) predicate.LedgerBreakageRecord { + return predicate.LedgerBreakageRecord(func(s *sql.Selector) { + step := newBreakageTransactionStep() + sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) { + for _, p := range preds { + p(s) + } + }) + }) +} + +// HasFboSubAccount applies the HasEdge predicate on the "fbo_sub_account" edge. +func HasFboSubAccount() predicate.LedgerBreakageRecord { + return predicate.LedgerBreakageRecord(func(s *sql.Selector) { + step := sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, FboSubAccountTable, FboSubAccountColumn), + ) + sqlgraph.HasNeighbors(s, step) + }) +} + +// HasFboSubAccountWith applies the HasEdge predicate on the "fbo_sub_account" edge with a given conditions (other predicates). +func HasFboSubAccountWith(preds ...predicate.LedgerSubAccount) predicate.LedgerBreakageRecord { + return predicate.LedgerBreakageRecord(func(s *sql.Selector) { + step := newFboSubAccountStep() + sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) { + for _, p := range preds { + p(s) + } + }) + }) +} + +// HasBreakageSubAccount applies the HasEdge predicate on the "breakage_sub_account" edge. +func HasBreakageSubAccount() predicate.LedgerBreakageRecord { + return predicate.LedgerBreakageRecord(func(s *sql.Selector) { + step := sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, BreakageSubAccountTable, BreakageSubAccountColumn), + ) + sqlgraph.HasNeighbors(s, step) + }) +} + +// HasBreakageSubAccountWith applies the HasEdge predicate on the "breakage_sub_account" edge with a given conditions (other predicates). +func HasBreakageSubAccountWith(preds ...predicate.LedgerSubAccount) predicate.LedgerBreakageRecord { + return predicate.LedgerBreakageRecord(func(s *sql.Selector) { + step := newBreakageSubAccountStep() + sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) { + for _, p := range preds { + p(s) + } + }) + }) +} + +// HasPlannedReleases applies the HasEdge predicate on the "planned_releases" edge. +func HasPlannedReleases() predicate.LedgerBreakageRecord { + return predicate.LedgerBreakageRecord(func(s *sql.Selector) { + step := sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, PlannedReleasesTable, PlannedReleasesColumn), + ) + sqlgraph.HasNeighbors(s, step) + }) +} + +// HasPlannedReleasesWith applies the HasEdge predicate on the "planned_releases" edge with a given conditions (other predicates). +func HasPlannedReleasesWith(preds ...predicate.LedgerBreakageRecord) predicate.LedgerBreakageRecord { + return predicate.LedgerBreakageRecord(func(s *sql.Selector) { + step := newPlannedReleasesStep() + sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) { + for _, p := range preds { + p(s) + } + }) + }) +} + +// HasReleaseReopens applies the HasEdge predicate on the "release_reopens" edge. +func HasReleaseReopens() predicate.LedgerBreakageRecord { + return predicate.LedgerBreakageRecord(func(s *sql.Selector) { + step := sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, ReleaseReopensTable, ReleaseReopensColumn), + ) + sqlgraph.HasNeighbors(s, step) + }) +} + +// HasReleaseReopensWith applies the HasEdge predicate on the "release_reopens" edge with a given conditions (other predicates). +func HasReleaseReopensWith(preds ...predicate.LedgerBreakageRecord) predicate.LedgerBreakageRecord { + return predicate.LedgerBreakageRecord(func(s *sql.Selector) { + step := newReleaseReopensStep() + sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) { + for _, p := range preds { + p(s) + } + }) + }) +} + +// HasPlan applies the HasEdge predicate on the "plan" edge. +func HasPlan() predicate.LedgerBreakageRecord { + return predicate.LedgerBreakageRecord(func(s *sql.Selector) { + step := sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, PlanTable, PlanColumn), + ) + sqlgraph.HasNeighbors(s, step) + }) +} + +// HasPlanWith applies the HasEdge predicate on the "plan" edge with a given conditions (other predicates). +func HasPlanWith(preds ...predicate.LedgerBreakageRecord) predicate.LedgerBreakageRecord { + return predicate.LedgerBreakageRecord(func(s *sql.Selector) { + step := newPlanStep() + sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) { + for _, p := range preds { + p(s) + } + }) + }) +} + +// HasRelease applies the HasEdge predicate on the "release" edge. +func HasRelease() predicate.LedgerBreakageRecord { + return predicate.LedgerBreakageRecord(func(s *sql.Selector) { + step := sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, ReleaseTable, ReleaseColumn), + ) + sqlgraph.HasNeighbors(s, step) + }) +} + +// HasReleaseWith applies the HasEdge predicate on the "release" edge with a given conditions (other predicates). +func HasReleaseWith(preds ...predicate.LedgerBreakageRecord) predicate.LedgerBreakageRecord { + return predicate.LedgerBreakageRecord(func(s *sql.Selector) { + step := newReleaseStep() + sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) { + for _, p := range preds { + p(s) + } + }) + }) +} + // And groups predicates with the AND operator between them. func And(predicates ...predicate.LedgerBreakageRecord) predicate.LedgerBreakageRecord { return predicate.LedgerBreakageRecord(sql.AndPredicates(predicates...)) diff --git a/openmeter/ent/db/ledgerbreakagerecord_create.go b/openmeter/ent/db/ledgerbreakagerecord_create.go index d7da9c935d..c4522ae57e 100644 --- a/openmeter/ent/db/ledgerbreakagerecord_create.go +++ b/openmeter/ent/db/ledgerbreakagerecord_create.go @@ -14,6 +14,10 @@ import ( "entgo.io/ent/schema/field" "github.com/alpacahq/alpacadecimal" "github.com/openmeterio/openmeter/openmeter/ent/db/ledgerbreakagerecord" + "github.com/openmeterio/openmeter/openmeter/ent/db/ledgerentry" + "github.com/openmeterio/openmeter/openmeter/ent/db/ledgersubaccount" + "github.com/openmeterio/openmeter/openmeter/ent/db/ledgertransaction" + "github.com/openmeterio/openmeter/openmeter/ent/db/ledgertransactiongroup" "github.com/openmeterio/openmeter/openmeter/ledger" "github.com/openmeterio/openmeter/pkg/currencyx" "github.com/openmeterio/openmeter/pkg/models" @@ -245,6 +249,81 @@ func (_c *LedgerBreakageRecordCreate) SetNillableID(v *string) *LedgerBreakageRe return _c } +// SetSourceTransactionGroup sets the "source_transaction_group" edge to the LedgerTransactionGroup entity. +func (_c *LedgerBreakageRecordCreate) SetSourceTransactionGroup(v *LedgerTransactionGroup) *LedgerBreakageRecordCreate { + return _c.SetSourceTransactionGroupID(v.ID) +} + +// SetSourceTransaction sets the "source_transaction" edge to the LedgerTransaction entity. +func (_c *LedgerBreakageRecordCreate) SetSourceTransaction(v *LedgerTransaction) *LedgerBreakageRecordCreate { + return _c.SetSourceTransactionID(v.ID) +} + +// SetSourceEntry sets the "source_entry" edge to the LedgerEntry entity. +func (_c *LedgerBreakageRecordCreate) SetSourceEntry(v *LedgerEntry) *LedgerBreakageRecordCreate { + return _c.SetSourceEntryID(v.ID) +} + +// SetBreakageTransactionGroup sets the "breakage_transaction_group" edge to the LedgerTransactionGroup entity. +func (_c *LedgerBreakageRecordCreate) SetBreakageTransactionGroup(v *LedgerTransactionGroup) *LedgerBreakageRecordCreate { + return _c.SetBreakageTransactionGroupID(v.ID) +} + +// SetBreakageTransaction sets the "breakage_transaction" edge to the LedgerTransaction entity. +func (_c *LedgerBreakageRecordCreate) SetBreakageTransaction(v *LedgerTransaction) *LedgerBreakageRecordCreate { + return _c.SetBreakageTransactionID(v.ID) +} + +// SetFboSubAccount sets the "fbo_sub_account" edge to the LedgerSubAccount entity. +func (_c *LedgerBreakageRecordCreate) SetFboSubAccount(v *LedgerSubAccount) *LedgerBreakageRecordCreate { + return _c.SetFboSubAccountID(v.ID) +} + +// SetBreakageSubAccount sets the "breakage_sub_account" edge to the LedgerSubAccount entity. +func (_c *LedgerBreakageRecordCreate) SetBreakageSubAccount(v *LedgerSubAccount) *LedgerBreakageRecordCreate { + return _c.SetBreakageSubAccountID(v.ID) +} + +// AddPlannedReleaseIDs adds the "planned_releases" edge to the LedgerBreakageRecord entity by IDs. +func (_c *LedgerBreakageRecordCreate) AddPlannedReleaseIDs(ids ...string) *LedgerBreakageRecordCreate { + _c.mutation.AddPlannedReleaseIDs(ids...) + return _c +} + +// AddPlannedReleases adds the "planned_releases" edges to the LedgerBreakageRecord entity. +func (_c *LedgerBreakageRecordCreate) AddPlannedReleases(v ...*LedgerBreakageRecord) *LedgerBreakageRecordCreate { + ids := make([]string, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _c.AddPlannedReleaseIDs(ids...) +} + +// AddReleaseReopenIDs adds the "release_reopens" edge to the LedgerBreakageRecord entity by IDs. +func (_c *LedgerBreakageRecordCreate) AddReleaseReopenIDs(ids ...string) *LedgerBreakageRecordCreate { + _c.mutation.AddReleaseReopenIDs(ids...) + return _c +} + +// AddReleaseReopens adds the "release_reopens" edges to the LedgerBreakageRecord entity. +func (_c *LedgerBreakageRecordCreate) AddReleaseReopens(v ...*LedgerBreakageRecord) *LedgerBreakageRecordCreate { + ids := make([]string, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _c.AddReleaseReopenIDs(ids...) +} + +// SetPlan sets the "plan" edge to the LedgerBreakageRecord entity. +func (_c *LedgerBreakageRecordCreate) SetPlan(v *LedgerBreakageRecord) *LedgerBreakageRecordCreate { + return _c.SetPlanID(v.ID) +} + +// SetRelease sets the "release" edge to the LedgerBreakageRecord entity. +func (_c *LedgerBreakageRecordCreate) SetRelease(v *LedgerBreakageRecord) *LedgerBreakageRecordCreate { + return _c.SetReleaseID(v.ID) +} + // Mutation returns the LedgerBreakageRecordMutation object of the builder. func (_c *LedgerBreakageRecordCreate) Mutation() *LedgerBreakageRecordMutation { return _c.mutation @@ -383,6 +462,18 @@ func (_c *LedgerBreakageRecordCreate) check() error { return &ValidationError{Name: "breakage_sub_account_id", err: fmt.Errorf(`db: validator failed for field "LedgerBreakageRecord.breakage_sub_account_id": %w`, err)} } } + if len(_c.mutation.BreakageTransactionGroupIDs()) == 0 { + return &ValidationError{Name: "breakage_transaction_group", err: errors.New(`db: missing required edge "LedgerBreakageRecord.breakage_transaction_group"`)} + } + if len(_c.mutation.BreakageTransactionIDs()) == 0 { + return &ValidationError{Name: "breakage_transaction", err: errors.New(`db: missing required edge "LedgerBreakageRecord.breakage_transaction"`)} + } + if len(_c.mutation.FboSubAccountIDs()) == 0 { + return &ValidationError{Name: "fbo_sub_account", err: errors.New(`db: missing required edge "LedgerBreakageRecord.fbo_sub_account"`)} + } + if len(_c.mutation.BreakageSubAccountIDs()) == 0 { + return &ValidationError{Name: "breakage_sub_account", err: errors.New(`db: missing required edge "LedgerBreakageRecord.breakage_sub_account"`)} + } return nil } @@ -471,41 +562,190 @@ func (_c *LedgerBreakageRecordCreate) createSpec() (*LedgerBreakageRecord, *sqlg _spec.SetField(ledgerbreakagerecord.FieldSourceChargeID, field.TypeString, value) _node.SourceChargeID = &value } - if value, ok := _c.mutation.SourceTransactionGroupID(); ok { - _spec.SetField(ledgerbreakagerecord.FieldSourceTransactionGroupID, field.TypeString, value) - _node.SourceTransactionGroupID = &value - } - if value, ok := _c.mutation.SourceTransactionID(); ok { - _spec.SetField(ledgerbreakagerecord.FieldSourceTransactionID, field.TypeString, value) - _node.SourceTransactionID = &value - } - if value, ok := _c.mutation.SourceEntryID(); ok { - _spec.SetField(ledgerbreakagerecord.FieldSourceEntryID, field.TypeString, value) - _node.SourceEntryID = &value - } - if value, ok := _c.mutation.BreakageTransactionGroupID(); ok { - _spec.SetField(ledgerbreakagerecord.FieldBreakageTransactionGroupID, field.TypeString, value) - _node.BreakageTransactionGroupID = value - } - if value, ok := _c.mutation.BreakageTransactionID(); ok { - _spec.SetField(ledgerbreakagerecord.FieldBreakageTransactionID, field.TypeString, value) - _node.BreakageTransactionID = value - } - if value, ok := _c.mutation.FboSubAccountID(); ok { - _spec.SetField(ledgerbreakagerecord.FieldFboSubAccountID, field.TypeString, value) - _node.FboSubAccountID = value - } - if value, ok := _c.mutation.BreakageSubAccountID(); ok { - _spec.SetField(ledgerbreakagerecord.FieldBreakageSubAccountID, field.TypeString, value) - _node.BreakageSubAccountID = value - } - if value, ok := _c.mutation.PlanID(); ok { - _spec.SetField(ledgerbreakagerecord.FieldPlanID, field.TypeString, value) - _node.PlanID = &value - } - if value, ok := _c.mutation.ReleaseID(); ok { - _spec.SetField(ledgerbreakagerecord.FieldReleaseID, field.TypeString, value) - _node.ReleaseID = &value + if nodes := _c.mutation.SourceTransactionGroupIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.M2O, + Inverse: true, + Table: ledgerbreakagerecord.SourceTransactionGroupTable, + Columns: []string{ledgerbreakagerecord.SourceTransactionGroupColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgertransactiongroup.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _node.SourceTransactionGroupID = &nodes[0] + _spec.Edges = append(_spec.Edges, edge) + } + if nodes := _c.mutation.SourceTransactionIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.M2O, + Inverse: true, + Table: ledgerbreakagerecord.SourceTransactionTable, + Columns: []string{ledgerbreakagerecord.SourceTransactionColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgertransaction.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _node.SourceTransactionID = &nodes[0] + _spec.Edges = append(_spec.Edges, edge) + } + if nodes := _c.mutation.SourceEntryIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.M2O, + Inverse: true, + Table: ledgerbreakagerecord.SourceEntryTable, + Columns: []string{ledgerbreakagerecord.SourceEntryColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerentry.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _node.SourceEntryID = &nodes[0] + _spec.Edges = append(_spec.Edges, edge) + } + if nodes := _c.mutation.BreakageTransactionGroupIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.M2O, + Inverse: true, + Table: ledgerbreakagerecord.BreakageTransactionGroupTable, + Columns: []string{ledgerbreakagerecord.BreakageTransactionGroupColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgertransactiongroup.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _node.BreakageTransactionGroupID = nodes[0] + _spec.Edges = append(_spec.Edges, edge) + } + if nodes := _c.mutation.BreakageTransactionIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.M2O, + Inverse: true, + Table: ledgerbreakagerecord.BreakageTransactionTable, + Columns: []string{ledgerbreakagerecord.BreakageTransactionColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgertransaction.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _node.BreakageTransactionID = nodes[0] + _spec.Edges = append(_spec.Edges, edge) + } + if nodes := _c.mutation.FboSubAccountIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.M2O, + Inverse: true, + Table: ledgerbreakagerecord.FboSubAccountTable, + Columns: []string{ledgerbreakagerecord.FboSubAccountColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgersubaccount.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _node.FboSubAccountID = nodes[0] + _spec.Edges = append(_spec.Edges, edge) + } + if nodes := _c.mutation.BreakageSubAccountIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.M2O, + Inverse: true, + Table: ledgerbreakagerecord.BreakageSubAccountTable, + Columns: []string{ledgerbreakagerecord.BreakageSubAccountColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgersubaccount.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _node.BreakageSubAccountID = nodes[0] + _spec.Edges = append(_spec.Edges, edge) + } + if nodes := _c.mutation.PlannedReleasesIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgerbreakagerecord.PlannedReleasesTable, + Columns: []string{ledgerbreakagerecord.PlannedReleasesColumn}, + Bidi: true, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges = append(_spec.Edges, edge) + } + if nodes := _c.mutation.ReleaseReopensIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgerbreakagerecord.ReleaseReopensTable, + Columns: []string{ledgerbreakagerecord.ReleaseReopensColumn}, + Bidi: true, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges = append(_spec.Edges, edge) + } + if nodes := _c.mutation.PlanIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.M2O, + Inverse: true, + Table: ledgerbreakagerecord.PlanTable, + Columns: []string{ledgerbreakagerecord.PlanColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _node.PlanID = &nodes[0] + _spec.Edges = append(_spec.Edges, edge) + } + if nodes := _c.mutation.ReleaseIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.M2O, + Inverse: true, + Table: ledgerbreakagerecord.ReleaseTable, + Columns: []string{ledgerbreakagerecord.ReleaseColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _node.ReleaseID = &nodes[0] + _spec.Edges = append(_spec.Edges, edge) } return _node, _spec } diff --git a/openmeter/ent/db/ledgerbreakagerecord_query.go b/openmeter/ent/db/ledgerbreakagerecord_query.go index ad947e8707..21d7bb3f40 100644 --- a/openmeter/ent/db/ledgerbreakagerecord_query.go +++ b/openmeter/ent/db/ledgerbreakagerecord_query.go @@ -4,6 +4,7 @@ package db import ( "context" + "database/sql/driver" "fmt" "math" @@ -13,17 +14,32 @@ import ( "entgo.io/ent/dialect/sql/sqlgraph" "entgo.io/ent/schema/field" "github.com/openmeterio/openmeter/openmeter/ent/db/ledgerbreakagerecord" + "github.com/openmeterio/openmeter/openmeter/ent/db/ledgerentry" + "github.com/openmeterio/openmeter/openmeter/ent/db/ledgersubaccount" + "github.com/openmeterio/openmeter/openmeter/ent/db/ledgertransaction" + "github.com/openmeterio/openmeter/openmeter/ent/db/ledgertransactiongroup" "github.com/openmeterio/openmeter/openmeter/ent/db/predicate" ) // LedgerBreakageRecordQuery is the builder for querying LedgerBreakageRecord entities. type LedgerBreakageRecordQuery struct { config - ctx *QueryContext - order []ledgerbreakagerecord.OrderOption - inters []Interceptor - predicates []predicate.LedgerBreakageRecord - modifiers []func(*sql.Selector) + ctx *QueryContext + order []ledgerbreakagerecord.OrderOption + inters []Interceptor + predicates []predicate.LedgerBreakageRecord + withSourceTransactionGroup *LedgerTransactionGroupQuery + withSourceTransaction *LedgerTransactionQuery + withSourceEntry *LedgerEntryQuery + withBreakageTransactionGroup *LedgerTransactionGroupQuery + withBreakageTransaction *LedgerTransactionQuery + withFboSubAccount *LedgerSubAccountQuery + withBreakageSubAccount *LedgerSubAccountQuery + withPlannedReleases *LedgerBreakageRecordQuery + withReleaseReopens *LedgerBreakageRecordQuery + withPlan *LedgerBreakageRecordQuery + withRelease *LedgerBreakageRecordQuery + modifiers []func(*sql.Selector) // intermediate query (i.e. traversal path). sql *sql.Selector path func(context.Context) (*sql.Selector, error) @@ -60,6 +76,248 @@ func (_q *LedgerBreakageRecordQuery) Order(o ...ledgerbreakagerecord.OrderOption return _q } +// QuerySourceTransactionGroup chains the current query on the "source_transaction_group" edge. +func (_q *LedgerBreakageRecordQuery) QuerySourceTransactionGroup() *LedgerTransactionGroupQuery { + query := (&LedgerTransactionGroupClient{config: _q.config}).Query() + query.path = func(ctx context.Context) (fromU *sql.Selector, err error) { + if err := _q.prepareQuery(ctx); err != nil { + return nil, err + } + selector := _q.sqlQuery(ctx) + if err := selector.Err(); err != nil { + return nil, err + } + step := sqlgraph.NewStep( + sqlgraph.From(ledgerbreakagerecord.Table, ledgerbreakagerecord.FieldID, selector), + sqlgraph.To(ledgertransactiongroup.Table, ledgertransactiongroup.FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, ledgerbreakagerecord.SourceTransactionGroupTable, ledgerbreakagerecord.SourceTransactionGroupColumn), + ) + fromU = sqlgraph.SetNeighbors(_q.driver.Dialect(), step) + return fromU, nil + } + return query +} + +// QuerySourceTransaction chains the current query on the "source_transaction" edge. +func (_q *LedgerBreakageRecordQuery) QuerySourceTransaction() *LedgerTransactionQuery { + query := (&LedgerTransactionClient{config: _q.config}).Query() + query.path = func(ctx context.Context) (fromU *sql.Selector, err error) { + if err := _q.prepareQuery(ctx); err != nil { + return nil, err + } + selector := _q.sqlQuery(ctx) + if err := selector.Err(); err != nil { + return nil, err + } + step := sqlgraph.NewStep( + sqlgraph.From(ledgerbreakagerecord.Table, ledgerbreakagerecord.FieldID, selector), + sqlgraph.To(ledgertransaction.Table, ledgertransaction.FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, ledgerbreakagerecord.SourceTransactionTable, ledgerbreakagerecord.SourceTransactionColumn), + ) + fromU = sqlgraph.SetNeighbors(_q.driver.Dialect(), step) + return fromU, nil + } + return query +} + +// QuerySourceEntry chains the current query on the "source_entry" edge. +func (_q *LedgerBreakageRecordQuery) QuerySourceEntry() *LedgerEntryQuery { + query := (&LedgerEntryClient{config: _q.config}).Query() + query.path = func(ctx context.Context) (fromU *sql.Selector, err error) { + if err := _q.prepareQuery(ctx); err != nil { + return nil, err + } + selector := _q.sqlQuery(ctx) + if err := selector.Err(); err != nil { + return nil, err + } + step := sqlgraph.NewStep( + sqlgraph.From(ledgerbreakagerecord.Table, ledgerbreakagerecord.FieldID, selector), + sqlgraph.To(ledgerentry.Table, ledgerentry.FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, ledgerbreakagerecord.SourceEntryTable, ledgerbreakagerecord.SourceEntryColumn), + ) + fromU = sqlgraph.SetNeighbors(_q.driver.Dialect(), step) + return fromU, nil + } + return query +} + +// QueryBreakageTransactionGroup chains the current query on the "breakage_transaction_group" edge. +func (_q *LedgerBreakageRecordQuery) QueryBreakageTransactionGroup() *LedgerTransactionGroupQuery { + query := (&LedgerTransactionGroupClient{config: _q.config}).Query() + query.path = func(ctx context.Context) (fromU *sql.Selector, err error) { + if err := _q.prepareQuery(ctx); err != nil { + return nil, err + } + selector := _q.sqlQuery(ctx) + if err := selector.Err(); err != nil { + return nil, err + } + step := sqlgraph.NewStep( + sqlgraph.From(ledgerbreakagerecord.Table, ledgerbreakagerecord.FieldID, selector), + sqlgraph.To(ledgertransactiongroup.Table, ledgertransactiongroup.FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, ledgerbreakagerecord.BreakageTransactionGroupTable, ledgerbreakagerecord.BreakageTransactionGroupColumn), + ) + fromU = sqlgraph.SetNeighbors(_q.driver.Dialect(), step) + return fromU, nil + } + return query +} + +// QueryBreakageTransaction chains the current query on the "breakage_transaction" edge. +func (_q *LedgerBreakageRecordQuery) QueryBreakageTransaction() *LedgerTransactionQuery { + query := (&LedgerTransactionClient{config: _q.config}).Query() + query.path = func(ctx context.Context) (fromU *sql.Selector, err error) { + if err := _q.prepareQuery(ctx); err != nil { + return nil, err + } + selector := _q.sqlQuery(ctx) + if err := selector.Err(); err != nil { + return nil, err + } + step := sqlgraph.NewStep( + sqlgraph.From(ledgerbreakagerecord.Table, ledgerbreakagerecord.FieldID, selector), + sqlgraph.To(ledgertransaction.Table, ledgertransaction.FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, ledgerbreakagerecord.BreakageTransactionTable, ledgerbreakagerecord.BreakageTransactionColumn), + ) + fromU = sqlgraph.SetNeighbors(_q.driver.Dialect(), step) + return fromU, nil + } + return query +} + +// QueryFboSubAccount chains the current query on the "fbo_sub_account" edge. +func (_q *LedgerBreakageRecordQuery) QueryFboSubAccount() *LedgerSubAccountQuery { + query := (&LedgerSubAccountClient{config: _q.config}).Query() + query.path = func(ctx context.Context) (fromU *sql.Selector, err error) { + if err := _q.prepareQuery(ctx); err != nil { + return nil, err + } + selector := _q.sqlQuery(ctx) + if err := selector.Err(); err != nil { + return nil, err + } + step := sqlgraph.NewStep( + sqlgraph.From(ledgerbreakagerecord.Table, ledgerbreakagerecord.FieldID, selector), + sqlgraph.To(ledgersubaccount.Table, ledgersubaccount.FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, ledgerbreakagerecord.FboSubAccountTable, ledgerbreakagerecord.FboSubAccountColumn), + ) + fromU = sqlgraph.SetNeighbors(_q.driver.Dialect(), step) + return fromU, nil + } + return query +} + +// QueryBreakageSubAccount chains the current query on the "breakage_sub_account" edge. +func (_q *LedgerBreakageRecordQuery) QueryBreakageSubAccount() *LedgerSubAccountQuery { + query := (&LedgerSubAccountClient{config: _q.config}).Query() + query.path = func(ctx context.Context) (fromU *sql.Selector, err error) { + if err := _q.prepareQuery(ctx); err != nil { + return nil, err + } + selector := _q.sqlQuery(ctx) + if err := selector.Err(); err != nil { + return nil, err + } + step := sqlgraph.NewStep( + sqlgraph.From(ledgerbreakagerecord.Table, ledgerbreakagerecord.FieldID, selector), + sqlgraph.To(ledgersubaccount.Table, ledgersubaccount.FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, ledgerbreakagerecord.BreakageSubAccountTable, ledgerbreakagerecord.BreakageSubAccountColumn), + ) + fromU = sqlgraph.SetNeighbors(_q.driver.Dialect(), step) + return fromU, nil + } + return query +} + +// QueryPlannedReleases chains the current query on the "planned_releases" edge. +func (_q *LedgerBreakageRecordQuery) QueryPlannedReleases() *LedgerBreakageRecordQuery { + query := (&LedgerBreakageRecordClient{config: _q.config}).Query() + query.path = func(ctx context.Context) (fromU *sql.Selector, err error) { + if err := _q.prepareQuery(ctx); err != nil { + return nil, err + } + selector := _q.sqlQuery(ctx) + if err := selector.Err(); err != nil { + return nil, err + } + step := sqlgraph.NewStep( + sqlgraph.From(ledgerbreakagerecord.Table, ledgerbreakagerecord.FieldID, selector), + sqlgraph.To(ledgerbreakagerecord.Table, ledgerbreakagerecord.FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, ledgerbreakagerecord.PlannedReleasesTable, ledgerbreakagerecord.PlannedReleasesColumn), + ) + fromU = sqlgraph.SetNeighbors(_q.driver.Dialect(), step) + return fromU, nil + } + return query +} + +// QueryReleaseReopens chains the current query on the "release_reopens" edge. +func (_q *LedgerBreakageRecordQuery) QueryReleaseReopens() *LedgerBreakageRecordQuery { + query := (&LedgerBreakageRecordClient{config: _q.config}).Query() + query.path = func(ctx context.Context) (fromU *sql.Selector, err error) { + if err := _q.prepareQuery(ctx); err != nil { + return nil, err + } + selector := _q.sqlQuery(ctx) + if err := selector.Err(); err != nil { + return nil, err + } + step := sqlgraph.NewStep( + sqlgraph.From(ledgerbreakagerecord.Table, ledgerbreakagerecord.FieldID, selector), + sqlgraph.To(ledgerbreakagerecord.Table, ledgerbreakagerecord.FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, ledgerbreakagerecord.ReleaseReopensTable, ledgerbreakagerecord.ReleaseReopensColumn), + ) + fromU = sqlgraph.SetNeighbors(_q.driver.Dialect(), step) + return fromU, nil + } + return query +} + +// QueryPlan chains the current query on the "plan" edge. +func (_q *LedgerBreakageRecordQuery) QueryPlan() *LedgerBreakageRecordQuery { + query := (&LedgerBreakageRecordClient{config: _q.config}).Query() + query.path = func(ctx context.Context) (fromU *sql.Selector, err error) { + if err := _q.prepareQuery(ctx); err != nil { + return nil, err + } + selector := _q.sqlQuery(ctx) + if err := selector.Err(); err != nil { + return nil, err + } + step := sqlgraph.NewStep( + sqlgraph.From(ledgerbreakagerecord.Table, ledgerbreakagerecord.FieldID, selector), + sqlgraph.To(ledgerbreakagerecord.Table, ledgerbreakagerecord.FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, ledgerbreakagerecord.PlanTable, ledgerbreakagerecord.PlanColumn), + ) + fromU = sqlgraph.SetNeighbors(_q.driver.Dialect(), step) + return fromU, nil + } + return query +} + +// QueryRelease chains the current query on the "release" edge. +func (_q *LedgerBreakageRecordQuery) QueryRelease() *LedgerBreakageRecordQuery { + query := (&LedgerBreakageRecordClient{config: _q.config}).Query() + query.path = func(ctx context.Context) (fromU *sql.Selector, err error) { + if err := _q.prepareQuery(ctx); err != nil { + return nil, err + } + selector := _q.sqlQuery(ctx) + if err := selector.Err(); err != nil { + return nil, err + } + step := sqlgraph.NewStep( + sqlgraph.From(ledgerbreakagerecord.Table, ledgerbreakagerecord.FieldID, selector), + sqlgraph.To(ledgerbreakagerecord.Table, ledgerbreakagerecord.FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, ledgerbreakagerecord.ReleaseTable, ledgerbreakagerecord.ReleaseColumn), + ) + fromU = sqlgraph.SetNeighbors(_q.driver.Dialect(), step) + return fromU, nil + } + return query +} + // First returns the first LedgerBreakageRecord entity from the query. // Returns a *NotFoundError when no LedgerBreakageRecord was found. func (_q *LedgerBreakageRecordQuery) First(ctx context.Context) (*LedgerBreakageRecord, error) { @@ -247,17 +505,149 @@ func (_q *LedgerBreakageRecordQuery) Clone() *LedgerBreakageRecordQuery { return nil } return &LedgerBreakageRecordQuery{ - config: _q.config, - ctx: _q.ctx.Clone(), - order: append([]ledgerbreakagerecord.OrderOption{}, _q.order...), - inters: append([]Interceptor{}, _q.inters...), - predicates: append([]predicate.LedgerBreakageRecord{}, _q.predicates...), + config: _q.config, + ctx: _q.ctx.Clone(), + order: append([]ledgerbreakagerecord.OrderOption{}, _q.order...), + inters: append([]Interceptor{}, _q.inters...), + predicates: append([]predicate.LedgerBreakageRecord{}, _q.predicates...), + withSourceTransactionGroup: _q.withSourceTransactionGroup.Clone(), + withSourceTransaction: _q.withSourceTransaction.Clone(), + withSourceEntry: _q.withSourceEntry.Clone(), + withBreakageTransactionGroup: _q.withBreakageTransactionGroup.Clone(), + withBreakageTransaction: _q.withBreakageTransaction.Clone(), + withFboSubAccount: _q.withFboSubAccount.Clone(), + withBreakageSubAccount: _q.withBreakageSubAccount.Clone(), + withPlannedReleases: _q.withPlannedReleases.Clone(), + withReleaseReopens: _q.withReleaseReopens.Clone(), + withPlan: _q.withPlan.Clone(), + withRelease: _q.withRelease.Clone(), // clone intermediate query. sql: _q.sql.Clone(), path: _q.path, } } +// WithSourceTransactionGroup tells the query-builder to eager-load the nodes that are connected to +// the "source_transaction_group" edge. The optional arguments are used to configure the query builder of the edge. +func (_q *LedgerBreakageRecordQuery) WithSourceTransactionGroup(opts ...func(*LedgerTransactionGroupQuery)) *LedgerBreakageRecordQuery { + query := (&LedgerTransactionGroupClient{config: _q.config}).Query() + for _, opt := range opts { + opt(query) + } + _q.withSourceTransactionGroup = query + return _q +} + +// WithSourceTransaction tells the query-builder to eager-load the nodes that are connected to +// the "source_transaction" edge. The optional arguments are used to configure the query builder of the edge. +func (_q *LedgerBreakageRecordQuery) WithSourceTransaction(opts ...func(*LedgerTransactionQuery)) *LedgerBreakageRecordQuery { + query := (&LedgerTransactionClient{config: _q.config}).Query() + for _, opt := range opts { + opt(query) + } + _q.withSourceTransaction = query + return _q +} + +// WithSourceEntry tells the query-builder to eager-load the nodes that are connected to +// the "source_entry" edge. The optional arguments are used to configure the query builder of the edge. +func (_q *LedgerBreakageRecordQuery) WithSourceEntry(opts ...func(*LedgerEntryQuery)) *LedgerBreakageRecordQuery { + query := (&LedgerEntryClient{config: _q.config}).Query() + for _, opt := range opts { + opt(query) + } + _q.withSourceEntry = query + return _q +} + +// WithBreakageTransactionGroup tells the query-builder to eager-load the nodes that are connected to +// the "breakage_transaction_group" edge. The optional arguments are used to configure the query builder of the edge. +func (_q *LedgerBreakageRecordQuery) WithBreakageTransactionGroup(opts ...func(*LedgerTransactionGroupQuery)) *LedgerBreakageRecordQuery { + query := (&LedgerTransactionGroupClient{config: _q.config}).Query() + for _, opt := range opts { + opt(query) + } + _q.withBreakageTransactionGroup = query + return _q +} + +// WithBreakageTransaction tells the query-builder to eager-load the nodes that are connected to +// the "breakage_transaction" edge. The optional arguments are used to configure the query builder of the edge. +func (_q *LedgerBreakageRecordQuery) WithBreakageTransaction(opts ...func(*LedgerTransactionQuery)) *LedgerBreakageRecordQuery { + query := (&LedgerTransactionClient{config: _q.config}).Query() + for _, opt := range opts { + opt(query) + } + _q.withBreakageTransaction = query + return _q +} + +// WithFboSubAccount tells the query-builder to eager-load the nodes that are connected to +// the "fbo_sub_account" edge. The optional arguments are used to configure the query builder of the edge. +func (_q *LedgerBreakageRecordQuery) WithFboSubAccount(opts ...func(*LedgerSubAccountQuery)) *LedgerBreakageRecordQuery { + query := (&LedgerSubAccountClient{config: _q.config}).Query() + for _, opt := range opts { + opt(query) + } + _q.withFboSubAccount = query + return _q +} + +// WithBreakageSubAccount tells the query-builder to eager-load the nodes that are connected to +// the "breakage_sub_account" edge. The optional arguments are used to configure the query builder of the edge. +func (_q *LedgerBreakageRecordQuery) WithBreakageSubAccount(opts ...func(*LedgerSubAccountQuery)) *LedgerBreakageRecordQuery { + query := (&LedgerSubAccountClient{config: _q.config}).Query() + for _, opt := range opts { + opt(query) + } + _q.withBreakageSubAccount = query + return _q +} + +// WithPlannedReleases tells the query-builder to eager-load the nodes that are connected to +// the "planned_releases" edge. The optional arguments are used to configure the query builder of the edge. +func (_q *LedgerBreakageRecordQuery) WithPlannedReleases(opts ...func(*LedgerBreakageRecordQuery)) *LedgerBreakageRecordQuery { + query := (&LedgerBreakageRecordClient{config: _q.config}).Query() + for _, opt := range opts { + opt(query) + } + _q.withPlannedReleases = query + return _q +} + +// WithReleaseReopens tells the query-builder to eager-load the nodes that are connected to +// the "release_reopens" edge. The optional arguments are used to configure the query builder of the edge. +func (_q *LedgerBreakageRecordQuery) WithReleaseReopens(opts ...func(*LedgerBreakageRecordQuery)) *LedgerBreakageRecordQuery { + query := (&LedgerBreakageRecordClient{config: _q.config}).Query() + for _, opt := range opts { + opt(query) + } + _q.withReleaseReopens = query + return _q +} + +// WithPlan tells the query-builder to eager-load the nodes that are connected to +// the "plan" edge. The optional arguments are used to configure the query builder of the edge. +func (_q *LedgerBreakageRecordQuery) WithPlan(opts ...func(*LedgerBreakageRecordQuery)) *LedgerBreakageRecordQuery { + query := (&LedgerBreakageRecordClient{config: _q.config}).Query() + for _, opt := range opts { + opt(query) + } + _q.withPlan = query + return _q +} + +// WithRelease tells the query-builder to eager-load the nodes that are connected to +// the "release" edge. The optional arguments are used to configure the query builder of the edge. +func (_q *LedgerBreakageRecordQuery) WithRelease(opts ...func(*LedgerBreakageRecordQuery)) *LedgerBreakageRecordQuery { + query := (&LedgerBreakageRecordClient{config: _q.config}).Query() + for _, opt := range opts { + opt(query) + } + _q.withRelease = query + return _q +} + // 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. // @@ -334,8 +724,21 @@ func (_q *LedgerBreakageRecordQuery) prepareQuery(ctx context.Context) error { func (_q *LedgerBreakageRecordQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*LedgerBreakageRecord, error) { var ( - nodes = []*LedgerBreakageRecord{} - _spec = _q.querySpec() + nodes = []*LedgerBreakageRecord{} + _spec = _q.querySpec() + loadedTypes = [11]bool{ + _q.withSourceTransactionGroup != nil, + _q.withSourceTransaction != nil, + _q.withSourceEntry != nil, + _q.withBreakageTransactionGroup != nil, + _q.withBreakageTransaction != nil, + _q.withFboSubAccount != nil, + _q.withBreakageSubAccount != nil, + _q.withPlannedReleases != nil, + _q.withReleaseReopens != nil, + _q.withPlan != nil, + _q.withRelease != nil, + } ) _spec.ScanValues = func(columns []string) ([]any, error) { return (*LedgerBreakageRecord).scanValues(nil, columns) @@ -343,6 +746,7 @@ func (_q *LedgerBreakageRecordQuery) sqlAll(ctx context.Context, hooks ...queryH _spec.Assign = func(columns []string, values []any) error { node := &LedgerBreakageRecord{config: _q.config} nodes = append(nodes, node) + node.Edges.loadedTypes = loadedTypes return node.assignValues(columns, values) } if len(_q.modifiers) > 0 { @@ -357,9 +761,424 @@ func (_q *LedgerBreakageRecordQuery) sqlAll(ctx context.Context, hooks ...queryH if len(nodes) == 0 { return nodes, nil } + if query := _q.withSourceTransactionGroup; query != nil { + if err := _q.loadSourceTransactionGroup(ctx, query, nodes, nil, + func(n *LedgerBreakageRecord, e *LedgerTransactionGroup) { n.Edges.SourceTransactionGroup = e }); err != nil { + return nil, err + } + } + if query := _q.withSourceTransaction; query != nil { + if err := _q.loadSourceTransaction(ctx, query, nodes, nil, + func(n *LedgerBreakageRecord, e *LedgerTransaction) { n.Edges.SourceTransaction = e }); err != nil { + return nil, err + } + } + if query := _q.withSourceEntry; query != nil { + if err := _q.loadSourceEntry(ctx, query, nodes, nil, + func(n *LedgerBreakageRecord, e *LedgerEntry) { n.Edges.SourceEntry = e }); err != nil { + return nil, err + } + } + if query := _q.withBreakageTransactionGroup; query != nil { + if err := _q.loadBreakageTransactionGroup(ctx, query, nodes, nil, + func(n *LedgerBreakageRecord, e *LedgerTransactionGroup) { n.Edges.BreakageTransactionGroup = e }); err != nil { + return nil, err + } + } + if query := _q.withBreakageTransaction; query != nil { + if err := _q.loadBreakageTransaction(ctx, query, nodes, nil, + func(n *LedgerBreakageRecord, e *LedgerTransaction) { n.Edges.BreakageTransaction = e }); err != nil { + return nil, err + } + } + if query := _q.withFboSubAccount; query != nil { + if err := _q.loadFboSubAccount(ctx, query, nodes, nil, + func(n *LedgerBreakageRecord, e *LedgerSubAccount) { n.Edges.FboSubAccount = e }); err != nil { + return nil, err + } + } + if query := _q.withBreakageSubAccount; query != nil { + if err := _q.loadBreakageSubAccount(ctx, query, nodes, nil, + func(n *LedgerBreakageRecord, e *LedgerSubAccount) { n.Edges.BreakageSubAccount = e }); err != nil { + return nil, err + } + } + if query := _q.withPlannedReleases; query != nil { + if err := _q.loadPlannedReleases(ctx, query, nodes, + func(n *LedgerBreakageRecord) { n.Edges.PlannedReleases = []*LedgerBreakageRecord{} }, + func(n *LedgerBreakageRecord, e *LedgerBreakageRecord) { + n.Edges.PlannedReleases = append(n.Edges.PlannedReleases, e) + }); err != nil { + return nil, err + } + } + if query := _q.withReleaseReopens; query != nil { + if err := _q.loadReleaseReopens(ctx, query, nodes, + func(n *LedgerBreakageRecord) { n.Edges.ReleaseReopens = []*LedgerBreakageRecord{} }, + func(n *LedgerBreakageRecord, e *LedgerBreakageRecord) { + n.Edges.ReleaseReopens = append(n.Edges.ReleaseReopens, e) + }); err != nil { + return nil, err + } + } + if query := _q.withPlan; query != nil { + if err := _q.loadPlan(ctx, query, nodes, nil, + func(n *LedgerBreakageRecord, e *LedgerBreakageRecord) { n.Edges.Plan = e }); err != nil { + return nil, err + } + } + if query := _q.withRelease; query != nil { + if err := _q.loadRelease(ctx, query, nodes, nil, + func(n *LedgerBreakageRecord, e *LedgerBreakageRecord) { n.Edges.Release = e }); err != nil { + return nil, err + } + } return nodes, nil } +func (_q *LedgerBreakageRecordQuery) loadSourceTransactionGroup(ctx context.Context, query *LedgerTransactionGroupQuery, nodes []*LedgerBreakageRecord, init func(*LedgerBreakageRecord), assign func(*LedgerBreakageRecord, *LedgerTransactionGroup)) error { + ids := make([]string, 0, len(nodes)) + nodeids := make(map[string][]*LedgerBreakageRecord) + for i := range nodes { + if nodes[i].SourceTransactionGroupID == nil { + continue + } + fk := *nodes[i].SourceTransactionGroupID + if _, ok := nodeids[fk]; !ok { + ids = append(ids, fk) + } + nodeids[fk] = append(nodeids[fk], nodes[i]) + } + if len(ids) == 0 { + return nil + } + query.Where(ledgertransactiongroup.IDIn(ids...)) + neighbors, err := query.All(ctx) + if err != nil { + return err + } + for _, n := range neighbors { + nodes, ok := nodeids[n.ID] + if !ok { + return fmt.Errorf(`unexpected foreign-key "source_transaction_group_id" returned %v`, n.ID) + } + for i := range nodes { + assign(nodes[i], n) + } + } + return nil +} +func (_q *LedgerBreakageRecordQuery) loadSourceTransaction(ctx context.Context, query *LedgerTransactionQuery, nodes []*LedgerBreakageRecord, init func(*LedgerBreakageRecord), assign func(*LedgerBreakageRecord, *LedgerTransaction)) error { + ids := make([]string, 0, len(nodes)) + nodeids := make(map[string][]*LedgerBreakageRecord) + for i := range nodes { + if nodes[i].SourceTransactionID == nil { + continue + } + fk := *nodes[i].SourceTransactionID + if _, ok := nodeids[fk]; !ok { + ids = append(ids, fk) + } + nodeids[fk] = append(nodeids[fk], nodes[i]) + } + if len(ids) == 0 { + return nil + } + query.Where(ledgertransaction.IDIn(ids...)) + neighbors, err := query.All(ctx) + if err != nil { + return err + } + for _, n := range neighbors { + nodes, ok := nodeids[n.ID] + if !ok { + return fmt.Errorf(`unexpected foreign-key "source_transaction_id" returned %v`, n.ID) + } + for i := range nodes { + assign(nodes[i], n) + } + } + return nil +} +func (_q *LedgerBreakageRecordQuery) loadSourceEntry(ctx context.Context, query *LedgerEntryQuery, nodes []*LedgerBreakageRecord, init func(*LedgerBreakageRecord), assign func(*LedgerBreakageRecord, *LedgerEntry)) error { + ids := make([]string, 0, len(nodes)) + nodeids := make(map[string][]*LedgerBreakageRecord) + for i := range nodes { + if nodes[i].SourceEntryID == nil { + continue + } + fk := *nodes[i].SourceEntryID + if _, ok := nodeids[fk]; !ok { + ids = append(ids, fk) + } + nodeids[fk] = append(nodeids[fk], nodes[i]) + } + if len(ids) == 0 { + return nil + } + query.Where(ledgerentry.IDIn(ids...)) + neighbors, err := query.All(ctx) + if err != nil { + return err + } + for _, n := range neighbors { + nodes, ok := nodeids[n.ID] + if !ok { + return fmt.Errorf(`unexpected foreign-key "source_entry_id" returned %v`, n.ID) + } + for i := range nodes { + assign(nodes[i], n) + } + } + return nil +} +func (_q *LedgerBreakageRecordQuery) loadBreakageTransactionGroup(ctx context.Context, query *LedgerTransactionGroupQuery, nodes []*LedgerBreakageRecord, init func(*LedgerBreakageRecord), assign func(*LedgerBreakageRecord, *LedgerTransactionGroup)) error { + ids := make([]string, 0, len(nodes)) + nodeids := make(map[string][]*LedgerBreakageRecord) + for i := range nodes { + fk := nodes[i].BreakageTransactionGroupID + if _, ok := nodeids[fk]; !ok { + ids = append(ids, fk) + } + nodeids[fk] = append(nodeids[fk], nodes[i]) + } + if len(ids) == 0 { + return nil + } + query.Where(ledgertransactiongroup.IDIn(ids...)) + neighbors, err := query.All(ctx) + if err != nil { + return err + } + for _, n := range neighbors { + nodes, ok := nodeids[n.ID] + if !ok { + return fmt.Errorf(`unexpected foreign-key "breakage_transaction_group_id" returned %v`, n.ID) + } + for i := range nodes { + assign(nodes[i], n) + } + } + return nil +} +func (_q *LedgerBreakageRecordQuery) loadBreakageTransaction(ctx context.Context, query *LedgerTransactionQuery, nodes []*LedgerBreakageRecord, init func(*LedgerBreakageRecord), assign func(*LedgerBreakageRecord, *LedgerTransaction)) error { + ids := make([]string, 0, len(nodes)) + nodeids := make(map[string][]*LedgerBreakageRecord) + for i := range nodes { + fk := nodes[i].BreakageTransactionID + if _, ok := nodeids[fk]; !ok { + ids = append(ids, fk) + } + nodeids[fk] = append(nodeids[fk], nodes[i]) + } + if len(ids) == 0 { + return nil + } + query.Where(ledgertransaction.IDIn(ids...)) + neighbors, err := query.All(ctx) + if err != nil { + return err + } + for _, n := range neighbors { + nodes, ok := nodeids[n.ID] + if !ok { + return fmt.Errorf(`unexpected foreign-key "breakage_transaction_id" returned %v`, n.ID) + } + for i := range nodes { + assign(nodes[i], n) + } + } + return nil +} +func (_q *LedgerBreakageRecordQuery) loadFboSubAccount(ctx context.Context, query *LedgerSubAccountQuery, nodes []*LedgerBreakageRecord, init func(*LedgerBreakageRecord), assign func(*LedgerBreakageRecord, *LedgerSubAccount)) error { + ids := make([]string, 0, len(nodes)) + nodeids := make(map[string][]*LedgerBreakageRecord) + for i := range nodes { + fk := nodes[i].FboSubAccountID + if _, ok := nodeids[fk]; !ok { + ids = append(ids, fk) + } + nodeids[fk] = append(nodeids[fk], nodes[i]) + } + if len(ids) == 0 { + return nil + } + query.Where(ledgersubaccount.IDIn(ids...)) + neighbors, err := query.All(ctx) + if err != nil { + return err + } + for _, n := range neighbors { + nodes, ok := nodeids[n.ID] + if !ok { + return fmt.Errorf(`unexpected foreign-key "fbo_sub_account_id" returned %v`, n.ID) + } + for i := range nodes { + assign(nodes[i], n) + } + } + return nil +} +func (_q *LedgerBreakageRecordQuery) loadBreakageSubAccount(ctx context.Context, query *LedgerSubAccountQuery, nodes []*LedgerBreakageRecord, init func(*LedgerBreakageRecord), assign func(*LedgerBreakageRecord, *LedgerSubAccount)) error { + ids := make([]string, 0, len(nodes)) + nodeids := make(map[string][]*LedgerBreakageRecord) + for i := range nodes { + fk := nodes[i].BreakageSubAccountID + if _, ok := nodeids[fk]; !ok { + ids = append(ids, fk) + } + nodeids[fk] = append(nodeids[fk], nodes[i]) + } + if len(ids) == 0 { + return nil + } + query.Where(ledgersubaccount.IDIn(ids...)) + neighbors, err := query.All(ctx) + if err != nil { + return err + } + for _, n := range neighbors { + nodes, ok := nodeids[n.ID] + if !ok { + return fmt.Errorf(`unexpected foreign-key "breakage_sub_account_id" returned %v`, n.ID) + } + for i := range nodes { + assign(nodes[i], n) + } + } + return nil +} +func (_q *LedgerBreakageRecordQuery) loadPlannedReleases(ctx context.Context, query *LedgerBreakageRecordQuery, nodes []*LedgerBreakageRecord, init func(*LedgerBreakageRecord), assign func(*LedgerBreakageRecord, *LedgerBreakageRecord)) error { + fks := make([]driver.Value, 0, len(nodes)) + nodeids := make(map[string]*LedgerBreakageRecord) + for i := range nodes { + fks = append(fks, nodes[i].ID) + nodeids[nodes[i].ID] = nodes[i] + if init != nil { + init(nodes[i]) + } + } + if len(query.ctx.Fields) > 0 { + query.ctx.AppendFieldOnce(ledgerbreakagerecord.FieldPlanID) + } + query.Where(predicate.LedgerBreakageRecord(func(s *sql.Selector) { + s.Where(sql.InValues(s.C(ledgerbreakagerecord.PlannedReleasesColumn), fks...)) + })) + neighbors, err := query.All(ctx) + if err != nil { + return err + } + for _, n := range neighbors { + fk := n.PlanID + if fk == nil { + return fmt.Errorf(`foreign-key "plan_id" is nil for node %v`, n.ID) + } + node, ok := nodeids[*fk] + if !ok { + return fmt.Errorf(`unexpected referenced foreign-key "plan_id" returned %v for node %v`, *fk, n.ID) + } + assign(node, n) + } + return nil +} +func (_q *LedgerBreakageRecordQuery) loadReleaseReopens(ctx context.Context, query *LedgerBreakageRecordQuery, nodes []*LedgerBreakageRecord, init func(*LedgerBreakageRecord), assign func(*LedgerBreakageRecord, *LedgerBreakageRecord)) error { + fks := make([]driver.Value, 0, len(nodes)) + nodeids := make(map[string]*LedgerBreakageRecord) + for i := range nodes { + fks = append(fks, nodes[i].ID) + nodeids[nodes[i].ID] = nodes[i] + if init != nil { + init(nodes[i]) + } + } + if len(query.ctx.Fields) > 0 { + query.ctx.AppendFieldOnce(ledgerbreakagerecord.FieldReleaseID) + } + query.Where(predicate.LedgerBreakageRecord(func(s *sql.Selector) { + s.Where(sql.InValues(s.C(ledgerbreakagerecord.ReleaseReopensColumn), fks...)) + })) + neighbors, err := query.All(ctx) + if err != nil { + return err + } + for _, n := range neighbors { + fk := n.ReleaseID + if fk == nil { + return fmt.Errorf(`foreign-key "release_id" is nil for node %v`, n.ID) + } + node, ok := nodeids[*fk] + if !ok { + return fmt.Errorf(`unexpected referenced foreign-key "release_id" returned %v for node %v`, *fk, n.ID) + } + assign(node, n) + } + return nil +} +func (_q *LedgerBreakageRecordQuery) loadPlan(ctx context.Context, query *LedgerBreakageRecordQuery, nodes []*LedgerBreakageRecord, init func(*LedgerBreakageRecord), assign func(*LedgerBreakageRecord, *LedgerBreakageRecord)) error { + ids := make([]string, 0, len(nodes)) + nodeids := make(map[string][]*LedgerBreakageRecord) + for i := range nodes { + if nodes[i].PlanID == nil { + continue + } + fk := *nodes[i].PlanID + if _, ok := nodeids[fk]; !ok { + ids = append(ids, fk) + } + nodeids[fk] = append(nodeids[fk], nodes[i]) + } + if len(ids) == 0 { + return nil + } + query.Where(ledgerbreakagerecord.IDIn(ids...)) + neighbors, err := query.All(ctx) + if err != nil { + return err + } + for _, n := range neighbors { + nodes, ok := nodeids[n.ID] + if !ok { + return fmt.Errorf(`unexpected foreign-key "plan_id" returned %v`, n.ID) + } + for i := range nodes { + assign(nodes[i], n) + } + } + return nil +} +func (_q *LedgerBreakageRecordQuery) loadRelease(ctx context.Context, query *LedgerBreakageRecordQuery, nodes []*LedgerBreakageRecord, init func(*LedgerBreakageRecord), assign func(*LedgerBreakageRecord, *LedgerBreakageRecord)) error { + ids := make([]string, 0, len(nodes)) + nodeids := make(map[string][]*LedgerBreakageRecord) + for i := range nodes { + if nodes[i].ReleaseID == nil { + continue + } + fk := *nodes[i].ReleaseID + if _, ok := nodeids[fk]; !ok { + ids = append(ids, fk) + } + nodeids[fk] = append(nodeids[fk], nodes[i]) + } + if len(ids) == 0 { + return nil + } + query.Where(ledgerbreakagerecord.IDIn(ids...)) + neighbors, err := query.All(ctx) + if err != nil { + return err + } + for _, n := range neighbors { + nodes, ok := nodeids[n.ID] + if !ok { + return fmt.Errorf(`unexpected foreign-key "release_id" returned %v`, n.ID) + } + for i := range nodes { + assign(nodes[i], n) + } + } + return nil +} + func (_q *LedgerBreakageRecordQuery) sqlCount(ctx context.Context) (int, error) { _spec := _q.querySpec() if len(_q.modifiers) > 0 { @@ -388,6 +1207,33 @@ func (_q *LedgerBreakageRecordQuery) querySpec() *sqlgraph.QuerySpec { _spec.Node.Columns = append(_spec.Node.Columns, fields[i]) } } + if _q.withSourceTransactionGroup != nil { + _spec.Node.AddColumnOnce(ledgerbreakagerecord.FieldSourceTransactionGroupID) + } + if _q.withSourceTransaction != nil { + _spec.Node.AddColumnOnce(ledgerbreakagerecord.FieldSourceTransactionID) + } + if _q.withSourceEntry != nil { + _spec.Node.AddColumnOnce(ledgerbreakagerecord.FieldSourceEntryID) + } + if _q.withBreakageTransactionGroup != nil { + _spec.Node.AddColumnOnce(ledgerbreakagerecord.FieldBreakageTransactionGroupID) + } + if _q.withBreakageTransaction != nil { + _spec.Node.AddColumnOnce(ledgerbreakagerecord.FieldBreakageTransactionID) + } + if _q.withFboSubAccount != nil { + _spec.Node.AddColumnOnce(ledgerbreakagerecord.FieldFboSubAccountID) + } + if _q.withBreakageSubAccount != nil { + _spec.Node.AddColumnOnce(ledgerbreakagerecord.FieldBreakageSubAccountID) + } + if _q.withPlan != nil { + _spec.Node.AddColumnOnce(ledgerbreakagerecord.FieldPlanID) + } + if _q.withRelease != nil { + _spec.Node.AddColumnOnce(ledgerbreakagerecord.FieldReleaseID) + } } if ps := _q.predicates; len(ps) > 0 { _spec.Predicate = func(selector *sql.Selector) { diff --git a/openmeter/ent/db/ledgerbreakagerecord_update.go b/openmeter/ent/db/ledgerbreakagerecord_update.go index 9ca82542b4..630fe5c999 100644 --- a/openmeter/ent/db/ledgerbreakagerecord_update.go +++ b/openmeter/ent/db/ledgerbreakagerecord_update.go @@ -82,11 +82,83 @@ func (_u *LedgerBreakageRecordUpdate) SetNillableAmount(v *alpacadecimal.Decimal return _u } +// AddPlannedReleaseIDs adds the "planned_releases" edge to the LedgerBreakageRecord entity by IDs. +func (_u *LedgerBreakageRecordUpdate) AddPlannedReleaseIDs(ids ...string) *LedgerBreakageRecordUpdate { + _u.mutation.AddPlannedReleaseIDs(ids...) + return _u +} + +// AddPlannedReleases adds the "planned_releases" edges to the LedgerBreakageRecord entity. +func (_u *LedgerBreakageRecordUpdate) AddPlannedReleases(v ...*LedgerBreakageRecord) *LedgerBreakageRecordUpdate { + ids := make([]string, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _u.AddPlannedReleaseIDs(ids...) +} + +// AddReleaseReopenIDs adds the "release_reopens" edge to the LedgerBreakageRecord entity by IDs. +func (_u *LedgerBreakageRecordUpdate) AddReleaseReopenIDs(ids ...string) *LedgerBreakageRecordUpdate { + _u.mutation.AddReleaseReopenIDs(ids...) + return _u +} + +// AddReleaseReopens adds the "release_reopens" edges to the LedgerBreakageRecord entity. +func (_u *LedgerBreakageRecordUpdate) AddReleaseReopens(v ...*LedgerBreakageRecord) *LedgerBreakageRecordUpdate { + ids := make([]string, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _u.AddReleaseReopenIDs(ids...) +} + // Mutation returns the LedgerBreakageRecordMutation object of the builder. func (_u *LedgerBreakageRecordUpdate) Mutation() *LedgerBreakageRecordMutation { return _u.mutation } +// ClearPlannedReleases clears all "planned_releases" edges to the LedgerBreakageRecord entity. +func (_u *LedgerBreakageRecordUpdate) ClearPlannedReleases() *LedgerBreakageRecordUpdate { + _u.mutation.ClearPlannedReleases() + return _u +} + +// RemovePlannedReleaseIDs removes the "planned_releases" edge to LedgerBreakageRecord entities by IDs. +func (_u *LedgerBreakageRecordUpdate) RemovePlannedReleaseIDs(ids ...string) *LedgerBreakageRecordUpdate { + _u.mutation.RemovePlannedReleaseIDs(ids...) + return _u +} + +// RemovePlannedReleases removes "planned_releases" edges to LedgerBreakageRecord entities. +func (_u *LedgerBreakageRecordUpdate) RemovePlannedReleases(v ...*LedgerBreakageRecord) *LedgerBreakageRecordUpdate { + ids := make([]string, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _u.RemovePlannedReleaseIDs(ids...) +} + +// ClearReleaseReopens clears all "release_reopens" edges to the LedgerBreakageRecord entity. +func (_u *LedgerBreakageRecordUpdate) ClearReleaseReopens() *LedgerBreakageRecordUpdate { + _u.mutation.ClearReleaseReopens() + return _u +} + +// RemoveReleaseReopenIDs removes the "release_reopens" edge to LedgerBreakageRecord entities by IDs. +func (_u *LedgerBreakageRecordUpdate) RemoveReleaseReopenIDs(ids ...string) *LedgerBreakageRecordUpdate { + _u.mutation.RemoveReleaseReopenIDs(ids...) + return _u +} + +// RemoveReleaseReopens removes "release_reopens" edges to LedgerBreakageRecord entities. +func (_u *LedgerBreakageRecordUpdate) RemoveReleaseReopens(v ...*LedgerBreakageRecord) *LedgerBreakageRecordUpdate { + ids := make([]string, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _u.RemoveReleaseReopenIDs(ids...) +} + // Save executes the query and returns the number of nodes affected by the update operation. func (_u *LedgerBreakageRecordUpdate) Save(ctx context.Context) (int, error) { _u.defaults() @@ -123,7 +195,27 @@ func (_u *LedgerBreakageRecordUpdate) defaults() { } } +// check runs all checks and user-defined validators on the builder. +func (_u *LedgerBreakageRecordUpdate) check() error { + if _u.mutation.BreakageTransactionGroupCleared() && len(_u.mutation.BreakageTransactionGroupIDs()) > 0 { + return errors.New(`db: clearing a required unique edge "LedgerBreakageRecord.breakage_transaction_group"`) + } + if _u.mutation.BreakageTransactionCleared() && len(_u.mutation.BreakageTransactionIDs()) > 0 { + return errors.New(`db: clearing a required unique edge "LedgerBreakageRecord.breakage_transaction"`) + } + if _u.mutation.FboSubAccountCleared() && len(_u.mutation.FboSubAccountIDs()) > 0 { + return errors.New(`db: clearing a required unique edge "LedgerBreakageRecord.fbo_sub_account"`) + } + if _u.mutation.BreakageSubAccountCleared() && len(_u.mutation.BreakageSubAccountIDs()) > 0 { + return errors.New(`db: clearing a required unique edge "LedgerBreakageRecord.breakage_sub_account"`) + } + return nil +} + func (_u *LedgerBreakageRecordUpdate) sqlSave(ctx context.Context) (_node int, err error) { + if err := _u.check(); err != nil { + return _node, err + } _spec := sqlgraph.NewUpdateSpec(ledgerbreakagerecord.Table, ledgerbreakagerecord.Columns, sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString)) if ps := _u.mutation.predicates; len(ps) > 0 { _spec.Predicate = func(selector *sql.Selector) { @@ -153,20 +245,95 @@ func (_u *LedgerBreakageRecordUpdate) sqlSave(ctx context.Context) (_node int, e if _u.mutation.SourceChargeIDCleared() { _spec.ClearField(ledgerbreakagerecord.FieldSourceChargeID, field.TypeString) } - if _u.mutation.SourceTransactionGroupIDCleared() { - _spec.ClearField(ledgerbreakagerecord.FieldSourceTransactionGroupID, field.TypeString) - } - if _u.mutation.SourceTransactionIDCleared() { - _spec.ClearField(ledgerbreakagerecord.FieldSourceTransactionID, field.TypeString) - } - if _u.mutation.SourceEntryIDCleared() { - _spec.ClearField(ledgerbreakagerecord.FieldSourceEntryID, field.TypeString) - } - if _u.mutation.PlanIDCleared() { - _spec.ClearField(ledgerbreakagerecord.FieldPlanID, field.TypeString) - } - if _u.mutation.ReleaseIDCleared() { - _spec.ClearField(ledgerbreakagerecord.FieldReleaseID, field.TypeString) + if _u.mutation.PlannedReleasesCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgerbreakagerecord.PlannedReleasesTable, + Columns: []string{ledgerbreakagerecord.PlannedReleasesColumn}, + Bidi: true, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := _u.mutation.RemovedPlannedReleasesIDs(); len(nodes) > 0 && !_u.mutation.PlannedReleasesCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgerbreakagerecord.PlannedReleasesTable, + Columns: []string{ledgerbreakagerecord.PlannedReleasesColumn}, + Bidi: true, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := _u.mutation.PlannedReleasesIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgerbreakagerecord.PlannedReleasesTable, + Columns: []string{ledgerbreakagerecord.PlannedReleasesColumn}, + Bidi: true, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Add = append(_spec.Edges.Add, edge) + } + if _u.mutation.ReleaseReopensCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgerbreakagerecord.ReleaseReopensTable, + Columns: []string{ledgerbreakagerecord.ReleaseReopensColumn}, + Bidi: true, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := _u.mutation.RemovedReleaseReopensIDs(); len(nodes) > 0 && !_u.mutation.ReleaseReopensCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgerbreakagerecord.ReleaseReopensTable, + Columns: []string{ledgerbreakagerecord.ReleaseReopensColumn}, + Bidi: true, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := _u.mutation.ReleaseReopensIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgerbreakagerecord.ReleaseReopensTable, + Columns: []string{ledgerbreakagerecord.ReleaseReopensColumn}, + Bidi: true, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Add = append(_spec.Edges.Add, edge) } if _node, err = sqlgraph.UpdateNodes(ctx, _u.driver, _spec); err != nil { if _, ok := err.(*sqlgraph.NotFoundError); ok { @@ -240,11 +407,83 @@ func (_u *LedgerBreakageRecordUpdateOne) SetNillableAmount(v *alpacadecimal.Deci return _u } +// AddPlannedReleaseIDs adds the "planned_releases" edge to the LedgerBreakageRecord entity by IDs. +func (_u *LedgerBreakageRecordUpdateOne) AddPlannedReleaseIDs(ids ...string) *LedgerBreakageRecordUpdateOne { + _u.mutation.AddPlannedReleaseIDs(ids...) + return _u +} + +// AddPlannedReleases adds the "planned_releases" edges to the LedgerBreakageRecord entity. +func (_u *LedgerBreakageRecordUpdateOne) AddPlannedReleases(v ...*LedgerBreakageRecord) *LedgerBreakageRecordUpdateOne { + ids := make([]string, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _u.AddPlannedReleaseIDs(ids...) +} + +// AddReleaseReopenIDs adds the "release_reopens" edge to the LedgerBreakageRecord entity by IDs. +func (_u *LedgerBreakageRecordUpdateOne) AddReleaseReopenIDs(ids ...string) *LedgerBreakageRecordUpdateOne { + _u.mutation.AddReleaseReopenIDs(ids...) + return _u +} + +// AddReleaseReopens adds the "release_reopens" edges to the LedgerBreakageRecord entity. +func (_u *LedgerBreakageRecordUpdateOne) AddReleaseReopens(v ...*LedgerBreakageRecord) *LedgerBreakageRecordUpdateOne { + ids := make([]string, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _u.AddReleaseReopenIDs(ids...) +} + // Mutation returns the LedgerBreakageRecordMutation object of the builder. func (_u *LedgerBreakageRecordUpdateOne) Mutation() *LedgerBreakageRecordMutation { return _u.mutation } +// ClearPlannedReleases clears all "planned_releases" edges to the LedgerBreakageRecord entity. +func (_u *LedgerBreakageRecordUpdateOne) ClearPlannedReleases() *LedgerBreakageRecordUpdateOne { + _u.mutation.ClearPlannedReleases() + return _u +} + +// RemovePlannedReleaseIDs removes the "planned_releases" edge to LedgerBreakageRecord entities by IDs. +func (_u *LedgerBreakageRecordUpdateOne) RemovePlannedReleaseIDs(ids ...string) *LedgerBreakageRecordUpdateOne { + _u.mutation.RemovePlannedReleaseIDs(ids...) + return _u +} + +// RemovePlannedReleases removes "planned_releases" edges to LedgerBreakageRecord entities. +func (_u *LedgerBreakageRecordUpdateOne) RemovePlannedReleases(v ...*LedgerBreakageRecord) *LedgerBreakageRecordUpdateOne { + ids := make([]string, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _u.RemovePlannedReleaseIDs(ids...) +} + +// ClearReleaseReopens clears all "release_reopens" edges to the LedgerBreakageRecord entity. +func (_u *LedgerBreakageRecordUpdateOne) ClearReleaseReopens() *LedgerBreakageRecordUpdateOne { + _u.mutation.ClearReleaseReopens() + return _u +} + +// RemoveReleaseReopenIDs removes the "release_reopens" edge to LedgerBreakageRecord entities by IDs. +func (_u *LedgerBreakageRecordUpdateOne) RemoveReleaseReopenIDs(ids ...string) *LedgerBreakageRecordUpdateOne { + _u.mutation.RemoveReleaseReopenIDs(ids...) + return _u +} + +// RemoveReleaseReopens removes "release_reopens" edges to LedgerBreakageRecord entities. +func (_u *LedgerBreakageRecordUpdateOne) RemoveReleaseReopens(v ...*LedgerBreakageRecord) *LedgerBreakageRecordUpdateOne { + ids := make([]string, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _u.RemoveReleaseReopenIDs(ids...) +} + // Where appends a list predicates to the LedgerBreakageRecordUpdate builder. func (_u *LedgerBreakageRecordUpdateOne) Where(ps ...predicate.LedgerBreakageRecord) *LedgerBreakageRecordUpdateOne { _u.mutation.Where(ps...) @@ -294,7 +533,27 @@ func (_u *LedgerBreakageRecordUpdateOne) defaults() { } } +// check runs all checks and user-defined validators on the builder. +func (_u *LedgerBreakageRecordUpdateOne) check() error { + if _u.mutation.BreakageTransactionGroupCleared() && len(_u.mutation.BreakageTransactionGroupIDs()) > 0 { + return errors.New(`db: clearing a required unique edge "LedgerBreakageRecord.breakage_transaction_group"`) + } + if _u.mutation.BreakageTransactionCleared() && len(_u.mutation.BreakageTransactionIDs()) > 0 { + return errors.New(`db: clearing a required unique edge "LedgerBreakageRecord.breakage_transaction"`) + } + if _u.mutation.FboSubAccountCleared() && len(_u.mutation.FboSubAccountIDs()) > 0 { + return errors.New(`db: clearing a required unique edge "LedgerBreakageRecord.fbo_sub_account"`) + } + if _u.mutation.BreakageSubAccountCleared() && len(_u.mutation.BreakageSubAccountIDs()) > 0 { + return errors.New(`db: clearing a required unique edge "LedgerBreakageRecord.breakage_sub_account"`) + } + return nil +} + func (_u *LedgerBreakageRecordUpdateOne) sqlSave(ctx context.Context) (_node *LedgerBreakageRecord, err error) { + if err := _u.check(); err != nil { + return _node, err + } _spec := sqlgraph.NewUpdateSpec(ledgerbreakagerecord.Table, ledgerbreakagerecord.Columns, sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString)) id, ok := _u.mutation.ID() if !ok { @@ -341,20 +600,95 @@ func (_u *LedgerBreakageRecordUpdateOne) sqlSave(ctx context.Context) (_node *Le if _u.mutation.SourceChargeIDCleared() { _spec.ClearField(ledgerbreakagerecord.FieldSourceChargeID, field.TypeString) } - if _u.mutation.SourceTransactionGroupIDCleared() { - _spec.ClearField(ledgerbreakagerecord.FieldSourceTransactionGroupID, field.TypeString) - } - if _u.mutation.SourceTransactionIDCleared() { - _spec.ClearField(ledgerbreakagerecord.FieldSourceTransactionID, field.TypeString) - } - if _u.mutation.SourceEntryIDCleared() { - _spec.ClearField(ledgerbreakagerecord.FieldSourceEntryID, field.TypeString) - } - if _u.mutation.PlanIDCleared() { - _spec.ClearField(ledgerbreakagerecord.FieldPlanID, field.TypeString) - } - if _u.mutation.ReleaseIDCleared() { - _spec.ClearField(ledgerbreakagerecord.FieldReleaseID, field.TypeString) + if _u.mutation.PlannedReleasesCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgerbreakagerecord.PlannedReleasesTable, + Columns: []string{ledgerbreakagerecord.PlannedReleasesColumn}, + Bidi: true, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := _u.mutation.RemovedPlannedReleasesIDs(); len(nodes) > 0 && !_u.mutation.PlannedReleasesCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgerbreakagerecord.PlannedReleasesTable, + Columns: []string{ledgerbreakagerecord.PlannedReleasesColumn}, + Bidi: true, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := _u.mutation.PlannedReleasesIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgerbreakagerecord.PlannedReleasesTable, + Columns: []string{ledgerbreakagerecord.PlannedReleasesColumn}, + Bidi: true, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Add = append(_spec.Edges.Add, edge) + } + if _u.mutation.ReleaseReopensCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgerbreakagerecord.ReleaseReopensTable, + Columns: []string{ledgerbreakagerecord.ReleaseReopensColumn}, + Bidi: true, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := _u.mutation.RemovedReleaseReopensIDs(); len(nodes) > 0 && !_u.mutation.ReleaseReopensCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgerbreakagerecord.ReleaseReopensTable, + Columns: []string{ledgerbreakagerecord.ReleaseReopensColumn}, + Bidi: true, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := _u.mutation.ReleaseReopensIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgerbreakagerecord.ReleaseReopensTable, + Columns: []string{ledgerbreakagerecord.ReleaseReopensColumn}, + Bidi: true, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Add = append(_spec.Edges.Add, edge) } _node = &LedgerBreakageRecord{config: _u.config} _spec.Assign = _node.assignValues diff --git a/openmeter/ent/db/ledgercustomeraccount.go b/openmeter/ent/db/ledgercustomeraccount.go index 62cb8be9c0..ccb4b0e477 100644 --- a/openmeter/ent/db/ledgercustomeraccount.go +++ b/openmeter/ent/db/ledgercustomeraccount.go @@ -9,6 +9,7 @@ import ( "entgo.io/ent" "entgo.io/ent/dialect/sql" + "github.com/openmeterio/openmeter/openmeter/ent/db/ledgeraccount" "github.com/openmeterio/openmeter/openmeter/ent/db/ledgercustomeraccount" "github.com/openmeterio/openmeter/openmeter/ledger" ) @@ -31,10 +32,33 @@ type LedgerCustomerAccount struct { // AccountType holds the value of the "account_type" field. AccountType ledger.AccountType `json:"account_type,omitempty"` // AccountID holds the value of the "account_id" field. - AccountID string `json:"account_id,omitempty"` + AccountID string `json:"account_id,omitempty"` + // Edges holds the relations/edges for other nodes in the graph. + // The values are being populated by the LedgerCustomerAccountQuery when eager-loading is set. + Edges LedgerCustomerAccountEdges `json:"edges"` selectValues sql.SelectValues } +// LedgerCustomerAccountEdges holds the relations/edges for other nodes in the graph. +type LedgerCustomerAccountEdges struct { + // Account holds the value of the account edge. + Account *LedgerAccount `json:"account,omitempty"` + // loadedTypes holds the information for reporting if a + // type was loaded (or requested) in eager-loading or not. + loadedTypes [1]bool +} + +// AccountOrErr returns the Account value or an error if the edge +// was not loaded in eager-loading, or loaded but was not found. +func (e LedgerCustomerAccountEdges) AccountOrErr() (*LedgerAccount, error) { + if e.Account != nil { + return e.Account, nil + } else if e.loadedTypes[0] { + return nil, &NotFoundError{label: ledgeraccount.Label} + } + return nil, &NotLoadedError{edge: "account"} +} + // scanValues returns the types for scanning values from sql.Rows. func (*LedgerCustomerAccount) scanValues(columns []string) ([]any, error) { values := make([]any, len(columns)) @@ -121,6 +145,11 @@ func (_m *LedgerCustomerAccount) Value(name string) (ent.Value, error) { return _m.selectValues.Get(name) } +// QueryAccount queries the "account" edge of the LedgerCustomerAccount entity. +func (_m *LedgerCustomerAccount) QueryAccount() *LedgerAccountQuery { + return NewLedgerCustomerAccountClient(_m.config).QueryAccount(_m) +} + // Update returns a builder for updating this LedgerCustomerAccount. // Note that you need to call LedgerCustomerAccount.Unwrap() before calling this method if this LedgerCustomerAccount // was returned from a transaction, and the transaction was committed or rolled back. diff --git a/openmeter/ent/db/ledgercustomeraccount/ledgercustomeraccount.go b/openmeter/ent/db/ledgercustomeraccount/ledgercustomeraccount.go index b6893c49ec..2dd7fb0c2b 100644 --- a/openmeter/ent/db/ledgercustomeraccount/ledgercustomeraccount.go +++ b/openmeter/ent/db/ledgercustomeraccount/ledgercustomeraccount.go @@ -6,6 +6,7 @@ import ( "time" "entgo.io/ent/dialect/sql" + "entgo.io/ent/dialect/sql/sqlgraph" ) const ( @@ -27,8 +28,17 @@ const ( FieldAccountType = "account_type" // FieldAccountID holds the string denoting the account_id field in the database. FieldAccountID = "account_id" + // EdgeAccount holds the string denoting the account edge name in mutations. + EdgeAccount = "account" // Table holds the table name of the ledgercustomeraccount in the database. Table = "ledger_customer_accounts" + // AccountTable is the table that holds the account relation/edge. + AccountTable = "ledger_customer_accounts" + // AccountInverseTable is the table name for the LedgerAccount entity. + // It exists in this package in order to avoid circular dependency with the "ledgeraccount" package. + AccountInverseTable = "ledger_accounts" + // AccountColumn is the table column denoting the account relation/edge. + AccountColumn = "account_id" ) // Columns holds all SQL columns for ledgercustomeraccount fields. @@ -108,3 +118,17 @@ func ByAccountType(opts ...sql.OrderTermOption) OrderOption { func ByAccountID(opts ...sql.OrderTermOption) OrderOption { return sql.OrderByField(FieldAccountID, opts...).ToFunc() } + +// ByAccountField orders the results by account field. +func ByAccountField(field string, opts ...sql.OrderTermOption) OrderOption { + return func(s *sql.Selector) { + sqlgraph.OrderByNeighborTerms(s, newAccountStep(), sql.OrderByField(field, opts...)) + } +} +func newAccountStep() *sqlgraph.Step { + return sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.To(AccountInverseTable, FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, AccountTable, AccountColumn), + ) +} diff --git a/openmeter/ent/db/ledgercustomeraccount/where.go b/openmeter/ent/db/ledgercustomeraccount/where.go index 84b306f265..b83fbf82cc 100644 --- a/openmeter/ent/db/ledgercustomeraccount/where.go +++ b/openmeter/ent/db/ledgercustomeraccount/where.go @@ -6,6 +6,7 @@ import ( "time" "entgo.io/ent/dialect/sql" + "entgo.io/ent/dialect/sql/sqlgraph" "github.com/openmeterio/openmeter/openmeter/ent/db/predicate" "github.com/openmeterio/openmeter/openmeter/ledger" ) @@ -510,6 +511,29 @@ func AccountIDContainsFold(v string) predicate.LedgerCustomerAccount { return predicate.LedgerCustomerAccount(sql.FieldContainsFold(FieldAccountID, v)) } +// HasAccount applies the HasEdge predicate on the "account" edge. +func HasAccount() predicate.LedgerCustomerAccount { + return predicate.LedgerCustomerAccount(func(s *sql.Selector) { + step := sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, AccountTable, AccountColumn), + ) + sqlgraph.HasNeighbors(s, step) + }) +} + +// HasAccountWith applies the HasEdge predicate on the "account" edge with a given conditions (other predicates). +func HasAccountWith(preds ...predicate.LedgerAccount) predicate.LedgerCustomerAccount { + return predicate.LedgerCustomerAccount(func(s *sql.Selector) { + step := newAccountStep() + sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) { + for _, p := range preds { + p(s) + } + }) + }) +} + // And groups predicates with the AND operator between them. func And(predicates ...predicate.LedgerCustomerAccount) predicate.LedgerCustomerAccount { return predicate.LedgerCustomerAccount(sql.AndPredicates(predicates...)) diff --git a/openmeter/ent/db/ledgercustomeraccount_create.go b/openmeter/ent/db/ledgercustomeraccount_create.go index a9e961d3f9..9f9e63169c 100644 --- a/openmeter/ent/db/ledgercustomeraccount_create.go +++ b/openmeter/ent/db/ledgercustomeraccount_create.go @@ -12,6 +12,7 @@ import ( "entgo.io/ent/dialect/sql" "entgo.io/ent/dialect/sql/sqlgraph" "entgo.io/ent/schema/field" + "github.com/openmeterio/openmeter/openmeter/ent/db/ledgeraccount" "github.com/openmeterio/openmeter/openmeter/ent/db/ledgercustomeraccount" "github.com/openmeterio/openmeter/openmeter/ledger" ) @@ -104,6 +105,11 @@ func (_c *LedgerCustomerAccountCreate) SetNillableID(v *string) *LedgerCustomerA return _c } +// SetAccount sets the "account" edge to the LedgerAccount entity. +func (_c *LedgerCustomerAccountCreate) SetAccount(v *LedgerAccount) *LedgerCustomerAccountCreate { + return _c.SetAccountID(v.ID) +} + // Mutation returns the LedgerCustomerAccountMutation object of the builder. func (_c *LedgerCustomerAccountCreate) Mutation() *LedgerCustomerAccountMutation { return _c.mutation @@ -183,6 +189,9 @@ func (_c *LedgerCustomerAccountCreate) check() error { if _, ok := _c.mutation.AccountID(); !ok { return &ValidationError{Name: "account_id", err: errors.New(`db: missing required field "LedgerCustomerAccount.account_id"`)} } + if len(_c.mutation.AccountIDs()) == 0 { + return &ValidationError{Name: "account", err: errors.New(`db: missing required edge "LedgerCustomerAccount.account"`)} + } return nil } @@ -243,9 +252,22 @@ func (_c *LedgerCustomerAccountCreate) createSpec() (*LedgerCustomerAccount, *sq _spec.SetField(ledgercustomeraccount.FieldAccountType, field.TypeString, value) _node.AccountType = value } - if value, ok := _c.mutation.AccountID(); ok { - _spec.SetField(ledgercustomeraccount.FieldAccountID, field.TypeString, value) - _node.AccountID = value + if nodes := _c.mutation.AccountIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.M2O, + Inverse: true, + Table: ledgercustomeraccount.AccountTable, + Columns: []string{ledgercustomeraccount.AccountColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgeraccount.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _node.AccountID = nodes[0] + _spec.Edges = append(_spec.Edges, edge) } return _node, _spec } diff --git a/openmeter/ent/db/ledgercustomeraccount_query.go b/openmeter/ent/db/ledgercustomeraccount_query.go index add91f81b9..e85fa26d1b 100644 --- a/openmeter/ent/db/ledgercustomeraccount_query.go +++ b/openmeter/ent/db/ledgercustomeraccount_query.go @@ -12,6 +12,7 @@ import ( "entgo.io/ent/dialect/sql" "entgo.io/ent/dialect/sql/sqlgraph" "entgo.io/ent/schema/field" + "github.com/openmeterio/openmeter/openmeter/ent/db/ledgeraccount" "github.com/openmeterio/openmeter/openmeter/ent/db/ledgercustomeraccount" "github.com/openmeterio/openmeter/openmeter/ent/db/predicate" ) @@ -19,11 +20,12 @@ import ( // LedgerCustomerAccountQuery is the builder for querying LedgerCustomerAccount entities. type LedgerCustomerAccountQuery struct { config - ctx *QueryContext - order []ledgercustomeraccount.OrderOption - inters []Interceptor - predicates []predicate.LedgerCustomerAccount - modifiers []func(*sql.Selector) + ctx *QueryContext + order []ledgercustomeraccount.OrderOption + inters []Interceptor + predicates []predicate.LedgerCustomerAccount + withAccount *LedgerAccountQuery + modifiers []func(*sql.Selector) // intermediate query (i.e. traversal path). sql *sql.Selector path func(context.Context) (*sql.Selector, error) @@ -60,6 +62,28 @@ func (_q *LedgerCustomerAccountQuery) Order(o ...ledgercustomeraccount.OrderOpti return _q } +// QueryAccount chains the current query on the "account" edge. +func (_q *LedgerCustomerAccountQuery) QueryAccount() *LedgerAccountQuery { + query := (&LedgerAccountClient{config: _q.config}).Query() + query.path = func(ctx context.Context) (fromU *sql.Selector, err error) { + if err := _q.prepareQuery(ctx); err != nil { + return nil, err + } + selector := _q.sqlQuery(ctx) + if err := selector.Err(); err != nil { + return nil, err + } + step := sqlgraph.NewStep( + sqlgraph.From(ledgercustomeraccount.Table, ledgercustomeraccount.FieldID, selector), + sqlgraph.To(ledgeraccount.Table, ledgeraccount.FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, ledgercustomeraccount.AccountTable, ledgercustomeraccount.AccountColumn), + ) + fromU = sqlgraph.SetNeighbors(_q.driver.Dialect(), step) + return fromU, nil + } + return query +} + // First returns the first LedgerCustomerAccount entity from the query. // Returns a *NotFoundError when no LedgerCustomerAccount was found. func (_q *LedgerCustomerAccountQuery) First(ctx context.Context) (*LedgerCustomerAccount, error) { @@ -247,17 +271,29 @@ func (_q *LedgerCustomerAccountQuery) Clone() *LedgerCustomerAccountQuery { return nil } return &LedgerCustomerAccountQuery{ - config: _q.config, - ctx: _q.ctx.Clone(), - order: append([]ledgercustomeraccount.OrderOption{}, _q.order...), - inters: append([]Interceptor{}, _q.inters...), - predicates: append([]predicate.LedgerCustomerAccount{}, _q.predicates...), + config: _q.config, + ctx: _q.ctx.Clone(), + order: append([]ledgercustomeraccount.OrderOption{}, _q.order...), + inters: append([]Interceptor{}, _q.inters...), + predicates: append([]predicate.LedgerCustomerAccount{}, _q.predicates...), + withAccount: _q.withAccount.Clone(), // clone intermediate query. sql: _q.sql.Clone(), path: _q.path, } } +// WithAccount tells the query-builder to eager-load the nodes that are connected to +// the "account" edge. The optional arguments are used to configure the query builder of the edge. +func (_q *LedgerCustomerAccountQuery) WithAccount(opts ...func(*LedgerAccountQuery)) *LedgerCustomerAccountQuery { + query := (&LedgerAccountClient{config: _q.config}).Query() + for _, opt := range opts { + opt(query) + } + _q.withAccount = query + return _q +} + // 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. // @@ -334,8 +370,11 @@ func (_q *LedgerCustomerAccountQuery) prepareQuery(ctx context.Context) error { func (_q *LedgerCustomerAccountQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*LedgerCustomerAccount, error) { var ( - nodes = []*LedgerCustomerAccount{} - _spec = _q.querySpec() + nodes = []*LedgerCustomerAccount{} + _spec = _q.querySpec() + loadedTypes = [1]bool{ + _q.withAccount != nil, + } ) _spec.ScanValues = func(columns []string) ([]any, error) { return (*LedgerCustomerAccount).scanValues(nil, columns) @@ -343,6 +382,7 @@ func (_q *LedgerCustomerAccountQuery) sqlAll(ctx context.Context, hooks ...query _spec.Assign = func(columns []string, values []any) error { node := &LedgerCustomerAccount{config: _q.config} nodes = append(nodes, node) + node.Edges.loadedTypes = loadedTypes return node.assignValues(columns, values) } if len(_q.modifiers) > 0 { @@ -357,9 +397,45 @@ func (_q *LedgerCustomerAccountQuery) sqlAll(ctx context.Context, hooks ...query if len(nodes) == 0 { return nodes, nil } + if query := _q.withAccount; query != nil { + if err := _q.loadAccount(ctx, query, nodes, nil, + func(n *LedgerCustomerAccount, e *LedgerAccount) { n.Edges.Account = e }); err != nil { + return nil, err + } + } return nodes, nil } +func (_q *LedgerCustomerAccountQuery) loadAccount(ctx context.Context, query *LedgerAccountQuery, nodes []*LedgerCustomerAccount, init func(*LedgerCustomerAccount), assign func(*LedgerCustomerAccount, *LedgerAccount)) error { + ids := make([]string, 0, len(nodes)) + nodeids := make(map[string][]*LedgerCustomerAccount) + for i := range nodes { + fk := nodes[i].AccountID + if _, ok := nodeids[fk]; !ok { + ids = append(ids, fk) + } + nodeids[fk] = append(nodeids[fk], nodes[i]) + } + if len(ids) == 0 { + return nil + } + query.Where(ledgeraccount.IDIn(ids...)) + neighbors, err := query.All(ctx) + if err != nil { + return err + } + for _, n := range neighbors { + nodes, ok := nodeids[n.ID] + if !ok { + return fmt.Errorf(`unexpected foreign-key "account_id" returned %v`, n.ID) + } + for i := range nodes { + assign(nodes[i], n) + } + } + return nil +} + func (_q *LedgerCustomerAccountQuery) sqlCount(ctx context.Context) (int, error) { _spec := _q.querySpec() if len(_q.modifiers) > 0 { @@ -388,6 +464,9 @@ func (_q *LedgerCustomerAccountQuery) querySpec() *sqlgraph.QuerySpec { _spec.Node.Columns = append(_spec.Node.Columns, fields[i]) } } + if _q.withAccount != nil { + _spec.Node.AddColumnOnce(ledgercustomeraccount.FieldAccountID) + } } if ps := _q.predicates; len(ps) > 0 { _spec.Predicate = func(selector *sql.Selector) { diff --git a/openmeter/ent/db/ledgercustomeraccount_update.go b/openmeter/ent/db/ledgercustomeraccount_update.go index dfd3d3b1cc..ab9feb3cb5 100644 --- a/openmeter/ent/db/ledgercustomeraccount_update.go +++ b/openmeter/ent/db/ledgercustomeraccount_update.go @@ -95,7 +95,18 @@ func (_u *LedgerCustomerAccountUpdate) defaults() { } } +// check runs all checks and user-defined validators on the builder. +func (_u *LedgerCustomerAccountUpdate) check() error { + if _u.mutation.AccountCleared() && len(_u.mutation.AccountIDs()) > 0 { + return errors.New(`db: clearing a required unique edge "LedgerCustomerAccount.account"`) + } + return nil +} + func (_u *LedgerCustomerAccountUpdate) sqlSave(ctx context.Context) (_node int, err error) { + if err := _u.check(); err != nil { + return _node, err + } _spec := sqlgraph.NewUpdateSpec(ledgercustomeraccount.Table, ledgercustomeraccount.Columns, sqlgraph.NewFieldSpec(ledgercustomeraccount.FieldID, field.TypeString)) if ps := _u.mutation.predicates; len(ps) > 0 { _spec.Predicate = func(selector *sql.Selector) { @@ -213,7 +224,18 @@ func (_u *LedgerCustomerAccountUpdateOne) defaults() { } } +// check runs all checks and user-defined validators on the builder. +func (_u *LedgerCustomerAccountUpdateOne) check() error { + if _u.mutation.AccountCleared() && len(_u.mutation.AccountIDs()) > 0 { + return errors.New(`db: clearing a required unique edge "LedgerCustomerAccount.account"`) + } + return nil +} + func (_u *LedgerCustomerAccountUpdateOne) sqlSave(ctx context.Context) (_node *LedgerCustomerAccount, err error) { + if err := _u.check(); err != nil { + return _node, err + } _spec := sqlgraph.NewUpdateSpec(ledgercustomeraccount.Table, ledgercustomeraccount.Columns, sqlgraph.NewFieldSpec(ledgercustomeraccount.FieldID, field.TypeString)) id, ok := _u.mutation.ID() if !ok { diff --git a/openmeter/ent/db/ledgerentry.go b/openmeter/ent/db/ledgerentry.go index f979e6367a..f5ff75d706 100644 --- a/openmeter/ent/db/ledgerentry.go +++ b/openmeter/ent/db/ledgerentry.go @@ -58,9 +58,11 @@ type LedgerEntryEdges struct { Transaction *LedgerTransaction `json:"transaction,omitempty"` // SubAccount holds the value of the sub_account edge. SubAccount *LedgerSubAccount `json:"sub_account,omitempty"` + // SourceBreakageRecords holds the value of the source_breakage_records edge. + SourceBreakageRecords []*LedgerBreakageRecord `json:"source_breakage_records,omitempty"` // loadedTypes holds the information for reporting if a // type was loaded (or requested) in eager-loading or not. - loadedTypes [2]bool + loadedTypes [3]bool } // TransactionOrErr returns the Transaction value or an error if the edge @@ -85,6 +87,15 @@ func (e LedgerEntryEdges) SubAccountOrErr() (*LedgerSubAccount, error) { return nil, &NotLoadedError{edge: "sub_account"} } +// SourceBreakageRecordsOrErr returns the SourceBreakageRecords value or an error if the edge +// was not loaded in eager-loading. +func (e LedgerEntryEdges) SourceBreakageRecordsOrErr() ([]*LedgerBreakageRecord, error) { + if e.loadedTypes[2] { + return e.SourceBreakageRecords, nil + } + return nil, &NotLoadedError{edge: "source_breakage_records"} +} + // scanValues returns the types for scanning values from sql.Rows. func (*LedgerEntry) scanValues(columns []string) ([]any, error) { values := make([]any, len(columns)) @@ -221,6 +232,11 @@ func (_m *LedgerEntry) QuerySubAccount() *LedgerSubAccountQuery { return NewLedgerEntryClient(_m.config).QuerySubAccount(_m) } +// QuerySourceBreakageRecords queries the "source_breakage_records" edge of the LedgerEntry entity. +func (_m *LedgerEntry) QuerySourceBreakageRecords() *LedgerBreakageRecordQuery { + return NewLedgerEntryClient(_m.config).QuerySourceBreakageRecords(_m) +} + // Update returns a builder for updating this LedgerEntry. // Note that you need to call LedgerEntry.Unwrap() before calling this method if this LedgerEntry // was returned from a transaction, and the transaction was committed or rolled back. diff --git a/openmeter/ent/db/ledgerentry/ledgerentry.go b/openmeter/ent/db/ledgerentry/ledgerentry.go index faf862db42..fde66c3148 100644 --- a/openmeter/ent/db/ledgerentry/ledgerentry.go +++ b/openmeter/ent/db/ledgerentry/ledgerentry.go @@ -42,6 +42,8 @@ const ( EdgeTransaction = "transaction" // EdgeSubAccount holds the string denoting the sub_account edge name in mutations. EdgeSubAccount = "sub_account" + // EdgeSourceBreakageRecords holds the string denoting the source_breakage_records edge name in mutations. + EdgeSourceBreakageRecords = "source_breakage_records" // Table holds the table name of the ledgerentry in the database. Table = "ledger_entries" // TransactionTable is the table that holds the transaction relation/edge. @@ -58,6 +60,13 @@ const ( SubAccountInverseTable = "ledger_sub_accounts" // SubAccountColumn is the table column denoting the sub_account relation/edge. SubAccountColumn = "sub_account_id" + // SourceBreakageRecordsTable is the table that holds the source_breakage_records relation/edge. + SourceBreakageRecordsTable = "ledger_breakage_records" + // SourceBreakageRecordsInverseTable is the table name for the LedgerBreakageRecord entity. + // It exists in this package in order to avoid circular dependency with the "ledgerbreakagerecord" package. + SourceBreakageRecordsInverseTable = "ledger_breakage_records" + // SourceBreakageRecordsColumn is the table column denoting the source_breakage_records relation/edge. + SourceBreakageRecordsColumn = "source_entry_id" ) // Columns holds all SQL columns for ledgerentry fields. @@ -184,6 +193,20 @@ func BySubAccountField(field string, opts ...sql.OrderTermOption) OrderOption { sqlgraph.OrderByNeighborTerms(s, newSubAccountStep(), sql.OrderByField(field, opts...)) } } + +// BySourceBreakageRecordsCount orders the results by source_breakage_records count. +func BySourceBreakageRecordsCount(opts ...sql.OrderTermOption) OrderOption { + return func(s *sql.Selector) { + sqlgraph.OrderByNeighborsCount(s, newSourceBreakageRecordsStep(), opts...) + } +} + +// BySourceBreakageRecords orders the results by source_breakage_records terms. +func BySourceBreakageRecords(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption { + return func(s *sql.Selector) { + sqlgraph.OrderByNeighborTerms(s, newSourceBreakageRecordsStep(), append([]sql.OrderTerm{term}, terms...)...) + } +} func newTransactionStep() *sqlgraph.Step { return sqlgraph.NewStep( sqlgraph.From(Table, FieldID), @@ -198,3 +221,10 @@ func newSubAccountStep() *sqlgraph.Step { sqlgraph.Edge(sqlgraph.M2O, true, SubAccountTable, SubAccountColumn), ) } +func newSourceBreakageRecordsStep() *sqlgraph.Step { + return sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.To(SourceBreakageRecordsInverseTable, FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, SourceBreakageRecordsTable, SourceBreakageRecordsColumn), + ) +} diff --git a/openmeter/ent/db/ledgerentry/where.go b/openmeter/ent/db/ledgerentry/where.go index 44de0346a1..b53fdc18ee 100644 --- a/openmeter/ent/db/ledgerentry/where.go +++ b/openmeter/ent/db/ledgerentry/where.go @@ -797,6 +797,29 @@ func HasSubAccountWith(preds ...predicate.LedgerSubAccount) predicate.LedgerEntr }) } +// HasSourceBreakageRecords applies the HasEdge predicate on the "source_breakage_records" edge. +func HasSourceBreakageRecords() predicate.LedgerEntry { + return predicate.LedgerEntry(func(s *sql.Selector) { + step := sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, SourceBreakageRecordsTable, SourceBreakageRecordsColumn), + ) + sqlgraph.HasNeighbors(s, step) + }) +} + +// HasSourceBreakageRecordsWith applies the HasEdge predicate on the "source_breakage_records" edge with a given conditions (other predicates). +func HasSourceBreakageRecordsWith(preds ...predicate.LedgerBreakageRecord) predicate.LedgerEntry { + return predicate.LedgerEntry(func(s *sql.Selector) { + step := newSourceBreakageRecordsStep() + sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) { + for _, p := range preds { + p(s) + } + }) + }) +} + // And groups predicates with the AND operator between them. func And(predicates ...predicate.LedgerEntry) predicate.LedgerEntry { return predicate.LedgerEntry(sql.AndPredicates(predicates...)) diff --git a/openmeter/ent/db/ledgerentry_create.go b/openmeter/ent/db/ledgerentry_create.go index 760b882a0a..2573d18725 100644 --- a/openmeter/ent/db/ledgerentry_create.go +++ b/openmeter/ent/db/ledgerentry_create.go @@ -13,6 +13,7 @@ import ( "entgo.io/ent/dialect/sql/sqlgraph" "entgo.io/ent/schema/field" "github.com/alpacahq/alpacadecimal" + "github.com/openmeterio/openmeter/openmeter/ent/db/ledgerbreakagerecord" "github.com/openmeterio/openmeter/openmeter/ent/db/ledgerentry" "github.com/openmeterio/openmeter/openmeter/ent/db/ledgersubaccount" "github.com/openmeterio/openmeter/openmeter/ent/db/ledgertransaction" @@ -179,6 +180,21 @@ func (_c *LedgerEntryCreate) SetSubAccount(v *LedgerSubAccount) *LedgerEntryCrea return _c.SetSubAccountID(v.ID) } +// AddSourceBreakageRecordIDs adds the "source_breakage_records" edge to the LedgerBreakageRecord entity by IDs. +func (_c *LedgerEntryCreate) AddSourceBreakageRecordIDs(ids ...string) *LedgerEntryCreate { + _c.mutation.AddSourceBreakageRecordIDs(ids...) + return _c +} + +// AddSourceBreakageRecords adds the "source_breakage_records" edges to the LedgerBreakageRecord entity. +func (_c *LedgerEntryCreate) AddSourceBreakageRecords(v ...*LedgerBreakageRecord) *LedgerEntryCreate { + ids := make([]string, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _c.AddSourceBreakageRecordIDs(ids...) +} + // Mutation returns the LedgerEntryMutation object of the builder. func (_c *LedgerEntryCreate) Mutation() *LedgerEntryMutation { return _c.mutation @@ -393,6 +409,22 @@ func (_c *LedgerEntryCreate) createSpec() (*LedgerEntry, *sqlgraph.CreateSpec) { _node.SubAccountID = nodes[0] _spec.Edges = append(_spec.Edges, edge) } + if nodes := _c.mutation.SourceBreakageRecordsIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgerentry.SourceBreakageRecordsTable, + Columns: []string{ledgerentry.SourceBreakageRecordsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges = append(_spec.Edges, edge) + } return _node, _spec } diff --git a/openmeter/ent/db/ledgerentry_query.go b/openmeter/ent/db/ledgerentry_query.go index a509ddec4e..8046709353 100644 --- a/openmeter/ent/db/ledgerentry_query.go +++ b/openmeter/ent/db/ledgerentry_query.go @@ -4,6 +4,7 @@ package db import ( "context" + "database/sql/driver" "fmt" "math" @@ -12,6 +13,7 @@ import ( "entgo.io/ent/dialect/sql" "entgo.io/ent/dialect/sql/sqlgraph" "entgo.io/ent/schema/field" + "github.com/openmeterio/openmeter/openmeter/ent/db/ledgerbreakagerecord" "github.com/openmeterio/openmeter/openmeter/ent/db/ledgerentry" "github.com/openmeterio/openmeter/openmeter/ent/db/ledgersubaccount" "github.com/openmeterio/openmeter/openmeter/ent/db/ledgertransaction" @@ -21,13 +23,14 @@ import ( // LedgerEntryQuery is the builder for querying LedgerEntry entities. type LedgerEntryQuery struct { config - ctx *QueryContext - order []ledgerentry.OrderOption - inters []Interceptor - predicates []predicate.LedgerEntry - withTransaction *LedgerTransactionQuery - withSubAccount *LedgerSubAccountQuery - modifiers []func(*sql.Selector) + ctx *QueryContext + order []ledgerentry.OrderOption + inters []Interceptor + predicates []predicate.LedgerEntry + withTransaction *LedgerTransactionQuery + withSubAccount *LedgerSubAccountQuery + withSourceBreakageRecords *LedgerBreakageRecordQuery + modifiers []func(*sql.Selector) // intermediate query (i.e. traversal path). sql *sql.Selector path func(context.Context) (*sql.Selector, error) @@ -108,6 +111,28 @@ func (_q *LedgerEntryQuery) QuerySubAccount() *LedgerSubAccountQuery { return query } +// QuerySourceBreakageRecords chains the current query on the "source_breakage_records" edge. +func (_q *LedgerEntryQuery) QuerySourceBreakageRecords() *LedgerBreakageRecordQuery { + query := (&LedgerBreakageRecordClient{config: _q.config}).Query() + query.path = func(ctx context.Context) (fromU *sql.Selector, err error) { + if err := _q.prepareQuery(ctx); err != nil { + return nil, err + } + selector := _q.sqlQuery(ctx) + if err := selector.Err(); err != nil { + return nil, err + } + step := sqlgraph.NewStep( + sqlgraph.From(ledgerentry.Table, ledgerentry.FieldID, selector), + sqlgraph.To(ledgerbreakagerecord.Table, ledgerbreakagerecord.FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, ledgerentry.SourceBreakageRecordsTable, ledgerentry.SourceBreakageRecordsColumn), + ) + fromU = sqlgraph.SetNeighbors(_q.driver.Dialect(), step) + return fromU, nil + } + return query +} + // First returns the first LedgerEntry entity from the query. // Returns a *NotFoundError when no LedgerEntry was found. func (_q *LedgerEntryQuery) First(ctx context.Context) (*LedgerEntry, error) { @@ -295,13 +320,14 @@ func (_q *LedgerEntryQuery) Clone() *LedgerEntryQuery { return nil } return &LedgerEntryQuery{ - config: _q.config, - ctx: _q.ctx.Clone(), - order: append([]ledgerentry.OrderOption{}, _q.order...), - inters: append([]Interceptor{}, _q.inters...), - predicates: append([]predicate.LedgerEntry{}, _q.predicates...), - withTransaction: _q.withTransaction.Clone(), - withSubAccount: _q.withSubAccount.Clone(), + config: _q.config, + ctx: _q.ctx.Clone(), + order: append([]ledgerentry.OrderOption{}, _q.order...), + inters: append([]Interceptor{}, _q.inters...), + predicates: append([]predicate.LedgerEntry{}, _q.predicates...), + withTransaction: _q.withTransaction.Clone(), + withSubAccount: _q.withSubAccount.Clone(), + withSourceBreakageRecords: _q.withSourceBreakageRecords.Clone(), // clone intermediate query. sql: _q.sql.Clone(), path: _q.path, @@ -330,6 +356,17 @@ func (_q *LedgerEntryQuery) WithSubAccount(opts ...func(*LedgerSubAccountQuery)) return _q } +// WithSourceBreakageRecords tells the query-builder to eager-load the nodes that are connected to +// the "source_breakage_records" edge. The optional arguments are used to configure the query builder of the edge. +func (_q *LedgerEntryQuery) WithSourceBreakageRecords(opts ...func(*LedgerBreakageRecordQuery)) *LedgerEntryQuery { + query := (&LedgerBreakageRecordClient{config: _q.config}).Query() + for _, opt := range opts { + opt(query) + } + _q.withSourceBreakageRecords = query + return _q +} + // 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. // @@ -408,9 +445,10 @@ func (_q *LedgerEntryQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]* var ( nodes = []*LedgerEntry{} _spec = _q.querySpec() - loadedTypes = [2]bool{ + loadedTypes = [3]bool{ _q.withTransaction != nil, _q.withSubAccount != nil, + _q.withSourceBreakageRecords != nil, } ) _spec.ScanValues = func(columns []string) ([]any, error) { @@ -446,6 +484,15 @@ func (_q *LedgerEntryQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]* return nil, err } } + if query := _q.withSourceBreakageRecords; query != nil { + if err := _q.loadSourceBreakageRecords(ctx, query, nodes, + func(n *LedgerEntry) { n.Edges.SourceBreakageRecords = []*LedgerBreakageRecord{} }, + func(n *LedgerEntry, e *LedgerBreakageRecord) { + n.Edges.SourceBreakageRecords = append(n.Edges.SourceBreakageRecords, e) + }); err != nil { + return nil, err + } + } return nodes, nil } @@ -507,6 +554,39 @@ func (_q *LedgerEntryQuery) loadSubAccount(ctx context.Context, query *LedgerSub } return nil } +func (_q *LedgerEntryQuery) loadSourceBreakageRecords(ctx context.Context, query *LedgerBreakageRecordQuery, nodes []*LedgerEntry, init func(*LedgerEntry), assign func(*LedgerEntry, *LedgerBreakageRecord)) error { + fks := make([]driver.Value, 0, len(nodes)) + nodeids := make(map[string]*LedgerEntry) + for i := range nodes { + fks = append(fks, nodes[i].ID) + nodeids[nodes[i].ID] = nodes[i] + if init != nil { + init(nodes[i]) + } + } + if len(query.ctx.Fields) > 0 { + query.ctx.AppendFieldOnce(ledgerbreakagerecord.FieldSourceEntryID) + } + query.Where(predicate.LedgerBreakageRecord(func(s *sql.Selector) { + s.Where(sql.InValues(s.C(ledgerentry.SourceBreakageRecordsColumn), fks...)) + })) + neighbors, err := query.All(ctx) + if err != nil { + return err + } + for _, n := range neighbors { + fk := n.SourceEntryID + if fk == nil { + return fmt.Errorf(`foreign-key "source_entry_id" is nil for node %v`, n.ID) + } + node, ok := nodeids[*fk] + if !ok { + return fmt.Errorf(`unexpected referenced foreign-key "source_entry_id" returned %v for node %v`, *fk, n.ID) + } + assign(node, n) + } + return nil +} func (_q *LedgerEntryQuery) sqlCount(ctx context.Context) (int, error) { _spec := _q.querySpec() diff --git a/openmeter/ent/db/ledgerentry_update.go b/openmeter/ent/db/ledgerentry_update.go index 37e82ec25e..ccf638ff6b 100644 --- a/openmeter/ent/db/ledgerentry_update.go +++ b/openmeter/ent/db/ledgerentry_update.go @@ -11,6 +11,7 @@ import ( "entgo.io/ent/dialect/sql" "entgo.io/ent/dialect/sql/sqlgraph" "entgo.io/ent/schema/field" + "github.com/openmeterio/openmeter/openmeter/ent/db/ledgerbreakagerecord" "github.com/openmeterio/openmeter/openmeter/ent/db/ledgerentry" "github.com/openmeterio/openmeter/openmeter/ent/db/predicate" "github.com/openmeterio/openmeter/pkg/models" @@ -67,11 +68,47 @@ func (_u *LedgerEntryUpdate) ClearDeletedAt() *LedgerEntryUpdate { return _u } +// AddSourceBreakageRecordIDs adds the "source_breakage_records" edge to the LedgerBreakageRecord entity by IDs. +func (_u *LedgerEntryUpdate) AddSourceBreakageRecordIDs(ids ...string) *LedgerEntryUpdate { + _u.mutation.AddSourceBreakageRecordIDs(ids...) + return _u +} + +// AddSourceBreakageRecords adds the "source_breakage_records" edges to the LedgerBreakageRecord entity. +func (_u *LedgerEntryUpdate) AddSourceBreakageRecords(v ...*LedgerBreakageRecord) *LedgerEntryUpdate { + ids := make([]string, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _u.AddSourceBreakageRecordIDs(ids...) +} + // Mutation returns the LedgerEntryMutation object of the builder. func (_u *LedgerEntryUpdate) Mutation() *LedgerEntryMutation { return _u.mutation } +// ClearSourceBreakageRecords clears all "source_breakage_records" edges to the LedgerBreakageRecord entity. +func (_u *LedgerEntryUpdate) ClearSourceBreakageRecords() *LedgerEntryUpdate { + _u.mutation.ClearSourceBreakageRecords() + return _u +} + +// RemoveSourceBreakageRecordIDs removes the "source_breakage_records" edge to LedgerBreakageRecord entities by IDs. +func (_u *LedgerEntryUpdate) RemoveSourceBreakageRecordIDs(ids ...string) *LedgerEntryUpdate { + _u.mutation.RemoveSourceBreakageRecordIDs(ids...) + return _u +} + +// RemoveSourceBreakageRecords removes "source_breakage_records" edges to LedgerBreakageRecord entities. +func (_u *LedgerEntryUpdate) RemoveSourceBreakageRecords(v ...*LedgerBreakageRecord) *LedgerEntryUpdate { + ids := make([]string, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _u.RemoveSourceBreakageRecordIDs(ids...) +} + // Save executes the query and returns the number of nodes affected by the update operation. func (_u *LedgerEntryUpdate) Save(ctx context.Context) (int, error) { _u.defaults() @@ -152,6 +189,51 @@ func (_u *LedgerEntryUpdate) sqlSave(ctx context.Context) (_node int, err error) if _u.mutation.SpendChargeIDCleared() { _spec.ClearField(ledgerentry.FieldSpendChargeID, field.TypeString) } + if _u.mutation.SourceBreakageRecordsCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgerentry.SourceBreakageRecordsTable, + Columns: []string{ledgerentry.SourceBreakageRecordsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := _u.mutation.RemovedSourceBreakageRecordsIDs(); len(nodes) > 0 && !_u.mutation.SourceBreakageRecordsCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgerentry.SourceBreakageRecordsTable, + Columns: []string{ledgerentry.SourceBreakageRecordsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := _u.mutation.SourceBreakageRecordsIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgerentry.SourceBreakageRecordsTable, + Columns: []string{ledgerentry.SourceBreakageRecordsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Add = append(_spec.Edges.Add, edge) + } if _node, err = sqlgraph.UpdateNodes(ctx, _u.driver, _spec); err != nil { if _, ok := err.(*sqlgraph.NotFoundError); ok { err = &NotFoundError{ledgerentry.Label} @@ -210,11 +292,47 @@ func (_u *LedgerEntryUpdateOne) ClearDeletedAt() *LedgerEntryUpdateOne { return _u } +// AddSourceBreakageRecordIDs adds the "source_breakage_records" edge to the LedgerBreakageRecord entity by IDs. +func (_u *LedgerEntryUpdateOne) AddSourceBreakageRecordIDs(ids ...string) *LedgerEntryUpdateOne { + _u.mutation.AddSourceBreakageRecordIDs(ids...) + return _u +} + +// AddSourceBreakageRecords adds the "source_breakage_records" edges to the LedgerBreakageRecord entity. +func (_u *LedgerEntryUpdateOne) AddSourceBreakageRecords(v ...*LedgerBreakageRecord) *LedgerEntryUpdateOne { + ids := make([]string, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _u.AddSourceBreakageRecordIDs(ids...) +} + // Mutation returns the LedgerEntryMutation object of the builder. func (_u *LedgerEntryUpdateOne) Mutation() *LedgerEntryMutation { return _u.mutation } +// ClearSourceBreakageRecords clears all "source_breakage_records" edges to the LedgerBreakageRecord entity. +func (_u *LedgerEntryUpdateOne) ClearSourceBreakageRecords() *LedgerEntryUpdateOne { + _u.mutation.ClearSourceBreakageRecords() + return _u +} + +// RemoveSourceBreakageRecordIDs removes the "source_breakage_records" edge to LedgerBreakageRecord entities by IDs. +func (_u *LedgerEntryUpdateOne) RemoveSourceBreakageRecordIDs(ids ...string) *LedgerEntryUpdateOne { + _u.mutation.RemoveSourceBreakageRecordIDs(ids...) + return _u +} + +// RemoveSourceBreakageRecords removes "source_breakage_records" edges to LedgerBreakageRecord entities. +func (_u *LedgerEntryUpdateOne) RemoveSourceBreakageRecords(v ...*LedgerBreakageRecord) *LedgerEntryUpdateOne { + ids := make([]string, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _u.RemoveSourceBreakageRecordIDs(ids...) +} + // Where appends a list predicates to the LedgerEntryUpdate builder. func (_u *LedgerEntryUpdateOne) Where(ps ...predicate.LedgerEntry) *LedgerEntryUpdateOne { _u.mutation.Where(ps...) @@ -325,6 +443,51 @@ func (_u *LedgerEntryUpdateOne) sqlSave(ctx context.Context) (_node *LedgerEntry if _u.mutation.SpendChargeIDCleared() { _spec.ClearField(ledgerentry.FieldSpendChargeID, field.TypeString) } + if _u.mutation.SourceBreakageRecordsCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgerentry.SourceBreakageRecordsTable, + Columns: []string{ledgerentry.SourceBreakageRecordsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := _u.mutation.RemovedSourceBreakageRecordsIDs(); len(nodes) > 0 && !_u.mutation.SourceBreakageRecordsCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgerentry.SourceBreakageRecordsTable, + Columns: []string{ledgerentry.SourceBreakageRecordsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := _u.mutation.SourceBreakageRecordsIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgerentry.SourceBreakageRecordsTable, + Columns: []string{ledgerentry.SourceBreakageRecordsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Add = append(_spec.Edges.Add, edge) + } _node = &LedgerEntry{config: _u.config} _spec.Assign = _node.assignValues _spec.ScanValues = _node.scanValues diff --git a/openmeter/ent/db/ledgersubaccount.go b/openmeter/ent/db/ledgersubaccount.go index 3a0c7df93f..c35485b918 100644 --- a/openmeter/ent/db/ledgersubaccount.go +++ b/openmeter/ent/db/ledgersubaccount.go @@ -49,9 +49,13 @@ type LedgerSubAccountEdges struct { Route *LedgerSubAccountRoute `json:"route,omitempty"` // Entries holds the value of the entries edge. Entries []*LedgerEntry `json:"entries,omitempty"` + // FboBreakageRecords holds the value of the fbo_breakage_records edge. + FboBreakageRecords []*LedgerBreakageRecord `json:"fbo_breakage_records,omitempty"` + // BreakageRecords holds the value of the breakage_records edge. + BreakageRecords []*LedgerBreakageRecord `json:"breakage_records,omitempty"` // loadedTypes holds the information for reporting if a // type was loaded (or requested) in eager-loading or not. - loadedTypes [3]bool + loadedTypes [5]bool } // AccountOrErr returns the Account value or an error if the edge @@ -85,6 +89,24 @@ func (e LedgerSubAccountEdges) EntriesOrErr() ([]*LedgerEntry, error) { return nil, &NotLoadedError{edge: "entries"} } +// FboBreakageRecordsOrErr returns the FboBreakageRecords value or an error if the edge +// was not loaded in eager-loading. +func (e LedgerSubAccountEdges) FboBreakageRecordsOrErr() ([]*LedgerBreakageRecord, error) { + if e.loadedTypes[3] { + return e.FboBreakageRecords, nil + } + return nil, &NotLoadedError{edge: "fbo_breakage_records"} +} + +// BreakageRecordsOrErr returns the BreakageRecords value or an error if the edge +// was not loaded in eager-loading. +func (e LedgerSubAccountEdges) BreakageRecordsOrErr() ([]*LedgerBreakageRecord, error) { + if e.loadedTypes[4] { + return e.BreakageRecords, nil + } + return nil, &NotLoadedError{edge: "breakage_records"} +} + // scanValues returns the types for scanning values from sql.Rows. func (*LedgerSubAccount) scanValues(columns []string) ([]any, error) { values := make([]any, len(columns)) @@ -190,6 +212,16 @@ func (_m *LedgerSubAccount) QueryEntries() *LedgerEntryQuery { return NewLedgerSubAccountClient(_m.config).QueryEntries(_m) } +// QueryFboBreakageRecords queries the "fbo_breakage_records" edge of the LedgerSubAccount entity. +func (_m *LedgerSubAccount) QueryFboBreakageRecords() *LedgerBreakageRecordQuery { + return NewLedgerSubAccountClient(_m.config).QueryFboBreakageRecords(_m) +} + +// QueryBreakageRecords queries the "breakage_records" edge of the LedgerSubAccount entity. +func (_m *LedgerSubAccount) QueryBreakageRecords() *LedgerBreakageRecordQuery { + return NewLedgerSubAccountClient(_m.config).QueryBreakageRecords(_m) +} + // Update returns a builder for updating this LedgerSubAccount. // Note that you need to call LedgerSubAccount.Unwrap() before calling this method if this LedgerSubAccount // was returned from a transaction, and the transaction was committed or rolled back. diff --git a/openmeter/ent/db/ledgersubaccount/ledgersubaccount.go b/openmeter/ent/db/ledgersubaccount/ledgersubaccount.go index 0fc52fe97a..40a694eb69 100644 --- a/openmeter/ent/db/ledgersubaccount/ledgersubaccount.go +++ b/openmeter/ent/db/ledgersubaccount/ledgersubaccount.go @@ -34,6 +34,10 @@ const ( EdgeRoute = "route" // EdgeEntries holds the string denoting the entries edge name in mutations. EdgeEntries = "entries" + // EdgeFboBreakageRecords holds the string denoting the fbo_breakage_records edge name in mutations. + EdgeFboBreakageRecords = "fbo_breakage_records" + // EdgeBreakageRecords holds the string denoting the breakage_records edge name in mutations. + EdgeBreakageRecords = "breakage_records" // Table holds the table name of the ledgersubaccount in the database. Table = "ledger_sub_accounts" // AccountTable is the table that holds the account relation/edge. @@ -57,6 +61,20 @@ const ( EntriesInverseTable = "ledger_entries" // EntriesColumn is the table column denoting the entries relation/edge. EntriesColumn = "sub_account_id" + // FboBreakageRecordsTable is the table that holds the fbo_breakage_records relation/edge. + FboBreakageRecordsTable = "ledger_breakage_records" + // FboBreakageRecordsInverseTable is the table name for the LedgerBreakageRecord entity. + // It exists in this package in order to avoid circular dependency with the "ledgerbreakagerecord" package. + FboBreakageRecordsInverseTable = "ledger_breakage_records" + // FboBreakageRecordsColumn is the table column denoting the fbo_breakage_records relation/edge. + FboBreakageRecordsColumn = "fbo_sub_account_id" + // BreakageRecordsTable is the table that holds the breakage_records relation/edge. + BreakageRecordsTable = "ledger_breakage_records" + // BreakageRecordsInverseTable is the table name for the LedgerBreakageRecord entity. + // It exists in this package in order to avoid circular dependency with the "ledgerbreakagerecord" package. + BreakageRecordsInverseTable = "ledger_breakage_records" + // BreakageRecordsColumn is the table column denoting the breakage_records relation/edge. + BreakageRecordsColumn = "breakage_sub_account_id" ) // Columns holds all SQL columns for ledgersubaccount fields. @@ -159,6 +177,34 @@ func ByEntries(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption { sqlgraph.OrderByNeighborTerms(s, newEntriesStep(), append([]sql.OrderTerm{term}, terms...)...) } } + +// ByFboBreakageRecordsCount orders the results by fbo_breakage_records count. +func ByFboBreakageRecordsCount(opts ...sql.OrderTermOption) OrderOption { + return func(s *sql.Selector) { + sqlgraph.OrderByNeighborsCount(s, newFboBreakageRecordsStep(), opts...) + } +} + +// ByFboBreakageRecords orders the results by fbo_breakage_records terms. +func ByFboBreakageRecords(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption { + return func(s *sql.Selector) { + sqlgraph.OrderByNeighborTerms(s, newFboBreakageRecordsStep(), append([]sql.OrderTerm{term}, terms...)...) + } +} + +// ByBreakageRecordsCount orders the results by breakage_records count. +func ByBreakageRecordsCount(opts ...sql.OrderTermOption) OrderOption { + return func(s *sql.Selector) { + sqlgraph.OrderByNeighborsCount(s, newBreakageRecordsStep(), opts...) + } +} + +// ByBreakageRecords orders the results by breakage_records terms. +func ByBreakageRecords(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption { + return func(s *sql.Selector) { + sqlgraph.OrderByNeighborTerms(s, newBreakageRecordsStep(), append([]sql.OrderTerm{term}, terms...)...) + } +} func newAccountStep() *sqlgraph.Step { return sqlgraph.NewStep( sqlgraph.From(Table, FieldID), @@ -180,3 +226,17 @@ func newEntriesStep() *sqlgraph.Step { sqlgraph.Edge(sqlgraph.O2M, false, EntriesTable, EntriesColumn), ) } +func newFboBreakageRecordsStep() *sqlgraph.Step { + return sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.To(FboBreakageRecordsInverseTable, FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, FboBreakageRecordsTable, FboBreakageRecordsColumn), + ) +} +func newBreakageRecordsStep() *sqlgraph.Step { + return sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.To(BreakageRecordsInverseTable, FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, BreakageRecordsTable, BreakageRecordsColumn), + ) +} diff --git a/openmeter/ent/db/ledgersubaccount/where.go b/openmeter/ent/db/ledgersubaccount/where.go index 620325807c..c7b743d2d5 100644 --- a/openmeter/ent/db/ledgersubaccount/where.go +++ b/openmeter/ent/db/ledgersubaccount/where.go @@ -499,6 +499,52 @@ func HasEntriesWith(preds ...predicate.LedgerEntry) predicate.LedgerSubAccount { }) } +// HasFboBreakageRecords applies the HasEdge predicate on the "fbo_breakage_records" edge. +func HasFboBreakageRecords() predicate.LedgerSubAccount { + return predicate.LedgerSubAccount(func(s *sql.Selector) { + step := sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, FboBreakageRecordsTable, FboBreakageRecordsColumn), + ) + sqlgraph.HasNeighbors(s, step) + }) +} + +// HasFboBreakageRecordsWith applies the HasEdge predicate on the "fbo_breakage_records" edge with a given conditions (other predicates). +func HasFboBreakageRecordsWith(preds ...predicate.LedgerBreakageRecord) predicate.LedgerSubAccount { + return predicate.LedgerSubAccount(func(s *sql.Selector) { + step := newFboBreakageRecordsStep() + sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) { + for _, p := range preds { + p(s) + } + }) + }) +} + +// HasBreakageRecords applies the HasEdge predicate on the "breakage_records" edge. +func HasBreakageRecords() predicate.LedgerSubAccount { + return predicate.LedgerSubAccount(func(s *sql.Selector) { + step := sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, BreakageRecordsTable, BreakageRecordsColumn), + ) + sqlgraph.HasNeighbors(s, step) + }) +} + +// HasBreakageRecordsWith applies the HasEdge predicate on the "breakage_records" edge with a given conditions (other predicates). +func HasBreakageRecordsWith(preds ...predicate.LedgerBreakageRecord) predicate.LedgerSubAccount { + return predicate.LedgerSubAccount(func(s *sql.Selector) { + step := newBreakageRecordsStep() + sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) { + for _, p := range preds { + p(s) + } + }) + }) +} + // And groups predicates with the AND operator between them. func And(predicates ...predicate.LedgerSubAccount) predicate.LedgerSubAccount { return predicate.LedgerSubAccount(sql.AndPredicates(predicates...)) diff --git a/openmeter/ent/db/ledgersubaccount_create.go b/openmeter/ent/db/ledgersubaccount_create.go index b47fcc7ac8..90fd2b69cf 100644 --- a/openmeter/ent/db/ledgersubaccount_create.go +++ b/openmeter/ent/db/ledgersubaccount_create.go @@ -13,6 +13,7 @@ import ( "entgo.io/ent/dialect/sql/sqlgraph" "entgo.io/ent/schema/field" "github.com/openmeterio/openmeter/openmeter/ent/db/ledgeraccount" + "github.com/openmeterio/openmeter/openmeter/ent/db/ledgerbreakagerecord" "github.com/openmeterio/openmeter/openmeter/ent/db/ledgerentry" "github.com/openmeterio/openmeter/openmeter/ent/db/ledgersubaccount" "github.com/openmeterio/openmeter/openmeter/ent/db/ledgersubaccountroute" @@ -132,6 +133,36 @@ func (_c *LedgerSubAccountCreate) AddEntries(v ...*LedgerEntry) *LedgerSubAccoun return _c.AddEntryIDs(ids...) } +// AddFboBreakageRecordIDs adds the "fbo_breakage_records" edge to the LedgerBreakageRecord entity by IDs. +func (_c *LedgerSubAccountCreate) AddFboBreakageRecordIDs(ids ...string) *LedgerSubAccountCreate { + _c.mutation.AddFboBreakageRecordIDs(ids...) + return _c +} + +// AddFboBreakageRecords adds the "fbo_breakage_records" edges to the LedgerBreakageRecord entity. +func (_c *LedgerSubAccountCreate) AddFboBreakageRecords(v ...*LedgerBreakageRecord) *LedgerSubAccountCreate { + ids := make([]string, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _c.AddFboBreakageRecordIDs(ids...) +} + +// AddBreakageRecordIDs adds the "breakage_records" edge to the LedgerBreakageRecord entity by IDs. +func (_c *LedgerSubAccountCreate) AddBreakageRecordIDs(ids ...string) *LedgerSubAccountCreate { + _c.mutation.AddBreakageRecordIDs(ids...) + return _c +} + +// AddBreakageRecords adds the "breakage_records" edges to the LedgerBreakageRecord entity. +func (_c *LedgerSubAccountCreate) AddBreakageRecords(v ...*LedgerBreakageRecord) *LedgerSubAccountCreate { + ids := make([]string, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _c.AddBreakageRecordIDs(ids...) +} + // Mutation returns the LedgerSubAccountMutation object of the builder. func (_c *LedgerSubAccountCreate) Mutation() *LedgerSubAccountMutation { return _c.mutation @@ -315,6 +346,38 @@ func (_c *LedgerSubAccountCreate) createSpec() (*LedgerSubAccount, *sqlgraph.Cre } _spec.Edges = append(_spec.Edges, edge) } + if nodes := _c.mutation.FboBreakageRecordsIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgersubaccount.FboBreakageRecordsTable, + Columns: []string{ledgersubaccount.FboBreakageRecordsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges = append(_spec.Edges, edge) + } + if nodes := _c.mutation.BreakageRecordsIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgersubaccount.BreakageRecordsTable, + Columns: []string{ledgersubaccount.BreakageRecordsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges = append(_spec.Edges, edge) + } return _node, _spec } diff --git a/openmeter/ent/db/ledgersubaccount_query.go b/openmeter/ent/db/ledgersubaccount_query.go index d0be58ae43..bee60d1714 100644 --- a/openmeter/ent/db/ledgersubaccount_query.go +++ b/openmeter/ent/db/ledgersubaccount_query.go @@ -14,6 +14,7 @@ import ( "entgo.io/ent/dialect/sql/sqlgraph" "entgo.io/ent/schema/field" "github.com/openmeterio/openmeter/openmeter/ent/db/ledgeraccount" + "github.com/openmeterio/openmeter/openmeter/ent/db/ledgerbreakagerecord" "github.com/openmeterio/openmeter/openmeter/ent/db/ledgerentry" "github.com/openmeterio/openmeter/openmeter/ent/db/ledgersubaccount" "github.com/openmeterio/openmeter/openmeter/ent/db/ledgersubaccountroute" @@ -23,14 +24,16 @@ import ( // LedgerSubAccountQuery is the builder for querying LedgerSubAccount entities. type LedgerSubAccountQuery struct { config - ctx *QueryContext - order []ledgersubaccount.OrderOption - inters []Interceptor - predicates []predicate.LedgerSubAccount - withAccount *LedgerAccountQuery - withRoute *LedgerSubAccountRouteQuery - withEntries *LedgerEntryQuery - modifiers []func(*sql.Selector) + ctx *QueryContext + order []ledgersubaccount.OrderOption + inters []Interceptor + predicates []predicate.LedgerSubAccount + withAccount *LedgerAccountQuery + withRoute *LedgerSubAccountRouteQuery + withEntries *LedgerEntryQuery + withFboBreakageRecords *LedgerBreakageRecordQuery + withBreakageRecords *LedgerBreakageRecordQuery + modifiers []func(*sql.Selector) // intermediate query (i.e. traversal path). sql *sql.Selector path func(context.Context) (*sql.Selector, error) @@ -133,6 +136,50 @@ func (_q *LedgerSubAccountQuery) QueryEntries() *LedgerEntryQuery { return query } +// QueryFboBreakageRecords chains the current query on the "fbo_breakage_records" edge. +func (_q *LedgerSubAccountQuery) QueryFboBreakageRecords() *LedgerBreakageRecordQuery { + query := (&LedgerBreakageRecordClient{config: _q.config}).Query() + query.path = func(ctx context.Context) (fromU *sql.Selector, err error) { + if err := _q.prepareQuery(ctx); err != nil { + return nil, err + } + selector := _q.sqlQuery(ctx) + if err := selector.Err(); err != nil { + return nil, err + } + step := sqlgraph.NewStep( + sqlgraph.From(ledgersubaccount.Table, ledgersubaccount.FieldID, selector), + sqlgraph.To(ledgerbreakagerecord.Table, ledgerbreakagerecord.FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, ledgersubaccount.FboBreakageRecordsTable, ledgersubaccount.FboBreakageRecordsColumn), + ) + fromU = sqlgraph.SetNeighbors(_q.driver.Dialect(), step) + return fromU, nil + } + return query +} + +// QueryBreakageRecords chains the current query on the "breakage_records" edge. +func (_q *LedgerSubAccountQuery) QueryBreakageRecords() *LedgerBreakageRecordQuery { + query := (&LedgerBreakageRecordClient{config: _q.config}).Query() + query.path = func(ctx context.Context) (fromU *sql.Selector, err error) { + if err := _q.prepareQuery(ctx); err != nil { + return nil, err + } + selector := _q.sqlQuery(ctx) + if err := selector.Err(); err != nil { + return nil, err + } + step := sqlgraph.NewStep( + sqlgraph.From(ledgersubaccount.Table, ledgersubaccount.FieldID, selector), + sqlgraph.To(ledgerbreakagerecord.Table, ledgerbreakagerecord.FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, ledgersubaccount.BreakageRecordsTable, ledgersubaccount.BreakageRecordsColumn), + ) + fromU = sqlgraph.SetNeighbors(_q.driver.Dialect(), step) + return fromU, nil + } + return query +} + // First returns the first LedgerSubAccount entity from the query. // Returns a *NotFoundError when no LedgerSubAccount was found. func (_q *LedgerSubAccountQuery) First(ctx context.Context) (*LedgerSubAccount, error) { @@ -320,14 +367,16 @@ func (_q *LedgerSubAccountQuery) Clone() *LedgerSubAccountQuery { return nil } return &LedgerSubAccountQuery{ - config: _q.config, - ctx: _q.ctx.Clone(), - order: append([]ledgersubaccount.OrderOption{}, _q.order...), - inters: append([]Interceptor{}, _q.inters...), - predicates: append([]predicate.LedgerSubAccount{}, _q.predicates...), - withAccount: _q.withAccount.Clone(), - withRoute: _q.withRoute.Clone(), - withEntries: _q.withEntries.Clone(), + config: _q.config, + ctx: _q.ctx.Clone(), + order: append([]ledgersubaccount.OrderOption{}, _q.order...), + inters: append([]Interceptor{}, _q.inters...), + predicates: append([]predicate.LedgerSubAccount{}, _q.predicates...), + withAccount: _q.withAccount.Clone(), + withRoute: _q.withRoute.Clone(), + withEntries: _q.withEntries.Clone(), + withFboBreakageRecords: _q.withFboBreakageRecords.Clone(), + withBreakageRecords: _q.withBreakageRecords.Clone(), // clone intermediate query. sql: _q.sql.Clone(), path: _q.path, @@ -367,6 +416,28 @@ func (_q *LedgerSubAccountQuery) WithEntries(opts ...func(*LedgerEntryQuery)) *L return _q } +// WithFboBreakageRecords tells the query-builder to eager-load the nodes that are connected to +// the "fbo_breakage_records" edge. The optional arguments are used to configure the query builder of the edge. +func (_q *LedgerSubAccountQuery) WithFboBreakageRecords(opts ...func(*LedgerBreakageRecordQuery)) *LedgerSubAccountQuery { + query := (&LedgerBreakageRecordClient{config: _q.config}).Query() + for _, opt := range opts { + opt(query) + } + _q.withFboBreakageRecords = query + return _q +} + +// WithBreakageRecords tells the query-builder to eager-load the nodes that are connected to +// the "breakage_records" edge. The optional arguments are used to configure the query builder of the edge. +func (_q *LedgerSubAccountQuery) WithBreakageRecords(opts ...func(*LedgerBreakageRecordQuery)) *LedgerSubAccountQuery { + query := (&LedgerBreakageRecordClient{config: _q.config}).Query() + for _, opt := range opts { + opt(query) + } + _q.withBreakageRecords = query + return _q +} + // 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. // @@ -445,10 +516,12 @@ func (_q *LedgerSubAccountQuery) sqlAll(ctx context.Context, hooks ...queryHook) var ( nodes = []*LedgerSubAccount{} _spec = _q.querySpec() - loadedTypes = [3]bool{ + loadedTypes = [5]bool{ _q.withAccount != nil, _q.withRoute != nil, _q.withEntries != nil, + _q.withFboBreakageRecords != nil, + _q.withBreakageRecords != nil, } ) _spec.ScanValues = func(columns []string) ([]any, error) { @@ -491,6 +564,24 @@ func (_q *LedgerSubAccountQuery) sqlAll(ctx context.Context, hooks ...queryHook) return nil, err } } + if query := _q.withFboBreakageRecords; query != nil { + if err := _q.loadFboBreakageRecords(ctx, query, nodes, + func(n *LedgerSubAccount) { n.Edges.FboBreakageRecords = []*LedgerBreakageRecord{} }, + func(n *LedgerSubAccount, e *LedgerBreakageRecord) { + n.Edges.FboBreakageRecords = append(n.Edges.FboBreakageRecords, e) + }); err != nil { + return nil, err + } + } + if query := _q.withBreakageRecords; query != nil { + if err := _q.loadBreakageRecords(ctx, query, nodes, + func(n *LedgerSubAccount) { n.Edges.BreakageRecords = []*LedgerBreakageRecord{} }, + func(n *LedgerSubAccount, e *LedgerBreakageRecord) { + n.Edges.BreakageRecords = append(n.Edges.BreakageRecords, e) + }); err != nil { + return nil, err + } + } return nodes, nil } @@ -582,6 +673,66 @@ func (_q *LedgerSubAccountQuery) loadEntries(ctx context.Context, query *LedgerE } return nil } +func (_q *LedgerSubAccountQuery) loadFboBreakageRecords(ctx context.Context, query *LedgerBreakageRecordQuery, nodes []*LedgerSubAccount, init func(*LedgerSubAccount), assign func(*LedgerSubAccount, *LedgerBreakageRecord)) error { + fks := make([]driver.Value, 0, len(nodes)) + nodeids := make(map[string]*LedgerSubAccount) + for i := range nodes { + fks = append(fks, nodes[i].ID) + nodeids[nodes[i].ID] = nodes[i] + if init != nil { + init(nodes[i]) + } + } + if len(query.ctx.Fields) > 0 { + query.ctx.AppendFieldOnce(ledgerbreakagerecord.FieldFboSubAccountID) + } + query.Where(predicate.LedgerBreakageRecord(func(s *sql.Selector) { + s.Where(sql.InValues(s.C(ledgersubaccount.FboBreakageRecordsColumn), fks...)) + })) + neighbors, err := query.All(ctx) + if err != nil { + return err + } + for _, n := range neighbors { + fk := n.FboSubAccountID + node, ok := nodeids[fk] + if !ok { + return fmt.Errorf(`unexpected referenced foreign-key "fbo_sub_account_id" returned %v for node %v`, fk, n.ID) + } + assign(node, n) + } + return nil +} +func (_q *LedgerSubAccountQuery) loadBreakageRecords(ctx context.Context, query *LedgerBreakageRecordQuery, nodes []*LedgerSubAccount, init func(*LedgerSubAccount), assign func(*LedgerSubAccount, *LedgerBreakageRecord)) error { + fks := make([]driver.Value, 0, len(nodes)) + nodeids := make(map[string]*LedgerSubAccount) + for i := range nodes { + fks = append(fks, nodes[i].ID) + nodeids[nodes[i].ID] = nodes[i] + if init != nil { + init(nodes[i]) + } + } + if len(query.ctx.Fields) > 0 { + query.ctx.AppendFieldOnce(ledgerbreakagerecord.FieldBreakageSubAccountID) + } + query.Where(predicate.LedgerBreakageRecord(func(s *sql.Selector) { + s.Where(sql.InValues(s.C(ledgersubaccount.BreakageRecordsColumn), fks...)) + })) + neighbors, err := query.All(ctx) + if err != nil { + return err + } + for _, n := range neighbors { + fk := n.BreakageSubAccountID + node, ok := nodeids[fk] + if !ok { + return fmt.Errorf(`unexpected referenced foreign-key "breakage_sub_account_id" returned %v for node %v`, fk, n.ID) + } + assign(node, n) + } + return nil +} func (_q *LedgerSubAccountQuery) sqlCount(ctx context.Context) (int, error) { _spec := _q.querySpec() diff --git a/openmeter/ent/db/ledgersubaccount_update.go b/openmeter/ent/db/ledgersubaccount_update.go index 2c761873ed..ca9a82240a 100644 --- a/openmeter/ent/db/ledgersubaccount_update.go +++ b/openmeter/ent/db/ledgersubaccount_update.go @@ -11,6 +11,7 @@ import ( "entgo.io/ent/dialect/sql" "entgo.io/ent/dialect/sql/sqlgraph" "entgo.io/ent/schema/field" + "github.com/openmeterio/openmeter/openmeter/ent/db/ledgerbreakagerecord" "github.com/openmeterio/openmeter/openmeter/ent/db/ledgerentry" "github.com/openmeterio/openmeter/openmeter/ent/db/ledgersubaccount" "github.com/openmeterio/openmeter/openmeter/ent/db/predicate" @@ -83,6 +84,36 @@ func (_u *LedgerSubAccountUpdate) AddEntries(v ...*LedgerEntry) *LedgerSubAccoun return _u.AddEntryIDs(ids...) } +// AddFboBreakageRecordIDs adds the "fbo_breakage_records" edge to the LedgerBreakageRecord entity by IDs. +func (_u *LedgerSubAccountUpdate) AddFboBreakageRecordIDs(ids ...string) *LedgerSubAccountUpdate { + _u.mutation.AddFboBreakageRecordIDs(ids...) + return _u +} + +// AddFboBreakageRecords adds the "fbo_breakage_records" edges to the LedgerBreakageRecord entity. +func (_u *LedgerSubAccountUpdate) AddFboBreakageRecords(v ...*LedgerBreakageRecord) *LedgerSubAccountUpdate { + ids := make([]string, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _u.AddFboBreakageRecordIDs(ids...) +} + +// AddBreakageRecordIDs adds the "breakage_records" edge to the LedgerBreakageRecord entity by IDs. +func (_u *LedgerSubAccountUpdate) AddBreakageRecordIDs(ids ...string) *LedgerSubAccountUpdate { + _u.mutation.AddBreakageRecordIDs(ids...) + return _u +} + +// AddBreakageRecords adds the "breakage_records" edges to the LedgerBreakageRecord entity. +func (_u *LedgerSubAccountUpdate) AddBreakageRecords(v ...*LedgerBreakageRecord) *LedgerSubAccountUpdate { + ids := make([]string, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _u.AddBreakageRecordIDs(ids...) +} + // Mutation returns the LedgerSubAccountMutation object of the builder. func (_u *LedgerSubAccountUpdate) Mutation() *LedgerSubAccountMutation { return _u.mutation @@ -109,6 +140,48 @@ func (_u *LedgerSubAccountUpdate) RemoveEntries(v ...*LedgerEntry) *LedgerSubAcc return _u.RemoveEntryIDs(ids...) } +// ClearFboBreakageRecords clears all "fbo_breakage_records" edges to the LedgerBreakageRecord entity. +func (_u *LedgerSubAccountUpdate) ClearFboBreakageRecords() *LedgerSubAccountUpdate { + _u.mutation.ClearFboBreakageRecords() + return _u +} + +// RemoveFboBreakageRecordIDs removes the "fbo_breakage_records" edge to LedgerBreakageRecord entities by IDs. +func (_u *LedgerSubAccountUpdate) RemoveFboBreakageRecordIDs(ids ...string) *LedgerSubAccountUpdate { + _u.mutation.RemoveFboBreakageRecordIDs(ids...) + return _u +} + +// RemoveFboBreakageRecords removes "fbo_breakage_records" edges to LedgerBreakageRecord entities. +func (_u *LedgerSubAccountUpdate) RemoveFboBreakageRecords(v ...*LedgerBreakageRecord) *LedgerSubAccountUpdate { + ids := make([]string, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _u.RemoveFboBreakageRecordIDs(ids...) +} + +// ClearBreakageRecords clears all "breakage_records" edges to the LedgerBreakageRecord entity. +func (_u *LedgerSubAccountUpdate) ClearBreakageRecords() *LedgerSubAccountUpdate { + _u.mutation.ClearBreakageRecords() + return _u +} + +// RemoveBreakageRecordIDs removes the "breakage_records" edge to LedgerBreakageRecord entities by IDs. +func (_u *LedgerSubAccountUpdate) RemoveBreakageRecordIDs(ids ...string) *LedgerSubAccountUpdate { + _u.mutation.RemoveBreakageRecordIDs(ids...) + return _u +} + +// RemoveBreakageRecords removes "breakage_records" edges to LedgerBreakageRecord entities. +func (_u *LedgerSubAccountUpdate) RemoveBreakageRecords(v ...*LedgerBreakageRecord) *LedgerSubAccountUpdate { + ids := make([]string, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _u.RemoveBreakageRecordIDs(ids...) +} + // Save executes the query and returns the number of nodes affected by the update operation. func (_u *LedgerSubAccountUpdate) Save(ctx context.Context) (int, error) { _u.defaults() @@ -228,6 +301,96 @@ func (_u *LedgerSubAccountUpdate) sqlSave(ctx context.Context) (_node int, err e } _spec.Edges.Add = append(_spec.Edges.Add, edge) } + if _u.mutation.FboBreakageRecordsCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgersubaccount.FboBreakageRecordsTable, + Columns: []string{ledgersubaccount.FboBreakageRecordsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := _u.mutation.RemovedFboBreakageRecordsIDs(); len(nodes) > 0 && !_u.mutation.FboBreakageRecordsCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgersubaccount.FboBreakageRecordsTable, + Columns: []string{ledgersubaccount.FboBreakageRecordsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := _u.mutation.FboBreakageRecordsIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgersubaccount.FboBreakageRecordsTable, + Columns: []string{ledgersubaccount.FboBreakageRecordsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Add = append(_spec.Edges.Add, edge) + } + if _u.mutation.BreakageRecordsCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgersubaccount.BreakageRecordsTable, + Columns: []string{ledgersubaccount.BreakageRecordsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := _u.mutation.RemovedBreakageRecordsIDs(); len(nodes) > 0 && !_u.mutation.BreakageRecordsCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgersubaccount.BreakageRecordsTable, + Columns: []string{ledgersubaccount.BreakageRecordsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := _u.mutation.BreakageRecordsIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgersubaccount.BreakageRecordsTable, + Columns: []string{ledgersubaccount.BreakageRecordsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Add = append(_spec.Edges.Add, edge) + } if _node, err = sqlgraph.UpdateNodes(ctx, _u.driver, _spec); err != nil { if _, ok := err.(*sqlgraph.NotFoundError); ok { err = &NotFoundError{ledgersubaccount.Label} @@ -301,6 +464,36 @@ func (_u *LedgerSubAccountUpdateOne) AddEntries(v ...*LedgerEntry) *LedgerSubAcc return _u.AddEntryIDs(ids...) } +// AddFboBreakageRecordIDs adds the "fbo_breakage_records" edge to the LedgerBreakageRecord entity by IDs. +func (_u *LedgerSubAccountUpdateOne) AddFboBreakageRecordIDs(ids ...string) *LedgerSubAccountUpdateOne { + _u.mutation.AddFboBreakageRecordIDs(ids...) + return _u +} + +// AddFboBreakageRecords adds the "fbo_breakage_records" edges to the LedgerBreakageRecord entity. +func (_u *LedgerSubAccountUpdateOne) AddFboBreakageRecords(v ...*LedgerBreakageRecord) *LedgerSubAccountUpdateOne { + ids := make([]string, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _u.AddFboBreakageRecordIDs(ids...) +} + +// AddBreakageRecordIDs adds the "breakage_records" edge to the LedgerBreakageRecord entity by IDs. +func (_u *LedgerSubAccountUpdateOne) AddBreakageRecordIDs(ids ...string) *LedgerSubAccountUpdateOne { + _u.mutation.AddBreakageRecordIDs(ids...) + return _u +} + +// AddBreakageRecords adds the "breakage_records" edges to the LedgerBreakageRecord entity. +func (_u *LedgerSubAccountUpdateOne) AddBreakageRecords(v ...*LedgerBreakageRecord) *LedgerSubAccountUpdateOne { + ids := make([]string, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _u.AddBreakageRecordIDs(ids...) +} + // Mutation returns the LedgerSubAccountMutation object of the builder. func (_u *LedgerSubAccountUpdateOne) Mutation() *LedgerSubAccountMutation { return _u.mutation @@ -327,6 +520,48 @@ func (_u *LedgerSubAccountUpdateOne) RemoveEntries(v ...*LedgerEntry) *LedgerSub return _u.RemoveEntryIDs(ids...) } +// ClearFboBreakageRecords clears all "fbo_breakage_records" edges to the LedgerBreakageRecord entity. +func (_u *LedgerSubAccountUpdateOne) ClearFboBreakageRecords() *LedgerSubAccountUpdateOne { + _u.mutation.ClearFboBreakageRecords() + return _u +} + +// RemoveFboBreakageRecordIDs removes the "fbo_breakage_records" edge to LedgerBreakageRecord entities by IDs. +func (_u *LedgerSubAccountUpdateOne) RemoveFboBreakageRecordIDs(ids ...string) *LedgerSubAccountUpdateOne { + _u.mutation.RemoveFboBreakageRecordIDs(ids...) + return _u +} + +// RemoveFboBreakageRecords removes "fbo_breakage_records" edges to LedgerBreakageRecord entities. +func (_u *LedgerSubAccountUpdateOne) RemoveFboBreakageRecords(v ...*LedgerBreakageRecord) *LedgerSubAccountUpdateOne { + ids := make([]string, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _u.RemoveFboBreakageRecordIDs(ids...) +} + +// ClearBreakageRecords clears all "breakage_records" edges to the LedgerBreakageRecord entity. +func (_u *LedgerSubAccountUpdateOne) ClearBreakageRecords() *LedgerSubAccountUpdateOne { + _u.mutation.ClearBreakageRecords() + return _u +} + +// RemoveBreakageRecordIDs removes the "breakage_records" edge to LedgerBreakageRecord entities by IDs. +func (_u *LedgerSubAccountUpdateOne) RemoveBreakageRecordIDs(ids ...string) *LedgerSubAccountUpdateOne { + _u.mutation.RemoveBreakageRecordIDs(ids...) + return _u +} + +// RemoveBreakageRecords removes "breakage_records" edges to LedgerBreakageRecord entities. +func (_u *LedgerSubAccountUpdateOne) RemoveBreakageRecords(v ...*LedgerBreakageRecord) *LedgerSubAccountUpdateOne { + ids := make([]string, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _u.RemoveBreakageRecordIDs(ids...) +} + // Where appends a list predicates to the LedgerSubAccountUpdate builder. func (_u *LedgerSubAccountUpdateOne) Where(ps ...predicate.LedgerSubAccount) *LedgerSubAccountUpdateOne { _u.mutation.Where(ps...) @@ -476,6 +711,96 @@ func (_u *LedgerSubAccountUpdateOne) sqlSave(ctx context.Context) (_node *Ledger } _spec.Edges.Add = append(_spec.Edges.Add, edge) } + if _u.mutation.FboBreakageRecordsCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgersubaccount.FboBreakageRecordsTable, + Columns: []string{ledgersubaccount.FboBreakageRecordsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := _u.mutation.RemovedFboBreakageRecordsIDs(); len(nodes) > 0 && !_u.mutation.FboBreakageRecordsCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgersubaccount.FboBreakageRecordsTable, + Columns: []string{ledgersubaccount.FboBreakageRecordsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := _u.mutation.FboBreakageRecordsIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgersubaccount.FboBreakageRecordsTable, + Columns: []string{ledgersubaccount.FboBreakageRecordsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Add = append(_spec.Edges.Add, edge) + } + if _u.mutation.BreakageRecordsCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgersubaccount.BreakageRecordsTable, + Columns: []string{ledgersubaccount.BreakageRecordsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := _u.mutation.RemovedBreakageRecordsIDs(); len(nodes) > 0 && !_u.mutation.BreakageRecordsCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgersubaccount.BreakageRecordsTable, + Columns: []string{ledgersubaccount.BreakageRecordsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := _u.mutation.BreakageRecordsIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgersubaccount.BreakageRecordsTable, + Columns: []string{ledgersubaccount.BreakageRecordsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Add = append(_spec.Edges.Add, edge) + } _node = &LedgerSubAccount{config: _u.config} _spec.Assign = _node.assignValues _spec.ScanValues = _node.scanValues diff --git a/openmeter/ent/db/ledgertransaction.go b/openmeter/ent/db/ledgertransaction.go index 5dc7ead442..11b21a046a 100644 --- a/openmeter/ent/db/ledgertransaction.go +++ b/openmeter/ent/db/ledgertransaction.go @@ -46,9 +46,13 @@ type LedgerTransactionEdges struct { Group *LedgerTransactionGroup `json:"group,omitempty"` // Entries holds the value of the entries edge. Entries []*LedgerEntry `json:"entries,omitempty"` + // SourceBreakageRecords holds the value of the source_breakage_records edge. + SourceBreakageRecords []*LedgerBreakageRecord `json:"source_breakage_records,omitempty"` + // BreakageRecords holds the value of the breakage_records edge. + BreakageRecords []*LedgerBreakageRecord `json:"breakage_records,omitempty"` // loadedTypes holds the information for reporting if a // type was loaded (or requested) in eager-loading or not. - loadedTypes [2]bool + loadedTypes [4]bool } // GroupOrErr returns the Group value or an error if the edge @@ -71,6 +75,24 @@ func (e LedgerTransactionEdges) EntriesOrErr() ([]*LedgerEntry, error) { return nil, &NotLoadedError{edge: "entries"} } +// SourceBreakageRecordsOrErr returns the SourceBreakageRecords value or an error if the edge +// was not loaded in eager-loading. +func (e LedgerTransactionEdges) SourceBreakageRecordsOrErr() ([]*LedgerBreakageRecord, error) { + if e.loadedTypes[2] { + return e.SourceBreakageRecords, nil + } + return nil, &NotLoadedError{edge: "source_breakage_records"} +} + +// BreakageRecordsOrErr returns the BreakageRecords value or an error if the edge +// was not loaded in eager-loading. +func (e LedgerTransactionEdges) BreakageRecordsOrErr() ([]*LedgerBreakageRecord, error) { + if e.loadedTypes[3] { + return e.BreakageRecords, nil + } + return nil, &NotLoadedError{edge: "breakage_records"} +} + // scanValues returns the types for scanning values from sql.Rows. func (*LedgerTransaction) scanValues(columns []string) ([]any, error) { values := make([]any, len(columns)) @@ -171,6 +193,16 @@ func (_m *LedgerTransaction) QueryEntries() *LedgerEntryQuery { return NewLedgerTransactionClient(_m.config).QueryEntries(_m) } +// QuerySourceBreakageRecords queries the "source_breakage_records" edge of the LedgerTransaction entity. +func (_m *LedgerTransaction) QuerySourceBreakageRecords() *LedgerBreakageRecordQuery { + return NewLedgerTransactionClient(_m.config).QuerySourceBreakageRecords(_m) +} + +// QueryBreakageRecords queries the "breakage_records" edge of the LedgerTransaction entity. +func (_m *LedgerTransaction) QueryBreakageRecords() *LedgerBreakageRecordQuery { + return NewLedgerTransactionClient(_m.config).QueryBreakageRecords(_m) +} + // Update returns a builder for updating this LedgerTransaction. // Note that you need to call LedgerTransaction.Unwrap() before calling this method if this LedgerTransaction // was returned from a transaction, and the transaction was committed or rolled back. diff --git a/openmeter/ent/db/ledgertransaction/ledgertransaction.go b/openmeter/ent/db/ledgertransaction/ledgertransaction.go index 1ac94d0b8b..ea4840e0d4 100644 --- a/openmeter/ent/db/ledgertransaction/ledgertransaction.go +++ b/openmeter/ent/db/ledgertransaction/ledgertransaction.go @@ -32,6 +32,10 @@ const ( EdgeGroup = "group" // EdgeEntries holds the string denoting the entries edge name in mutations. EdgeEntries = "entries" + // EdgeSourceBreakageRecords holds the string denoting the source_breakage_records edge name in mutations. + EdgeSourceBreakageRecords = "source_breakage_records" + // EdgeBreakageRecords holds the string denoting the breakage_records edge name in mutations. + EdgeBreakageRecords = "breakage_records" // Table holds the table name of the ledgertransaction in the database. Table = "ledger_transactions" // GroupTable is the table that holds the group relation/edge. @@ -48,6 +52,20 @@ const ( EntriesInverseTable = "ledger_entries" // EntriesColumn is the table column denoting the entries relation/edge. EntriesColumn = "transaction_id" + // SourceBreakageRecordsTable is the table that holds the source_breakage_records relation/edge. + SourceBreakageRecordsTable = "ledger_breakage_records" + // SourceBreakageRecordsInverseTable is the table name for the LedgerBreakageRecord entity. + // It exists in this package in order to avoid circular dependency with the "ledgerbreakagerecord" package. + SourceBreakageRecordsInverseTable = "ledger_breakage_records" + // SourceBreakageRecordsColumn is the table column denoting the source_breakage_records relation/edge. + SourceBreakageRecordsColumn = "source_transaction_id" + // BreakageRecordsTable is the table that holds the breakage_records relation/edge. + BreakageRecordsTable = "ledger_breakage_records" + // BreakageRecordsInverseTable is the table name for the LedgerBreakageRecord entity. + // It exists in this package in order to avoid circular dependency with the "ledgerbreakagerecord" package. + BreakageRecordsInverseTable = "ledger_breakage_records" + // BreakageRecordsColumn is the table column denoting the breakage_records relation/edge. + BreakageRecordsColumn = "breakage_transaction_id" ) // Columns holds all SQL columns for ledgertransaction fields. @@ -143,6 +161,34 @@ func ByEntries(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption { sqlgraph.OrderByNeighborTerms(s, newEntriesStep(), append([]sql.OrderTerm{term}, terms...)...) } } + +// BySourceBreakageRecordsCount orders the results by source_breakage_records count. +func BySourceBreakageRecordsCount(opts ...sql.OrderTermOption) OrderOption { + return func(s *sql.Selector) { + sqlgraph.OrderByNeighborsCount(s, newSourceBreakageRecordsStep(), opts...) + } +} + +// BySourceBreakageRecords orders the results by source_breakage_records terms. +func BySourceBreakageRecords(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption { + return func(s *sql.Selector) { + sqlgraph.OrderByNeighborTerms(s, newSourceBreakageRecordsStep(), append([]sql.OrderTerm{term}, terms...)...) + } +} + +// ByBreakageRecordsCount orders the results by breakage_records count. +func ByBreakageRecordsCount(opts ...sql.OrderTermOption) OrderOption { + return func(s *sql.Selector) { + sqlgraph.OrderByNeighborsCount(s, newBreakageRecordsStep(), opts...) + } +} + +// ByBreakageRecords orders the results by breakage_records terms. +func ByBreakageRecords(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption { + return func(s *sql.Selector) { + sqlgraph.OrderByNeighborTerms(s, newBreakageRecordsStep(), append([]sql.OrderTerm{term}, terms...)...) + } +} func newGroupStep() *sqlgraph.Step { return sqlgraph.NewStep( sqlgraph.From(Table, FieldID), @@ -157,3 +203,17 @@ func newEntriesStep() *sqlgraph.Step { sqlgraph.Edge(sqlgraph.O2M, false, EntriesTable, EntriesColumn), ) } +func newSourceBreakageRecordsStep() *sqlgraph.Step { + return sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.To(SourceBreakageRecordsInverseTable, FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, SourceBreakageRecordsTable, SourceBreakageRecordsColumn), + ) +} +func newBreakageRecordsStep() *sqlgraph.Step { + return sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.To(BreakageRecordsInverseTable, FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, BreakageRecordsTable, BreakageRecordsColumn), + ) +} diff --git a/openmeter/ent/db/ledgertransaction/where.go b/openmeter/ent/db/ledgertransaction/where.go index 9bd4234c9b..c13c6e4b95 100644 --- a/openmeter/ent/db/ledgertransaction/where.go +++ b/openmeter/ent/db/ledgertransaction/where.go @@ -451,6 +451,52 @@ func HasEntriesWith(preds ...predicate.LedgerEntry) predicate.LedgerTransaction }) } +// HasSourceBreakageRecords applies the HasEdge predicate on the "source_breakage_records" edge. +func HasSourceBreakageRecords() predicate.LedgerTransaction { + return predicate.LedgerTransaction(func(s *sql.Selector) { + step := sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, SourceBreakageRecordsTable, SourceBreakageRecordsColumn), + ) + sqlgraph.HasNeighbors(s, step) + }) +} + +// HasSourceBreakageRecordsWith applies the HasEdge predicate on the "source_breakage_records" edge with a given conditions (other predicates). +func HasSourceBreakageRecordsWith(preds ...predicate.LedgerBreakageRecord) predicate.LedgerTransaction { + return predicate.LedgerTransaction(func(s *sql.Selector) { + step := newSourceBreakageRecordsStep() + sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) { + for _, p := range preds { + p(s) + } + }) + }) +} + +// HasBreakageRecords applies the HasEdge predicate on the "breakage_records" edge. +func HasBreakageRecords() predicate.LedgerTransaction { + return predicate.LedgerTransaction(func(s *sql.Selector) { + step := sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, BreakageRecordsTable, BreakageRecordsColumn), + ) + sqlgraph.HasNeighbors(s, step) + }) +} + +// HasBreakageRecordsWith applies the HasEdge predicate on the "breakage_records" edge with a given conditions (other predicates). +func HasBreakageRecordsWith(preds ...predicate.LedgerBreakageRecord) predicate.LedgerTransaction { + return predicate.LedgerTransaction(func(s *sql.Selector) { + step := newBreakageRecordsStep() + sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) { + for _, p := range preds { + p(s) + } + }) + }) +} + // And groups predicates with the AND operator between them. func And(predicates ...predicate.LedgerTransaction) predicate.LedgerTransaction { return predicate.LedgerTransaction(sql.AndPredicates(predicates...)) diff --git a/openmeter/ent/db/ledgertransaction_create.go b/openmeter/ent/db/ledgertransaction_create.go index 651554d555..590c575aeb 100644 --- a/openmeter/ent/db/ledgertransaction_create.go +++ b/openmeter/ent/db/ledgertransaction_create.go @@ -12,6 +12,7 @@ import ( "entgo.io/ent/dialect/sql" "entgo.io/ent/dialect/sql/sqlgraph" "entgo.io/ent/schema/field" + "github.com/openmeterio/openmeter/openmeter/ent/db/ledgerbreakagerecord" "github.com/openmeterio/openmeter/openmeter/ent/db/ledgerentry" "github.com/openmeterio/openmeter/openmeter/ent/db/ledgertransaction" "github.com/openmeterio/openmeter/openmeter/ent/db/ledgertransactiongroup" @@ -126,6 +127,36 @@ func (_c *LedgerTransactionCreate) AddEntries(v ...*LedgerEntry) *LedgerTransact return _c.AddEntryIDs(ids...) } +// AddSourceBreakageRecordIDs adds the "source_breakage_records" edge to the LedgerBreakageRecord entity by IDs. +func (_c *LedgerTransactionCreate) AddSourceBreakageRecordIDs(ids ...string) *LedgerTransactionCreate { + _c.mutation.AddSourceBreakageRecordIDs(ids...) + return _c +} + +// AddSourceBreakageRecords adds the "source_breakage_records" edges to the LedgerBreakageRecord entity. +func (_c *LedgerTransactionCreate) AddSourceBreakageRecords(v ...*LedgerBreakageRecord) *LedgerTransactionCreate { + ids := make([]string, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _c.AddSourceBreakageRecordIDs(ids...) +} + +// AddBreakageRecordIDs adds the "breakage_records" edge to the LedgerBreakageRecord entity by IDs. +func (_c *LedgerTransactionCreate) AddBreakageRecordIDs(ids ...string) *LedgerTransactionCreate { + _c.mutation.AddBreakageRecordIDs(ids...) + return _c +} + +// AddBreakageRecords adds the "breakage_records" edges to the LedgerBreakageRecord entity. +func (_c *LedgerTransactionCreate) AddBreakageRecords(v ...*LedgerBreakageRecord) *LedgerTransactionCreate { + ids := make([]string, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _c.AddBreakageRecordIDs(ids...) +} + // Mutation returns the LedgerTransactionMutation object of the builder. func (_c *LedgerTransactionCreate) Mutation() *LedgerTransactionMutation { return _c.mutation @@ -293,6 +324,38 @@ func (_c *LedgerTransactionCreate) createSpec() (*LedgerTransaction, *sqlgraph.C } _spec.Edges = append(_spec.Edges, edge) } + if nodes := _c.mutation.SourceBreakageRecordsIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgertransaction.SourceBreakageRecordsTable, + Columns: []string{ledgertransaction.SourceBreakageRecordsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges = append(_spec.Edges, edge) + } + if nodes := _c.mutation.BreakageRecordsIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgertransaction.BreakageRecordsTable, + Columns: []string{ledgertransaction.BreakageRecordsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges = append(_spec.Edges, edge) + } return _node, _spec } diff --git a/openmeter/ent/db/ledgertransaction_query.go b/openmeter/ent/db/ledgertransaction_query.go index 14e883a919..ff0c5c3ccd 100644 --- a/openmeter/ent/db/ledgertransaction_query.go +++ b/openmeter/ent/db/ledgertransaction_query.go @@ -13,6 +13,7 @@ import ( "entgo.io/ent/dialect/sql" "entgo.io/ent/dialect/sql/sqlgraph" "entgo.io/ent/schema/field" + "github.com/openmeterio/openmeter/openmeter/ent/db/ledgerbreakagerecord" "github.com/openmeterio/openmeter/openmeter/ent/db/ledgerentry" "github.com/openmeterio/openmeter/openmeter/ent/db/ledgertransaction" "github.com/openmeterio/openmeter/openmeter/ent/db/ledgertransactiongroup" @@ -22,13 +23,15 @@ import ( // LedgerTransactionQuery is the builder for querying LedgerTransaction entities. type LedgerTransactionQuery struct { config - ctx *QueryContext - order []ledgertransaction.OrderOption - inters []Interceptor - predicates []predicate.LedgerTransaction - withGroup *LedgerTransactionGroupQuery - withEntries *LedgerEntryQuery - modifiers []func(*sql.Selector) + ctx *QueryContext + order []ledgertransaction.OrderOption + inters []Interceptor + predicates []predicate.LedgerTransaction + withGroup *LedgerTransactionGroupQuery + withEntries *LedgerEntryQuery + withSourceBreakageRecords *LedgerBreakageRecordQuery + withBreakageRecords *LedgerBreakageRecordQuery + modifiers []func(*sql.Selector) // intermediate query (i.e. traversal path). sql *sql.Selector path func(context.Context) (*sql.Selector, error) @@ -109,6 +112,50 @@ func (_q *LedgerTransactionQuery) QueryEntries() *LedgerEntryQuery { return query } +// QuerySourceBreakageRecords chains the current query on the "source_breakage_records" edge. +func (_q *LedgerTransactionQuery) QuerySourceBreakageRecords() *LedgerBreakageRecordQuery { + query := (&LedgerBreakageRecordClient{config: _q.config}).Query() + query.path = func(ctx context.Context) (fromU *sql.Selector, err error) { + if err := _q.prepareQuery(ctx); err != nil { + return nil, err + } + selector := _q.sqlQuery(ctx) + if err := selector.Err(); err != nil { + return nil, err + } + step := sqlgraph.NewStep( + sqlgraph.From(ledgertransaction.Table, ledgertransaction.FieldID, selector), + sqlgraph.To(ledgerbreakagerecord.Table, ledgerbreakagerecord.FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, ledgertransaction.SourceBreakageRecordsTable, ledgertransaction.SourceBreakageRecordsColumn), + ) + fromU = sqlgraph.SetNeighbors(_q.driver.Dialect(), step) + return fromU, nil + } + return query +} + +// QueryBreakageRecords chains the current query on the "breakage_records" edge. +func (_q *LedgerTransactionQuery) QueryBreakageRecords() *LedgerBreakageRecordQuery { + query := (&LedgerBreakageRecordClient{config: _q.config}).Query() + query.path = func(ctx context.Context) (fromU *sql.Selector, err error) { + if err := _q.prepareQuery(ctx); err != nil { + return nil, err + } + selector := _q.sqlQuery(ctx) + if err := selector.Err(); err != nil { + return nil, err + } + step := sqlgraph.NewStep( + sqlgraph.From(ledgertransaction.Table, ledgertransaction.FieldID, selector), + sqlgraph.To(ledgerbreakagerecord.Table, ledgerbreakagerecord.FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, ledgertransaction.BreakageRecordsTable, ledgertransaction.BreakageRecordsColumn), + ) + fromU = sqlgraph.SetNeighbors(_q.driver.Dialect(), step) + return fromU, nil + } + return query +} + // First returns the first LedgerTransaction entity from the query. // Returns a *NotFoundError when no LedgerTransaction was found. func (_q *LedgerTransactionQuery) First(ctx context.Context) (*LedgerTransaction, error) { @@ -296,13 +343,15 @@ func (_q *LedgerTransactionQuery) Clone() *LedgerTransactionQuery { return nil } return &LedgerTransactionQuery{ - config: _q.config, - ctx: _q.ctx.Clone(), - order: append([]ledgertransaction.OrderOption{}, _q.order...), - inters: append([]Interceptor{}, _q.inters...), - predicates: append([]predicate.LedgerTransaction{}, _q.predicates...), - withGroup: _q.withGroup.Clone(), - withEntries: _q.withEntries.Clone(), + config: _q.config, + ctx: _q.ctx.Clone(), + order: append([]ledgertransaction.OrderOption{}, _q.order...), + inters: append([]Interceptor{}, _q.inters...), + predicates: append([]predicate.LedgerTransaction{}, _q.predicates...), + withGroup: _q.withGroup.Clone(), + withEntries: _q.withEntries.Clone(), + withSourceBreakageRecords: _q.withSourceBreakageRecords.Clone(), + withBreakageRecords: _q.withBreakageRecords.Clone(), // clone intermediate query. sql: _q.sql.Clone(), path: _q.path, @@ -331,6 +380,28 @@ func (_q *LedgerTransactionQuery) WithEntries(opts ...func(*LedgerEntryQuery)) * return _q } +// WithSourceBreakageRecords tells the query-builder to eager-load the nodes that are connected to +// the "source_breakage_records" edge. The optional arguments are used to configure the query builder of the edge. +func (_q *LedgerTransactionQuery) WithSourceBreakageRecords(opts ...func(*LedgerBreakageRecordQuery)) *LedgerTransactionQuery { + query := (&LedgerBreakageRecordClient{config: _q.config}).Query() + for _, opt := range opts { + opt(query) + } + _q.withSourceBreakageRecords = query + return _q +} + +// WithBreakageRecords tells the query-builder to eager-load the nodes that are connected to +// the "breakage_records" edge. The optional arguments are used to configure the query builder of the edge. +func (_q *LedgerTransactionQuery) WithBreakageRecords(opts ...func(*LedgerBreakageRecordQuery)) *LedgerTransactionQuery { + query := (&LedgerBreakageRecordClient{config: _q.config}).Query() + for _, opt := range opts { + opt(query) + } + _q.withBreakageRecords = query + return _q +} + // 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. // @@ -409,9 +480,11 @@ func (_q *LedgerTransactionQuery) sqlAll(ctx context.Context, hooks ...queryHook var ( nodes = []*LedgerTransaction{} _spec = _q.querySpec() - loadedTypes = [2]bool{ + loadedTypes = [4]bool{ _q.withGroup != nil, _q.withEntries != nil, + _q.withSourceBreakageRecords != nil, + _q.withBreakageRecords != nil, } ) _spec.ScanValues = func(columns []string) ([]any, error) { @@ -448,6 +521,24 @@ func (_q *LedgerTransactionQuery) sqlAll(ctx context.Context, hooks ...queryHook return nil, err } } + if query := _q.withSourceBreakageRecords; query != nil { + if err := _q.loadSourceBreakageRecords(ctx, query, nodes, + func(n *LedgerTransaction) { n.Edges.SourceBreakageRecords = []*LedgerBreakageRecord{} }, + func(n *LedgerTransaction, e *LedgerBreakageRecord) { + n.Edges.SourceBreakageRecords = append(n.Edges.SourceBreakageRecords, e) + }); err != nil { + return nil, err + } + } + if query := _q.withBreakageRecords; query != nil { + if err := _q.loadBreakageRecords(ctx, query, nodes, + func(n *LedgerTransaction) { n.Edges.BreakageRecords = []*LedgerBreakageRecord{} }, + func(n *LedgerTransaction, e *LedgerBreakageRecord) { + n.Edges.BreakageRecords = append(n.Edges.BreakageRecords, e) + }); err != nil { + return nil, err + } + } return nodes, nil } @@ -510,6 +601,69 @@ func (_q *LedgerTransactionQuery) loadEntries(ctx context.Context, query *Ledger } return nil } +func (_q *LedgerTransactionQuery) loadSourceBreakageRecords(ctx context.Context, query *LedgerBreakageRecordQuery, nodes []*LedgerTransaction, init func(*LedgerTransaction), assign func(*LedgerTransaction, *LedgerBreakageRecord)) error { + fks := make([]driver.Value, 0, len(nodes)) + nodeids := make(map[string]*LedgerTransaction) + for i := range nodes { + fks = append(fks, nodes[i].ID) + nodeids[nodes[i].ID] = nodes[i] + if init != nil { + init(nodes[i]) + } + } + if len(query.ctx.Fields) > 0 { + query.ctx.AppendFieldOnce(ledgerbreakagerecord.FieldSourceTransactionID) + } + query.Where(predicate.LedgerBreakageRecord(func(s *sql.Selector) { + s.Where(sql.InValues(s.C(ledgertransaction.SourceBreakageRecordsColumn), fks...)) + })) + neighbors, err := query.All(ctx) + if err != nil { + return err + } + for _, n := range neighbors { + fk := n.SourceTransactionID + if fk == nil { + return fmt.Errorf(`foreign-key "source_transaction_id" is nil for node %v`, n.ID) + } + node, ok := nodeids[*fk] + if !ok { + return fmt.Errorf(`unexpected referenced foreign-key "source_transaction_id" returned %v for node %v`, *fk, n.ID) + } + assign(node, n) + } + return nil +} +func (_q *LedgerTransactionQuery) loadBreakageRecords(ctx context.Context, query *LedgerBreakageRecordQuery, nodes []*LedgerTransaction, init func(*LedgerTransaction), assign func(*LedgerTransaction, *LedgerBreakageRecord)) error { + fks := make([]driver.Value, 0, len(nodes)) + nodeids := make(map[string]*LedgerTransaction) + for i := range nodes { + fks = append(fks, nodes[i].ID) + nodeids[nodes[i].ID] = nodes[i] + if init != nil { + init(nodes[i]) + } + } + if len(query.ctx.Fields) > 0 { + query.ctx.AppendFieldOnce(ledgerbreakagerecord.FieldBreakageTransactionID) + } + query.Where(predicate.LedgerBreakageRecord(func(s *sql.Selector) { + s.Where(sql.InValues(s.C(ledgertransaction.BreakageRecordsColumn), fks...)) + })) + neighbors, err := query.All(ctx) + if err != nil { + return err + } + for _, n := range neighbors { + fk := n.BreakageTransactionID + node, ok := nodeids[fk] + if !ok { + return fmt.Errorf(`unexpected referenced foreign-key "breakage_transaction_id" returned %v for node %v`, fk, n.ID) + } + assign(node, n) + } + return nil +} func (_q *LedgerTransactionQuery) sqlCount(ctx context.Context) (int, error) { _spec := _q.querySpec() diff --git a/openmeter/ent/db/ledgertransaction_update.go b/openmeter/ent/db/ledgertransaction_update.go index 5dd453071e..0654cd9e0b 100644 --- a/openmeter/ent/db/ledgertransaction_update.go +++ b/openmeter/ent/db/ledgertransaction_update.go @@ -11,6 +11,7 @@ import ( "entgo.io/ent/dialect/sql" "entgo.io/ent/dialect/sql/sqlgraph" "entgo.io/ent/schema/field" + "github.com/openmeterio/openmeter/openmeter/ent/db/ledgerbreakagerecord" "github.com/openmeterio/openmeter/openmeter/ent/db/ledgerentry" "github.com/openmeterio/openmeter/openmeter/ent/db/ledgertransaction" "github.com/openmeterio/openmeter/openmeter/ent/db/predicate" @@ -83,6 +84,36 @@ func (_u *LedgerTransactionUpdate) AddEntries(v ...*LedgerEntry) *LedgerTransact return _u.AddEntryIDs(ids...) } +// AddSourceBreakageRecordIDs adds the "source_breakage_records" edge to the LedgerBreakageRecord entity by IDs. +func (_u *LedgerTransactionUpdate) AddSourceBreakageRecordIDs(ids ...string) *LedgerTransactionUpdate { + _u.mutation.AddSourceBreakageRecordIDs(ids...) + return _u +} + +// AddSourceBreakageRecords adds the "source_breakage_records" edges to the LedgerBreakageRecord entity. +func (_u *LedgerTransactionUpdate) AddSourceBreakageRecords(v ...*LedgerBreakageRecord) *LedgerTransactionUpdate { + ids := make([]string, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _u.AddSourceBreakageRecordIDs(ids...) +} + +// AddBreakageRecordIDs adds the "breakage_records" edge to the LedgerBreakageRecord entity by IDs. +func (_u *LedgerTransactionUpdate) AddBreakageRecordIDs(ids ...string) *LedgerTransactionUpdate { + _u.mutation.AddBreakageRecordIDs(ids...) + return _u +} + +// AddBreakageRecords adds the "breakage_records" edges to the LedgerBreakageRecord entity. +func (_u *LedgerTransactionUpdate) AddBreakageRecords(v ...*LedgerBreakageRecord) *LedgerTransactionUpdate { + ids := make([]string, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _u.AddBreakageRecordIDs(ids...) +} + // Mutation returns the LedgerTransactionMutation object of the builder. func (_u *LedgerTransactionUpdate) Mutation() *LedgerTransactionMutation { return _u.mutation @@ -109,6 +140,48 @@ func (_u *LedgerTransactionUpdate) RemoveEntries(v ...*LedgerEntry) *LedgerTrans return _u.RemoveEntryIDs(ids...) } +// ClearSourceBreakageRecords clears all "source_breakage_records" edges to the LedgerBreakageRecord entity. +func (_u *LedgerTransactionUpdate) ClearSourceBreakageRecords() *LedgerTransactionUpdate { + _u.mutation.ClearSourceBreakageRecords() + return _u +} + +// RemoveSourceBreakageRecordIDs removes the "source_breakage_records" edge to LedgerBreakageRecord entities by IDs. +func (_u *LedgerTransactionUpdate) RemoveSourceBreakageRecordIDs(ids ...string) *LedgerTransactionUpdate { + _u.mutation.RemoveSourceBreakageRecordIDs(ids...) + return _u +} + +// RemoveSourceBreakageRecords removes "source_breakage_records" edges to LedgerBreakageRecord entities. +func (_u *LedgerTransactionUpdate) RemoveSourceBreakageRecords(v ...*LedgerBreakageRecord) *LedgerTransactionUpdate { + ids := make([]string, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _u.RemoveSourceBreakageRecordIDs(ids...) +} + +// ClearBreakageRecords clears all "breakage_records" edges to the LedgerBreakageRecord entity. +func (_u *LedgerTransactionUpdate) ClearBreakageRecords() *LedgerTransactionUpdate { + _u.mutation.ClearBreakageRecords() + return _u +} + +// RemoveBreakageRecordIDs removes the "breakage_records" edge to LedgerBreakageRecord entities by IDs. +func (_u *LedgerTransactionUpdate) RemoveBreakageRecordIDs(ids ...string) *LedgerTransactionUpdate { + _u.mutation.RemoveBreakageRecordIDs(ids...) + return _u +} + +// RemoveBreakageRecords removes "breakage_records" edges to LedgerBreakageRecord entities. +func (_u *LedgerTransactionUpdate) RemoveBreakageRecords(v ...*LedgerBreakageRecord) *LedgerTransactionUpdate { + ids := make([]string, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _u.RemoveBreakageRecordIDs(ids...) +} + // Save executes the query and returns the number of nodes affected by the update operation. func (_u *LedgerTransactionUpdate) Save(ctx context.Context) (int, error) { _u.defaults() @@ -225,6 +298,96 @@ func (_u *LedgerTransactionUpdate) sqlSave(ctx context.Context) (_node int, err } _spec.Edges.Add = append(_spec.Edges.Add, edge) } + if _u.mutation.SourceBreakageRecordsCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgertransaction.SourceBreakageRecordsTable, + Columns: []string{ledgertransaction.SourceBreakageRecordsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := _u.mutation.RemovedSourceBreakageRecordsIDs(); len(nodes) > 0 && !_u.mutation.SourceBreakageRecordsCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgertransaction.SourceBreakageRecordsTable, + Columns: []string{ledgertransaction.SourceBreakageRecordsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := _u.mutation.SourceBreakageRecordsIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgertransaction.SourceBreakageRecordsTable, + Columns: []string{ledgertransaction.SourceBreakageRecordsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Add = append(_spec.Edges.Add, edge) + } + if _u.mutation.BreakageRecordsCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgertransaction.BreakageRecordsTable, + Columns: []string{ledgertransaction.BreakageRecordsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := _u.mutation.RemovedBreakageRecordsIDs(); len(nodes) > 0 && !_u.mutation.BreakageRecordsCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgertransaction.BreakageRecordsTable, + Columns: []string{ledgertransaction.BreakageRecordsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := _u.mutation.BreakageRecordsIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgertransaction.BreakageRecordsTable, + Columns: []string{ledgertransaction.BreakageRecordsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Add = append(_spec.Edges.Add, edge) + } if _node, err = sqlgraph.UpdateNodes(ctx, _u.driver, _spec); err != nil { if _, ok := err.(*sqlgraph.NotFoundError); ok { err = &NotFoundError{ledgertransaction.Label} @@ -298,6 +461,36 @@ func (_u *LedgerTransactionUpdateOne) AddEntries(v ...*LedgerEntry) *LedgerTrans return _u.AddEntryIDs(ids...) } +// AddSourceBreakageRecordIDs adds the "source_breakage_records" edge to the LedgerBreakageRecord entity by IDs. +func (_u *LedgerTransactionUpdateOne) AddSourceBreakageRecordIDs(ids ...string) *LedgerTransactionUpdateOne { + _u.mutation.AddSourceBreakageRecordIDs(ids...) + return _u +} + +// AddSourceBreakageRecords adds the "source_breakage_records" edges to the LedgerBreakageRecord entity. +func (_u *LedgerTransactionUpdateOne) AddSourceBreakageRecords(v ...*LedgerBreakageRecord) *LedgerTransactionUpdateOne { + ids := make([]string, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _u.AddSourceBreakageRecordIDs(ids...) +} + +// AddBreakageRecordIDs adds the "breakage_records" edge to the LedgerBreakageRecord entity by IDs. +func (_u *LedgerTransactionUpdateOne) AddBreakageRecordIDs(ids ...string) *LedgerTransactionUpdateOne { + _u.mutation.AddBreakageRecordIDs(ids...) + return _u +} + +// AddBreakageRecords adds the "breakage_records" edges to the LedgerBreakageRecord entity. +func (_u *LedgerTransactionUpdateOne) AddBreakageRecords(v ...*LedgerBreakageRecord) *LedgerTransactionUpdateOne { + ids := make([]string, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _u.AddBreakageRecordIDs(ids...) +} + // Mutation returns the LedgerTransactionMutation object of the builder. func (_u *LedgerTransactionUpdateOne) Mutation() *LedgerTransactionMutation { return _u.mutation @@ -324,6 +517,48 @@ func (_u *LedgerTransactionUpdateOne) RemoveEntries(v ...*LedgerEntry) *LedgerTr return _u.RemoveEntryIDs(ids...) } +// ClearSourceBreakageRecords clears all "source_breakage_records" edges to the LedgerBreakageRecord entity. +func (_u *LedgerTransactionUpdateOne) ClearSourceBreakageRecords() *LedgerTransactionUpdateOne { + _u.mutation.ClearSourceBreakageRecords() + return _u +} + +// RemoveSourceBreakageRecordIDs removes the "source_breakage_records" edge to LedgerBreakageRecord entities by IDs. +func (_u *LedgerTransactionUpdateOne) RemoveSourceBreakageRecordIDs(ids ...string) *LedgerTransactionUpdateOne { + _u.mutation.RemoveSourceBreakageRecordIDs(ids...) + return _u +} + +// RemoveSourceBreakageRecords removes "source_breakage_records" edges to LedgerBreakageRecord entities. +func (_u *LedgerTransactionUpdateOne) RemoveSourceBreakageRecords(v ...*LedgerBreakageRecord) *LedgerTransactionUpdateOne { + ids := make([]string, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _u.RemoveSourceBreakageRecordIDs(ids...) +} + +// ClearBreakageRecords clears all "breakage_records" edges to the LedgerBreakageRecord entity. +func (_u *LedgerTransactionUpdateOne) ClearBreakageRecords() *LedgerTransactionUpdateOne { + _u.mutation.ClearBreakageRecords() + return _u +} + +// RemoveBreakageRecordIDs removes the "breakage_records" edge to LedgerBreakageRecord entities by IDs. +func (_u *LedgerTransactionUpdateOne) RemoveBreakageRecordIDs(ids ...string) *LedgerTransactionUpdateOne { + _u.mutation.RemoveBreakageRecordIDs(ids...) + return _u +} + +// RemoveBreakageRecords removes "breakage_records" edges to LedgerBreakageRecord entities. +func (_u *LedgerTransactionUpdateOne) RemoveBreakageRecords(v ...*LedgerBreakageRecord) *LedgerTransactionUpdateOne { + ids := make([]string, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _u.RemoveBreakageRecordIDs(ids...) +} + // Where appends a list predicates to the LedgerTransactionUpdate builder. func (_u *LedgerTransactionUpdateOne) Where(ps ...predicate.LedgerTransaction) *LedgerTransactionUpdateOne { _u.mutation.Where(ps...) @@ -470,6 +705,96 @@ func (_u *LedgerTransactionUpdateOne) sqlSave(ctx context.Context) (_node *Ledge } _spec.Edges.Add = append(_spec.Edges.Add, edge) } + if _u.mutation.SourceBreakageRecordsCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgertransaction.SourceBreakageRecordsTable, + Columns: []string{ledgertransaction.SourceBreakageRecordsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := _u.mutation.RemovedSourceBreakageRecordsIDs(); len(nodes) > 0 && !_u.mutation.SourceBreakageRecordsCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgertransaction.SourceBreakageRecordsTable, + Columns: []string{ledgertransaction.SourceBreakageRecordsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := _u.mutation.SourceBreakageRecordsIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgertransaction.SourceBreakageRecordsTable, + Columns: []string{ledgertransaction.SourceBreakageRecordsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Add = append(_spec.Edges.Add, edge) + } + if _u.mutation.BreakageRecordsCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgertransaction.BreakageRecordsTable, + Columns: []string{ledgertransaction.BreakageRecordsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := _u.mutation.RemovedBreakageRecordsIDs(); len(nodes) > 0 && !_u.mutation.BreakageRecordsCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgertransaction.BreakageRecordsTable, + Columns: []string{ledgertransaction.BreakageRecordsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := _u.mutation.BreakageRecordsIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgertransaction.BreakageRecordsTable, + Columns: []string{ledgertransaction.BreakageRecordsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Add = append(_spec.Edges.Add, edge) + } _node = &LedgerTransaction{config: _u.config} _spec.Assign = _node.assignValues _spec.ScanValues = _node.scanValues diff --git a/openmeter/ent/db/ledgertransactiongroup.go b/openmeter/ent/db/ledgertransactiongroup.go index 78bca45729..3eee4e3dda 100644 --- a/openmeter/ent/db/ledgertransactiongroup.go +++ b/openmeter/ent/db/ledgertransactiongroup.go @@ -39,9 +39,13 @@ type LedgerTransactionGroup struct { type LedgerTransactionGroupEdges struct { // Transactions holds the value of the transactions edge. Transactions []*LedgerTransaction `json:"transactions,omitempty"` + // SourceBreakageRecords holds the value of the source_breakage_records edge. + SourceBreakageRecords []*LedgerBreakageRecord `json:"source_breakage_records,omitempty"` + // BreakageRecords holds the value of the breakage_records edge. + BreakageRecords []*LedgerBreakageRecord `json:"breakage_records,omitempty"` // loadedTypes holds the information for reporting if a // type was loaded (or requested) in eager-loading or not. - loadedTypes [1]bool + loadedTypes [3]bool } // TransactionsOrErr returns the Transactions value or an error if the edge @@ -53,6 +57,24 @@ func (e LedgerTransactionGroupEdges) TransactionsOrErr() ([]*LedgerTransaction, return nil, &NotLoadedError{edge: "transactions"} } +// SourceBreakageRecordsOrErr returns the SourceBreakageRecords value or an error if the edge +// was not loaded in eager-loading. +func (e LedgerTransactionGroupEdges) SourceBreakageRecordsOrErr() ([]*LedgerBreakageRecord, error) { + if e.loadedTypes[1] { + return e.SourceBreakageRecords, nil + } + return nil, &NotLoadedError{edge: "source_breakage_records"} +} + +// BreakageRecordsOrErr returns the BreakageRecords value or an error if the edge +// was not loaded in eager-loading. +func (e LedgerTransactionGroupEdges) BreakageRecordsOrErr() ([]*LedgerBreakageRecord, error) { + if e.loadedTypes[2] { + return e.BreakageRecords, nil + } + return nil, &NotLoadedError{edge: "breakage_records"} +} + // scanValues returns the types for scanning values from sql.Rows. func (*LedgerTransactionGroup) scanValues(columns []string) ([]any, error) { values := make([]any, len(columns)) @@ -136,6 +158,16 @@ func (_m *LedgerTransactionGroup) QueryTransactions() *LedgerTransactionQuery { return NewLedgerTransactionGroupClient(_m.config).QueryTransactions(_m) } +// QuerySourceBreakageRecords queries the "source_breakage_records" edge of the LedgerTransactionGroup entity. +func (_m *LedgerTransactionGroup) QuerySourceBreakageRecords() *LedgerBreakageRecordQuery { + return NewLedgerTransactionGroupClient(_m.config).QuerySourceBreakageRecords(_m) +} + +// QueryBreakageRecords queries the "breakage_records" edge of the LedgerTransactionGroup entity. +func (_m *LedgerTransactionGroup) QueryBreakageRecords() *LedgerBreakageRecordQuery { + return NewLedgerTransactionGroupClient(_m.config).QueryBreakageRecords(_m) +} + // Update returns a builder for updating this LedgerTransactionGroup. // Note that you need to call LedgerTransactionGroup.Unwrap() before calling this method if this LedgerTransactionGroup // was returned from a transaction, and the transaction was committed or rolled back. diff --git a/openmeter/ent/db/ledgertransactiongroup/ledgertransactiongroup.go b/openmeter/ent/db/ledgertransactiongroup/ledgertransactiongroup.go index 4963650a5f..40aaa6fdec 100644 --- a/openmeter/ent/db/ledgertransactiongroup/ledgertransactiongroup.go +++ b/openmeter/ent/db/ledgertransactiongroup/ledgertransactiongroup.go @@ -26,6 +26,10 @@ const ( FieldDeletedAt = "deleted_at" // EdgeTransactions holds the string denoting the transactions edge name in mutations. EdgeTransactions = "transactions" + // EdgeSourceBreakageRecords holds the string denoting the source_breakage_records edge name in mutations. + EdgeSourceBreakageRecords = "source_breakage_records" + // EdgeBreakageRecords holds the string denoting the breakage_records edge name in mutations. + EdgeBreakageRecords = "breakage_records" // Table holds the table name of the ledgertransactiongroup in the database. Table = "ledger_transaction_groups" // TransactionsTable is the table that holds the transactions relation/edge. @@ -35,6 +39,20 @@ const ( TransactionsInverseTable = "ledger_transactions" // TransactionsColumn is the table column denoting the transactions relation/edge. TransactionsColumn = "group_id" + // SourceBreakageRecordsTable is the table that holds the source_breakage_records relation/edge. + SourceBreakageRecordsTable = "ledger_breakage_records" + // SourceBreakageRecordsInverseTable is the table name for the LedgerBreakageRecord entity. + // It exists in this package in order to avoid circular dependency with the "ledgerbreakagerecord" package. + SourceBreakageRecordsInverseTable = "ledger_breakage_records" + // SourceBreakageRecordsColumn is the table column denoting the source_breakage_records relation/edge. + SourceBreakageRecordsColumn = "source_transaction_group_id" + // BreakageRecordsTable is the table that holds the breakage_records relation/edge. + BreakageRecordsTable = "ledger_breakage_records" + // BreakageRecordsInverseTable is the table name for the LedgerBreakageRecord entity. + // It exists in this package in order to avoid circular dependency with the "ledgerbreakagerecord" package. + BreakageRecordsInverseTable = "ledger_breakage_records" + // BreakageRecordsColumn is the table column denoting the breakage_records relation/edge. + BreakageRecordsColumn = "breakage_transaction_group_id" ) // Columns holds all SQL columns for ledgertransactiongroup fields. @@ -111,6 +129,34 @@ func ByTransactions(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption { sqlgraph.OrderByNeighborTerms(s, newTransactionsStep(), append([]sql.OrderTerm{term}, terms...)...) } } + +// BySourceBreakageRecordsCount orders the results by source_breakage_records count. +func BySourceBreakageRecordsCount(opts ...sql.OrderTermOption) OrderOption { + return func(s *sql.Selector) { + sqlgraph.OrderByNeighborsCount(s, newSourceBreakageRecordsStep(), opts...) + } +} + +// BySourceBreakageRecords orders the results by source_breakage_records terms. +func BySourceBreakageRecords(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption { + return func(s *sql.Selector) { + sqlgraph.OrderByNeighborTerms(s, newSourceBreakageRecordsStep(), append([]sql.OrderTerm{term}, terms...)...) + } +} + +// ByBreakageRecordsCount orders the results by breakage_records count. +func ByBreakageRecordsCount(opts ...sql.OrderTermOption) OrderOption { + return func(s *sql.Selector) { + sqlgraph.OrderByNeighborsCount(s, newBreakageRecordsStep(), opts...) + } +} + +// ByBreakageRecords orders the results by breakage_records terms. +func ByBreakageRecords(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption { + return func(s *sql.Selector) { + sqlgraph.OrderByNeighborTerms(s, newBreakageRecordsStep(), append([]sql.OrderTerm{term}, terms...)...) + } +} func newTransactionsStep() *sqlgraph.Step { return sqlgraph.NewStep( sqlgraph.From(Table, FieldID), @@ -118,3 +164,17 @@ func newTransactionsStep() *sqlgraph.Step { sqlgraph.Edge(sqlgraph.O2M, false, TransactionsTable, TransactionsColumn), ) } +func newSourceBreakageRecordsStep() *sqlgraph.Step { + return sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.To(SourceBreakageRecordsInverseTable, FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, SourceBreakageRecordsTable, SourceBreakageRecordsColumn), + ) +} +func newBreakageRecordsStep() *sqlgraph.Step { + return sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.To(BreakageRecordsInverseTable, FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, BreakageRecordsTable, BreakageRecordsColumn), + ) +} diff --git a/openmeter/ent/db/ledgertransactiongroup/where.go b/openmeter/ent/db/ledgertransactiongroup/where.go index b4ed481a4e..8d7c60515c 100644 --- a/openmeter/ent/db/ledgertransactiongroup/where.go +++ b/openmeter/ent/db/ledgertransactiongroup/where.go @@ -313,6 +313,52 @@ func HasTransactionsWith(preds ...predicate.LedgerTransaction) predicate.LedgerT }) } +// HasSourceBreakageRecords applies the HasEdge predicate on the "source_breakage_records" edge. +func HasSourceBreakageRecords() predicate.LedgerTransactionGroup { + return predicate.LedgerTransactionGroup(func(s *sql.Selector) { + step := sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, SourceBreakageRecordsTable, SourceBreakageRecordsColumn), + ) + sqlgraph.HasNeighbors(s, step) + }) +} + +// HasSourceBreakageRecordsWith applies the HasEdge predicate on the "source_breakage_records" edge with a given conditions (other predicates). +func HasSourceBreakageRecordsWith(preds ...predicate.LedgerBreakageRecord) predicate.LedgerTransactionGroup { + return predicate.LedgerTransactionGroup(func(s *sql.Selector) { + step := newSourceBreakageRecordsStep() + sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) { + for _, p := range preds { + p(s) + } + }) + }) +} + +// HasBreakageRecords applies the HasEdge predicate on the "breakage_records" edge. +func HasBreakageRecords() predicate.LedgerTransactionGroup { + return predicate.LedgerTransactionGroup(func(s *sql.Selector) { + step := sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, BreakageRecordsTable, BreakageRecordsColumn), + ) + sqlgraph.HasNeighbors(s, step) + }) +} + +// HasBreakageRecordsWith applies the HasEdge predicate on the "breakage_records" edge with a given conditions (other predicates). +func HasBreakageRecordsWith(preds ...predicate.LedgerBreakageRecord) predicate.LedgerTransactionGroup { + return predicate.LedgerTransactionGroup(func(s *sql.Selector) { + step := newBreakageRecordsStep() + sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) { + for _, p := range preds { + p(s) + } + }) + }) +} + // And groups predicates with the AND operator between them. func And(predicates ...predicate.LedgerTransactionGroup) predicate.LedgerTransactionGroup { return predicate.LedgerTransactionGroup(sql.AndPredicates(predicates...)) diff --git a/openmeter/ent/db/ledgertransactiongroup_create.go b/openmeter/ent/db/ledgertransactiongroup_create.go index ddfc1ff11e..246402cf74 100644 --- a/openmeter/ent/db/ledgertransactiongroup_create.go +++ b/openmeter/ent/db/ledgertransactiongroup_create.go @@ -12,6 +12,7 @@ import ( "entgo.io/ent/dialect/sql" "entgo.io/ent/dialect/sql/sqlgraph" "entgo.io/ent/schema/field" + "github.com/openmeterio/openmeter/openmeter/ent/db/ledgerbreakagerecord" "github.com/openmeterio/openmeter/openmeter/ent/db/ledgertransaction" "github.com/openmeterio/openmeter/openmeter/ent/db/ledgertransactiongroup" "github.com/openmeterio/openmeter/pkg/models" @@ -108,6 +109,36 @@ func (_c *LedgerTransactionGroupCreate) AddTransactions(v ...*LedgerTransaction) return _c.AddTransactionIDs(ids...) } +// AddSourceBreakageRecordIDs adds the "source_breakage_records" edge to the LedgerBreakageRecord entity by IDs. +func (_c *LedgerTransactionGroupCreate) AddSourceBreakageRecordIDs(ids ...string) *LedgerTransactionGroupCreate { + _c.mutation.AddSourceBreakageRecordIDs(ids...) + return _c +} + +// AddSourceBreakageRecords adds the "source_breakage_records" edges to the LedgerBreakageRecord entity. +func (_c *LedgerTransactionGroupCreate) AddSourceBreakageRecords(v ...*LedgerBreakageRecord) *LedgerTransactionGroupCreate { + ids := make([]string, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _c.AddSourceBreakageRecordIDs(ids...) +} + +// AddBreakageRecordIDs adds the "breakage_records" edge to the LedgerBreakageRecord entity by IDs. +func (_c *LedgerTransactionGroupCreate) AddBreakageRecordIDs(ids ...string) *LedgerTransactionGroupCreate { + _c.mutation.AddBreakageRecordIDs(ids...) + return _c +} + +// AddBreakageRecords adds the "breakage_records" edges to the LedgerBreakageRecord entity. +func (_c *LedgerTransactionGroupCreate) AddBreakageRecords(v ...*LedgerBreakageRecord) *LedgerTransactionGroupCreate { + ids := make([]string, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _c.AddBreakageRecordIDs(ids...) +} + // Mutation returns the LedgerTransactionGroupMutation object of the builder. func (_c *LedgerTransactionGroupCreate) Mutation() *LedgerTransactionGroupMutation { return _c.mutation @@ -245,6 +276,38 @@ func (_c *LedgerTransactionGroupCreate) createSpec() (*LedgerTransactionGroup, * } _spec.Edges = append(_spec.Edges, edge) } + if nodes := _c.mutation.SourceBreakageRecordsIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgertransactiongroup.SourceBreakageRecordsTable, + Columns: []string{ledgertransactiongroup.SourceBreakageRecordsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges = append(_spec.Edges, edge) + } + if nodes := _c.mutation.BreakageRecordsIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgertransactiongroup.BreakageRecordsTable, + Columns: []string{ledgertransactiongroup.BreakageRecordsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges = append(_spec.Edges, edge) + } return _node, _spec } diff --git a/openmeter/ent/db/ledgertransactiongroup_query.go b/openmeter/ent/db/ledgertransactiongroup_query.go index 79d891e6e6..0db13cf29e 100644 --- a/openmeter/ent/db/ledgertransactiongroup_query.go +++ b/openmeter/ent/db/ledgertransactiongroup_query.go @@ -13,6 +13,7 @@ import ( "entgo.io/ent/dialect/sql" "entgo.io/ent/dialect/sql/sqlgraph" "entgo.io/ent/schema/field" + "github.com/openmeterio/openmeter/openmeter/ent/db/ledgerbreakagerecord" "github.com/openmeterio/openmeter/openmeter/ent/db/ledgertransaction" "github.com/openmeterio/openmeter/openmeter/ent/db/ledgertransactiongroup" "github.com/openmeterio/openmeter/openmeter/ent/db/predicate" @@ -21,12 +22,14 @@ import ( // LedgerTransactionGroupQuery is the builder for querying LedgerTransactionGroup entities. type LedgerTransactionGroupQuery struct { config - ctx *QueryContext - order []ledgertransactiongroup.OrderOption - inters []Interceptor - predicates []predicate.LedgerTransactionGroup - withTransactions *LedgerTransactionQuery - modifiers []func(*sql.Selector) + ctx *QueryContext + order []ledgertransactiongroup.OrderOption + inters []Interceptor + predicates []predicate.LedgerTransactionGroup + withTransactions *LedgerTransactionQuery + withSourceBreakageRecords *LedgerBreakageRecordQuery + withBreakageRecords *LedgerBreakageRecordQuery + modifiers []func(*sql.Selector) // intermediate query (i.e. traversal path). sql *sql.Selector path func(context.Context) (*sql.Selector, error) @@ -85,6 +88,50 @@ func (_q *LedgerTransactionGroupQuery) QueryTransactions() *LedgerTransactionQue return query } +// QuerySourceBreakageRecords chains the current query on the "source_breakage_records" edge. +func (_q *LedgerTransactionGroupQuery) QuerySourceBreakageRecords() *LedgerBreakageRecordQuery { + query := (&LedgerBreakageRecordClient{config: _q.config}).Query() + query.path = func(ctx context.Context) (fromU *sql.Selector, err error) { + if err := _q.prepareQuery(ctx); err != nil { + return nil, err + } + selector := _q.sqlQuery(ctx) + if err := selector.Err(); err != nil { + return nil, err + } + step := sqlgraph.NewStep( + sqlgraph.From(ledgertransactiongroup.Table, ledgertransactiongroup.FieldID, selector), + sqlgraph.To(ledgerbreakagerecord.Table, ledgerbreakagerecord.FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, ledgertransactiongroup.SourceBreakageRecordsTable, ledgertransactiongroup.SourceBreakageRecordsColumn), + ) + fromU = sqlgraph.SetNeighbors(_q.driver.Dialect(), step) + return fromU, nil + } + return query +} + +// QueryBreakageRecords chains the current query on the "breakage_records" edge. +func (_q *LedgerTransactionGroupQuery) QueryBreakageRecords() *LedgerBreakageRecordQuery { + query := (&LedgerBreakageRecordClient{config: _q.config}).Query() + query.path = func(ctx context.Context) (fromU *sql.Selector, err error) { + if err := _q.prepareQuery(ctx); err != nil { + return nil, err + } + selector := _q.sqlQuery(ctx) + if err := selector.Err(); err != nil { + return nil, err + } + step := sqlgraph.NewStep( + sqlgraph.From(ledgertransactiongroup.Table, ledgertransactiongroup.FieldID, selector), + sqlgraph.To(ledgerbreakagerecord.Table, ledgerbreakagerecord.FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, ledgertransactiongroup.BreakageRecordsTable, ledgertransactiongroup.BreakageRecordsColumn), + ) + fromU = sqlgraph.SetNeighbors(_q.driver.Dialect(), step) + return fromU, nil + } + return query +} + // First returns the first LedgerTransactionGroup entity from the query. // Returns a *NotFoundError when no LedgerTransactionGroup was found. func (_q *LedgerTransactionGroupQuery) First(ctx context.Context) (*LedgerTransactionGroup, error) { @@ -272,12 +319,14 @@ func (_q *LedgerTransactionGroupQuery) Clone() *LedgerTransactionGroupQuery { return nil } return &LedgerTransactionGroupQuery{ - config: _q.config, - ctx: _q.ctx.Clone(), - order: append([]ledgertransactiongroup.OrderOption{}, _q.order...), - inters: append([]Interceptor{}, _q.inters...), - predicates: append([]predicate.LedgerTransactionGroup{}, _q.predicates...), - withTransactions: _q.withTransactions.Clone(), + config: _q.config, + ctx: _q.ctx.Clone(), + order: append([]ledgertransactiongroup.OrderOption{}, _q.order...), + inters: append([]Interceptor{}, _q.inters...), + predicates: append([]predicate.LedgerTransactionGroup{}, _q.predicates...), + withTransactions: _q.withTransactions.Clone(), + withSourceBreakageRecords: _q.withSourceBreakageRecords.Clone(), + withBreakageRecords: _q.withBreakageRecords.Clone(), // clone intermediate query. sql: _q.sql.Clone(), path: _q.path, @@ -295,6 +344,28 @@ func (_q *LedgerTransactionGroupQuery) WithTransactions(opts ...func(*LedgerTran return _q } +// WithSourceBreakageRecords tells the query-builder to eager-load the nodes that are connected to +// the "source_breakage_records" edge. The optional arguments are used to configure the query builder of the edge. +func (_q *LedgerTransactionGroupQuery) WithSourceBreakageRecords(opts ...func(*LedgerBreakageRecordQuery)) *LedgerTransactionGroupQuery { + query := (&LedgerBreakageRecordClient{config: _q.config}).Query() + for _, opt := range opts { + opt(query) + } + _q.withSourceBreakageRecords = query + return _q +} + +// WithBreakageRecords tells the query-builder to eager-load the nodes that are connected to +// the "breakage_records" edge. The optional arguments are used to configure the query builder of the edge. +func (_q *LedgerTransactionGroupQuery) WithBreakageRecords(opts ...func(*LedgerBreakageRecordQuery)) *LedgerTransactionGroupQuery { + query := (&LedgerBreakageRecordClient{config: _q.config}).Query() + for _, opt := range opts { + opt(query) + } + _q.withBreakageRecords = query + return _q +} + // 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. // @@ -373,8 +444,10 @@ func (_q *LedgerTransactionGroupQuery) sqlAll(ctx context.Context, hooks ...quer var ( nodes = []*LedgerTransactionGroup{} _spec = _q.querySpec() - loadedTypes = [1]bool{ + loadedTypes = [3]bool{ _q.withTransactions != nil, + _q.withSourceBreakageRecords != nil, + _q.withBreakageRecords != nil, } ) _spec.ScanValues = func(columns []string) ([]any, error) { @@ -407,6 +480,24 @@ func (_q *LedgerTransactionGroupQuery) sqlAll(ctx context.Context, hooks ...quer return nil, err } } + if query := _q.withSourceBreakageRecords; query != nil { + if err := _q.loadSourceBreakageRecords(ctx, query, nodes, + func(n *LedgerTransactionGroup) { n.Edges.SourceBreakageRecords = []*LedgerBreakageRecord{} }, + func(n *LedgerTransactionGroup, e *LedgerBreakageRecord) { + n.Edges.SourceBreakageRecords = append(n.Edges.SourceBreakageRecords, e) + }); err != nil { + return nil, err + } + } + if query := _q.withBreakageRecords; query != nil { + if err := _q.loadBreakageRecords(ctx, query, nodes, + func(n *LedgerTransactionGroup) { n.Edges.BreakageRecords = []*LedgerBreakageRecord{} }, + func(n *LedgerTransactionGroup, e *LedgerBreakageRecord) { + n.Edges.BreakageRecords = append(n.Edges.BreakageRecords, e) + }); err != nil { + return nil, err + } + } return nodes, nil } @@ -440,6 +531,69 @@ func (_q *LedgerTransactionGroupQuery) loadTransactions(ctx context.Context, que } return nil } +func (_q *LedgerTransactionGroupQuery) loadSourceBreakageRecords(ctx context.Context, query *LedgerBreakageRecordQuery, nodes []*LedgerTransactionGroup, init func(*LedgerTransactionGroup), assign func(*LedgerTransactionGroup, *LedgerBreakageRecord)) error { + fks := make([]driver.Value, 0, len(nodes)) + nodeids := make(map[string]*LedgerTransactionGroup) + for i := range nodes { + fks = append(fks, nodes[i].ID) + nodeids[nodes[i].ID] = nodes[i] + if init != nil { + init(nodes[i]) + } + } + if len(query.ctx.Fields) > 0 { + query.ctx.AppendFieldOnce(ledgerbreakagerecord.FieldSourceTransactionGroupID) + } + query.Where(predicate.LedgerBreakageRecord(func(s *sql.Selector) { + s.Where(sql.InValues(s.C(ledgertransactiongroup.SourceBreakageRecordsColumn), fks...)) + })) + neighbors, err := query.All(ctx) + if err != nil { + return err + } + for _, n := range neighbors { + fk := n.SourceTransactionGroupID + if fk == nil { + return fmt.Errorf(`foreign-key "source_transaction_group_id" is nil for node %v`, n.ID) + } + node, ok := nodeids[*fk] + if !ok { + return fmt.Errorf(`unexpected referenced foreign-key "source_transaction_group_id" returned %v for node %v`, *fk, n.ID) + } + assign(node, n) + } + return nil +} +func (_q *LedgerTransactionGroupQuery) loadBreakageRecords(ctx context.Context, query *LedgerBreakageRecordQuery, nodes []*LedgerTransactionGroup, init func(*LedgerTransactionGroup), assign func(*LedgerTransactionGroup, *LedgerBreakageRecord)) error { + fks := make([]driver.Value, 0, len(nodes)) + nodeids := make(map[string]*LedgerTransactionGroup) + for i := range nodes { + fks = append(fks, nodes[i].ID) + nodeids[nodes[i].ID] = nodes[i] + if init != nil { + init(nodes[i]) + } + } + if len(query.ctx.Fields) > 0 { + query.ctx.AppendFieldOnce(ledgerbreakagerecord.FieldBreakageTransactionGroupID) + } + query.Where(predicate.LedgerBreakageRecord(func(s *sql.Selector) { + s.Where(sql.InValues(s.C(ledgertransactiongroup.BreakageRecordsColumn), fks...)) + })) + neighbors, err := query.All(ctx) + if err != nil { + return err + } + for _, n := range neighbors { + fk := n.BreakageTransactionGroupID + node, ok := nodeids[fk] + if !ok { + return fmt.Errorf(`unexpected referenced foreign-key "breakage_transaction_group_id" returned %v for node %v`, fk, n.ID) + } + assign(node, n) + } + return nil +} func (_q *LedgerTransactionGroupQuery) sqlCount(ctx context.Context) (int, error) { _spec := _q.querySpec() diff --git a/openmeter/ent/db/ledgertransactiongroup_update.go b/openmeter/ent/db/ledgertransactiongroup_update.go index 98d49f68ff..8d26f5cd41 100644 --- a/openmeter/ent/db/ledgertransactiongroup_update.go +++ b/openmeter/ent/db/ledgertransactiongroup_update.go @@ -11,6 +11,7 @@ import ( "entgo.io/ent/dialect/sql" "entgo.io/ent/dialect/sql/sqlgraph" "entgo.io/ent/schema/field" + "github.com/openmeterio/openmeter/openmeter/ent/db/ledgerbreakagerecord" "github.com/openmeterio/openmeter/openmeter/ent/db/ledgertransaction" "github.com/openmeterio/openmeter/openmeter/ent/db/ledgertransactiongroup" "github.com/openmeterio/openmeter/openmeter/ent/db/predicate" @@ -83,6 +84,36 @@ func (_u *LedgerTransactionGroupUpdate) AddTransactions(v ...*LedgerTransaction) return _u.AddTransactionIDs(ids...) } +// AddSourceBreakageRecordIDs adds the "source_breakage_records" edge to the LedgerBreakageRecord entity by IDs. +func (_u *LedgerTransactionGroupUpdate) AddSourceBreakageRecordIDs(ids ...string) *LedgerTransactionGroupUpdate { + _u.mutation.AddSourceBreakageRecordIDs(ids...) + return _u +} + +// AddSourceBreakageRecords adds the "source_breakage_records" edges to the LedgerBreakageRecord entity. +func (_u *LedgerTransactionGroupUpdate) AddSourceBreakageRecords(v ...*LedgerBreakageRecord) *LedgerTransactionGroupUpdate { + ids := make([]string, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _u.AddSourceBreakageRecordIDs(ids...) +} + +// AddBreakageRecordIDs adds the "breakage_records" edge to the LedgerBreakageRecord entity by IDs. +func (_u *LedgerTransactionGroupUpdate) AddBreakageRecordIDs(ids ...string) *LedgerTransactionGroupUpdate { + _u.mutation.AddBreakageRecordIDs(ids...) + return _u +} + +// AddBreakageRecords adds the "breakage_records" edges to the LedgerBreakageRecord entity. +func (_u *LedgerTransactionGroupUpdate) AddBreakageRecords(v ...*LedgerBreakageRecord) *LedgerTransactionGroupUpdate { + ids := make([]string, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _u.AddBreakageRecordIDs(ids...) +} + // Mutation returns the LedgerTransactionGroupMutation object of the builder. func (_u *LedgerTransactionGroupUpdate) Mutation() *LedgerTransactionGroupMutation { return _u.mutation @@ -109,6 +140,48 @@ func (_u *LedgerTransactionGroupUpdate) RemoveTransactions(v ...*LedgerTransacti return _u.RemoveTransactionIDs(ids...) } +// ClearSourceBreakageRecords clears all "source_breakage_records" edges to the LedgerBreakageRecord entity. +func (_u *LedgerTransactionGroupUpdate) ClearSourceBreakageRecords() *LedgerTransactionGroupUpdate { + _u.mutation.ClearSourceBreakageRecords() + return _u +} + +// RemoveSourceBreakageRecordIDs removes the "source_breakage_records" edge to LedgerBreakageRecord entities by IDs. +func (_u *LedgerTransactionGroupUpdate) RemoveSourceBreakageRecordIDs(ids ...string) *LedgerTransactionGroupUpdate { + _u.mutation.RemoveSourceBreakageRecordIDs(ids...) + return _u +} + +// RemoveSourceBreakageRecords removes "source_breakage_records" edges to LedgerBreakageRecord entities. +func (_u *LedgerTransactionGroupUpdate) RemoveSourceBreakageRecords(v ...*LedgerBreakageRecord) *LedgerTransactionGroupUpdate { + ids := make([]string, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _u.RemoveSourceBreakageRecordIDs(ids...) +} + +// ClearBreakageRecords clears all "breakage_records" edges to the LedgerBreakageRecord entity. +func (_u *LedgerTransactionGroupUpdate) ClearBreakageRecords() *LedgerTransactionGroupUpdate { + _u.mutation.ClearBreakageRecords() + return _u +} + +// RemoveBreakageRecordIDs removes the "breakage_records" edge to LedgerBreakageRecord entities by IDs. +func (_u *LedgerTransactionGroupUpdate) RemoveBreakageRecordIDs(ids ...string) *LedgerTransactionGroupUpdate { + _u.mutation.RemoveBreakageRecordIDs(ids...) + return _u +} + +// RemoveBreakageRecords removes "breakage_records" edges to LedgerBreakageRecord entities. +func (_u *LedgerTransactionGroupUpdate) RemoveBreakageRecords(v ...*LedgerBreakageRecord) *LedgerTransactionGroupUpdate { + ids := make([]string, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _u.RemoveBreakageRecordIDs(ids...) +} + // Save executes the query and returns the number of nodes affected by the update operation. func (_u *LedgerTransactionGroupUpdate) Save(ctx context.Context) (int, error) { _u.defaults() @@ -214,6 +287,96 @@ func (_u *LedgerTransactionGroupUpdate) sqlSave(ctx context.Context) (_node int, } _spec.Edges.Add = append(_spec.Edges.Add, edge) } + if _u.mutation.SourceBreakageRecordsCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgertransactiongroup.SourceBreakageRecordsTable, + Columns: []string{ledgertransactiongroup.SourceBreakageRecordsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := _u.mutation.RemovedSourceBreakageRecordsIDs(); len(nodes) > 0 && !_u.mutation.SourceBreakageRecordsCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgertransactiongroup.SourceBreakageRecordsTable, + Columns: []string{ledgertransactiongroup.SourceBreakageRecordsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := _u.mutation.SourceBreakageRecordsIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgertransactiongroup.SourceBreakageRecordsTable, + Columns: []string{ledgertransactiongroup.SourceBreakageRecordsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Add = append(_spec.Edges.Add, edge) + } + if _u.mutation.BreakageRecordsCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgertransactiongroup.BreakageRecordsTable, + Columns: []string{ledgertransactiongroup.BreakageRecordsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := _u.mutation.RemovedBreakageRecordsIDs(); len(nodes) > 0 && !_u.mutation.BreakageRecordsCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgertransactiongroup.BreakageRecordsTable, + Columns: []string{ledgertransactiongroup.BreakageRecordsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := _u.mutation.BreakageRecordsIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgertransactiongroup.BreakageRecordsTable, + Columns: []string{ledgertransactiongroup.BreakageRecordsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Add = append(_spec.Edges.Add, edge) + } if _node, err = sqlgraph.UpdateNodes(ctx, _u.driver, _spec); err != nil { if _, ok := err.(*sqlgraph.NotFoundError); ok { err = &NotFoundError{ledgertransactiongroup.Label} @@ -287,6 +450,36 @@ func (_u *LedgerTransactionGroupUpdateOne) AddTransactions(v ...*LedgerTransacti return _u.AddTransactionIDs(ids...) } +// AddSourceBreakageRecordIDs adds the "source_breakage_records" edge to the LedgerBreakageRecord entity by IDs. +func (_u *LedgerTransactionGroupUpdateOne) AddSourceBreakageRecordIDs(ids ...string) *LedgerTransactionGroupUpdateOne { + _u.mutation.AddSourceBreakageRecordIDs(ids...) + return _u +} + +// AddSourceBreakageRecords adds the "source_breakage_records" edges to the LedgerBreakageRecord entity. +func (_u *LedgerTransactionGroupUpdateOne) AddSourceBreakageRecords(v ...*LedgerBreakageRecord) *LedgerTransactionGroupUpdateOne { + ids := make([]string, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _u.AddSourceBreakageRecordIDs(ids...) +} + +// AddBreakageRecordIDs adds the "breakage_records" edge to the LedgerBreakageRecord entity by IDs. +func (_u *LedgerTransactionGroupUpdateOne) AddBreakageRecordIDs(ids ...string) *LedgerTransactionGroupUpdateOne { + _u.mutation.AddBreakageRecordIDs(ids...) + return _u +} + +// AddBreakageRecords adds the "breakage_records" edges to the LedgerBreakageRecord entity. +func (_u *LedgerTransactionGroupUpdateOne) AddBreakageRecords(v ...*LedgerBreakageRecord) *LedgerTransactionGroupUpdateOne { + ids := make([]string, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _u.AddBreakageRecordIDs(ids...) +} + // Mutation returns the LedgerTransactionGroupMutation object of the builder. func (_u *LedgerTransactionGroupUpdateOne) Mutation() *LedgerTransactionGroupMutation { return _u.mutation @@ -313,6 +506,48 @@ func (_u *LedgerTransactionGroupUpdateOne) RemoveTransactions(v ...*LedgerTransa return _u.RemoveTransactionIDs(ids...) } +// ClearSourceBreakageRecords clears all "source_breakage_records" edges to the LedgerBreakageRecord entity. +func (_u *LedgerTransactionGroupUpdateOne) ClearSourceBreakageRecords() *LedgerTransactionGroupUpdateOne { + _u.mutation.ClearSourceBreakageRecords() + return _u +} + +// RemoveSourceBreakageRecordIDs removes the "source_breakage_records" edge to LedgerBreakageRecord entities by IDs. +func (_u *LedgerTransactionGroupUpdateOne) RemoveSourceBreakageRecordIDs(ids ...string) *LedgerTransactionGroupUpdateOne { + _u.mutation.RemoveSourceBreakageRecordIDs(ids...) + return _u +} + +// RemoveSourceBreakageRecords removes "source_breakage_records" edges to LedgerBreakageRecord entities. +func (_u *LedgerTransactionGroupUpdateOne) RemoveSourceBreakageRecords(v ...*LedgerBreakageRecord) *LedgerTransactionGroupUpdateOne { + ids := make([]string, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _u.RemoveSourceBreakageRecordIDs(ids...) +} + +// ClearBreakageRecords clears all "breakage_records" edges to the LedgerBreakageRecord entity. +func (_u *LedgerTransactionGroupUpdateOne) ClearBreakageRecords() *LedgerTransactionGroupUpdateOne { + _u.mutation.ClearBreakageRecords() + return _u +} + +// RemoveBreakageRecordIDs removes the "breakage_records" edge to LedgerBreakageRecord entities by IDs. +func (_u *LedgerTransactionGroupUpdateOne) RemoveBreakageRecordIDs(ids ...string) *LedgerTransactionGroupUpdateOne { + _u.mutation.RemoveBreakageRecordIDs(ids...) + return _u +} + +// RemoveBreakageRecords removes "breakage_records" edges to LedgerBreakageRecord entities. +func (_u *LedgerTransactionGroupUpdateOne) RemoveBreakageRecords(v ...*LedgerBreakageRecord) *LedgerTransactionGroupUpdateOne { + ids := make([]string, len(v)) + for i := range v { + ids[i] = v[i].ID + } + return _u.RemoveBreakageRecordIDs(ids...) +} + // Where appends a list predicates to the LedgerTransactionGroupUpdate builder. func (_u *LedgerTransactionGroupUpdateOne) Where(ps ...predicate.LedgerTransactionGroup) *LedgerTransactionGroupUpdateOne { _u.mutation.Where(ps...) @@ -448,6 +683,96 @@ func (_u *LedgerTransactionGroupUpdateOne) sqlSave(ctx context.Context) (_node * } _spec.Edges.Add = append(_spec.Edges.Add, edge) } + if _u.mutation.SourceBreakageRecordsCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgertransactiongroup.SourceBreakageRecordsTable, + Columns: []string{ledgertransactiongroup.SourceBreakageRecordsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := _u.mutation.RemovedSourceBreakageRecordsIDs(); len(nodes) > 0 && !_u.mutation.SourceBreakageRecordsCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgertransactiongroup.SourceBreakageRecordsTable, + Columns: []string{ledgertransactiongroup.SourceBreakageRecordsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := _u.mutation.SourceBreakageRecordsIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgertransactiongroup.SourceBreakageRecordsTable, + Columns: []string{ledgertransactiongroup.SourceBreakageRecordsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Add = append(_spec.Edges.Add, edge) + } + if _u.mutation.BreakageRecordsCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgertransactiongroup.BreakageRecordsTable, + Columns: []string{ledgertransactiongroup.BreakageRecordsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := _u.mutation.RemovedBreakageRecordsIDs(); len(nodes) > 0 && !_u.mutation.BreakageRecordsCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgertransactiongroup.BreakageRecordsTable, + Columns: []string{ledgertransactiongroup.BreakageRecordsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := _u.mutation.BreakageRecordsIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: ledgertransactiongroup.BreakageRecordsTable, + Columns: []string{ledgertransactiongroup.BreakageRecordsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(ledgerbreakagerecord.FieldID, field.TypeString), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Add = append(_spec.Edges.Add, edge) + } _node = &LedgerTransactionGroup{config: _u.config} _spec.Assign = _node.assignValues _spec.ScanValues = _node.scanValues diff --git a/openmeter/ent/db/migrate/schema.go b/openmeter/ent/db/migrate/schema.go index 65f15ecd89..7ca969c29a 100644 --- a/openmeter/ent/db/migrate/schema.go +++ b/openmeter/ent/db/migrate/schema.go @@ -3683,21 +3683,77 @@ var ( {Name: "expires_at", Type: field.TypeTime}, {Name: "source_kind", Type: field.TypeEnum, Enums: []string{"credit_purchase", "usage", "usage_correction", "credit_purchase_correction", "advance_backfill"}}, {Name: "source_charge_id", Type: field.TypeString, Nullable: true, SchemaType: map[string]string{"postgres": "char(26)"}}, - {Name: "source_transaction_group_id", Type: field.TypeString, Nullable: true, SchemaType: map[string]string{"postgres": "char(26)"}}, - {Name: "source_transaction_id", Type: field.TypeString, Nullable: true, SchemaType: map[string]string{"postgres": "char(26)"}}, + {Name: "plan_id", Type: field.TypeString, Nullable: true, SchemaType: map[string]string{"postgres": "char(26)"}}, + {Name: "release_id", Type: field.TypeString, Nullable: true, SchemaType: map[string]string{"postgres": "char(26)"}}, {Name: "source_entry_id", Type: field.TypeString, Nullable: true, SchemaType: map[string]string{"postgres": "char(26)"}}, - {Name: "breakage_transaction_group_id", Type: field.TypeString, SchemaType: map[string]string{"postgres": "char(26)"}}, - {Name: "breakage_transaction_id", Type: field.TypeString, SchemaType: map[string]string{"postgres": "char(26)"}}, {Name: "fbo_sub_account_id", Type: field.TypeString, SchemaType: map[string]string{"postgres": "char(26)"}}, {Name: "breakage_sub_account_id", Type: field.TypeString, SchemaType: map[string]string{"postgres": "char(26)"}}, - {Name: "plan_id", Type: field.TypeString, Nullable: true, SchemaType: map[string]string{"postgres": "char(26)"}}, - {Name: "release_id", Type: field.TypeString, Nullable: true, SchemaType: map[string]string{"postgres": "char(26)"}}, + {Name: "source_transaction_id", Type: field.TypeString, Nullable: true, SchemaType: map[string]string{"postgres": "char(26)"}}, + {Name: "breakage_transaction_id", Type: field.TypeString, SchemaType: map[string]string{"postgres": "char(26)"}}, + {Name: "source_transaction_group_id", Type: field.TypeString, Nullable: true, SchemaType: map[string]string{"postgres": "char(26)"}}, + {Name: "breakage_transaction_group_id", Type: field.TypeString, SchemaType: map[string]string{"postgres": "char(26)"}}, } // LedgerBreakageRecordsTable holds the schema information for the "ledger_breakage_records" table. LedgerBreakageRecordsTable = &schema.Table{ Name: "ledger_breakage_records", Columns: LedgerBreakageRecordsColumns, PrimaryKey: []*schema.Column{LedgerBreakageRecordsColumns[0]}, + ForeignKeys: []*schema.ForeignKey{ + { + Symbol: "ledger_breakage_records_ledger_breakage_records_planned_releases", + Columns: []*schema.Column{LedgerBreakageRecordsColumns[14]}, + RefColumns: []*schema.Column{LedgerBreakageRecordsColumns[0]}, + OnDelete: schema.Restrict, + }, + { + Symbol: "ledger_breakage_records_ledger_breakage_records_release_reopens", + Columns: []*schema.Column{LedgerBreakageRecordsColumns[15]}, + RefColumns: []*schema.Column{LedgerBreakageRecordsColumns[0]}, + OnDelete: schema.Restrict, + }, + { + Symbol: "ledger_breakage_records_ledger_entries_source_breakage_records", + Columns: []*schema.Column{LedgerBreakageRecordsColumns[16]}, + RefColumns: []*schema.Column{LedgerEntriesColumns[0]}, + OnDelete: schema.Restrict, + }, + { + Symbol: "ledger_breakage_records_ledger_sub_accounts_fbo_breakage_records", + Columns: []*schema.Column{LedgerBreakageRecordsColumns[17]}, + RefColumns: []*schema.Column{LedgerSubAccountsColumns[0]}, + OnDelete: schema.NoAction, + }, + { + Symbol: "ledger_breakage_records_ledger_sub_accounts_breakage_records", + Columns: []*schema.Column{LedgerBreakageRecordsColumns[18]}, + RefColumns: []*schema.Column{LedgerSubAccountsColumns[0]}, + OnDelete: schema.NoAction, + }, + { + Symbol: "ledger_breakage_records_ledger_transactions_source_breakage_records", + Columns: []*schema.Column{LedgerBreakageRecordsColumns[19]}, + RefColumns: []*schema.Column{LedgerTransactionsColumns[0]}, + OnDelete: schema.Restrict, + }, + { + Symbol: "ledger_breakage_records_ledger_transactions_breakage_records", + Columns: []*schema.Column{LedgerBreakageRecordsColumns[20]}, + RefColumns: []*schema.Column{LedgerTransactionsColumns[0]}, + OnDelete: schema.NoAction, + }, + { + Symbol: "ledger_breakage_records_ledger_transaction_groups_source_breakage_records", + Columns: []*schema.Column{LedgerBreakageRecordsColumns[21]}, + RefColumns: []*schema.Column{LedgerTransactionGroupsColumns[0]}, + OnDelete: schema.Restrict, + }, + { + Symbol: "ledger_breakage_records_ledger_transaction_groups_breakage_records", + Columns: []*schema.Column{LedgerBreakageRecordsColumns[22]}, + RefColumns: []*schema.Column{LedgerTransactionGroupsColumns[0]}, + OnDelete: schema.NoAction, + }, + }, Indexes: []*schema.Index{ { Name: "ledgerbreakagerecord_id", @@ -3727,7 +3783,7 @@ var ( { Name: "ledgerbreakagerecord_namespace_plan_id", Unique: false, - Columns: []*schema.Column{LedgerBreakageRecordsColumns[1], LedgerBreakageRecordsColumns[21]}, + Columns: []*schema.Column{LedgerBreakageRecordsColumns[1], LedgerBreakageRecordsColumns[14]}, }, { Name: "ledgerbreakagerecord_namespace_source_charge_id", @@ -3737,7 +3793,7 @@ var ( { Name: "ledgerbreakagerecord_namespace_source_transaction_group_id", Unique: false, - Columns: []*schema.Column{LedgerBreakageRecordsColumns[1], LedgerBreakageRecordsColumns[14]}, + Columns: []*schema.Column{LedgerBreakageRecordsColumns[1], LedgerBreakageRecordsColumns[21]}, }, { Name: "ledgerbreakagerecord_namespace_source_entry_id", @@ -3747,7 +3803,7 @@ var ( { Name: "ledgerbreakagerecord_namespace_breakage_transaction_group_id", Unique: false, - Columns: []*schema.Column{LedgerBreakageRecordsColumns[1], LedgerBreakageRecordsColumns[17]}, + Columns: []*schema.Column{LedgerBreakageRecordsColumns[1], LedgerBreakageRecordsColumns[22]}, }, }, } @@ -3760,13 +3816,21 @@ var ( {Name: "deleted_at", Type: field.TypeTime, Nullable: true}, {Name: "customer_id", Type: field.TypeString}, {Name: "account_type", Type: field.TypeString}, - {Name: "account_id", Type: field.TypeString}, + {Name: "account_id", Type: field.TypeString, SchemaType: map[string]string{"postgres": "char(26)"}}, } // LedgerCustomerAccountsTable holds the schema information for the "ledger_customer_accounts" table. LedgerCustomerAccountsTable = &schema.Table{ Name: "ledger_customer_accounts", Columns: LedgerCustomerAccountsColumns, PrimaryKey: []*schema.Column{LedgerCustomerAccountsColumns[0]}, + ForeignKeys: []*schema.ForeignKey{ + { + Symbol: "ledger_customer_accounts_ledger_accounts_customer_accounts", + Columns: []*schema.Column{LedgerCustomerAccountsColumns[7]}, + RefColumns: []*schema.Column{LedgerAccountsColumns[0]}, + OnDelete: schema.NoAction, + }, + }, Indexes: []*schema.Index{ { Name: "ledgercustomeraccount_id", @@ -5518,6 +5582,16 @@ func init() { "unit_cost_llm_token_type_mutual_exclusive": "NOT (unit_cost_llm_token_type_property IS NOT NULL AND unit_cost_llm_token_type IS NOT NULL)", } GrantsTable.ForeignKeys[0].RefTable = EntitlementsTable + LedgerBreakageRecordsTable.ForeignKeys[0].RefTable = LedgerBreakageRecordsTable + LedgerBreakageRecordsTable.ForeignKeys[1].RefTable = LedgerBreakageRecordsTable + LedgerBreakageRecordsTable.ForeignKeys[2].RefTable = LedgerEntriesTable + LedgerBreakageRecordsTable.ForeignKeys[3].RefTable = LedgerSubAccountsTable + LedgerBreakageRecordsTable.ForeignKeys[4].RefTable = LedgerSubAccountsTable + LedgerBreakageRecordsTable.ForeignKeys[5].RefTable = LedgerTransactionsTable + LedgerBreakageRecordsTable.ForeignKeys[6].RefTable = LedgerTransactionsTable + LedgerBreakageRecordsTable.ForeignKeys[7].RefTable = LedgerTransactionGroupsTable + LedgerBreakageRecordsTable.ForeignKeys[8].RefTable = LedgerTransactionGroupsTable + LedgerCustomerAccountsTable.ForeignKeys[0].RefTable = LedgerAccountsTable LedgerEntriesTable.ForeignKeys[0].RefTable = LedgerSubAccountsTable LedgerEntriesTable.ForeignKeys[1].RefTable = LedgerTransactionsTable LedgerSubAccountsTable.ForeignKeys[0].RefTable = LedgerAccountsTable diff --git a/openmeter/ent/db/mutation.go b/openmeter/ent/db/mutation.go index 097f7e5a68..0d6bac06cd 100644 --- a/openmeter/ent/db/mutation.go +++ b/openmeter/ent/db/mutation.go @@ -82278,6 +82278,9 @@ type LedgerAccountMutation struct { sub_account_routes map[string]struct{} removedsub_account_routes map[string]struct{} clearedsub_account_routes bool + customer_accounts map[string]struct{} + removedcustomer_accounts map[string]struct{} + clearedcustomer_accounts bool done bool oldValue func(context.Context) (*LedgerAccount, error) predicates []predicate.LedgerAccount @@ -82737,6 +82740,60 @@ func (m *LedgerAccountMutation) ResetSubAccountRoutes() { m.removedsub_account_routes = nil } +// AddCustomerAccountIDs adds the "customer_accounts" edge to the LedgerCustomerAccount entity by ids. +func (m *LedgerAccountMutation) AddCustomerAccountIDs(ids ...string) { + if m.customer_accounts == nil { + m.customer_accounts = make(map[string]struct{}) + } + for i := range ids { + m.customer_accounts[ids[i]] = struct{}{} + } +} + +// ClearCustomerAccounts clears the "customer_accounts" edge to the LedgerCustomerAccount entity. +func (m *LedgerAccountMutation) ClearCustomerAccounts() { + m.clearedcustomer_accounts = true +} + +// CustomerAccountsCleared reports if the "customer_accounts" edge to the LedgerCustomerAccount entity was cleared. +func (m *LedgerAccountMutation) CustomerAccountsCleared() bool { + return m.clearedcustomer_accounts +} + +// RemoveCustomerAccountIDs removes the "customer_accounts" edge to the LedgerCustomerAccount entity by IDs. +func (m *LedgerAccountMutation) RemoveCustomerAccountIDs(ids ...string) { + if m.removedcustomer_accounts == nil { + m.removedcustomer_accounts = make(map[string]struct{}) + } + for i := range ids { + delete(m.customer_accounts, ids[i]) + m.removedcustomer_accounts[ids[i]] = struct{}{} + } +} + +// RemovedCustomerAccounts returns the removed IDs of the "customer_accounts" edge to the LedgerCustomerAccount entity. +func (m *LedgerAccountMutation) RemovedCustomerAccountsIDs() (ids []string) { + for id := range m.removedcustomer_accounts { + ids = append(ids, id) + } + return +} + +// CustomerAccountsIDs returns the "customer_accounts" edge IDs in the mutation. +func (m *LedgerAccountMutation) CustomerAccountsIDs() (ids []string) { + for id := range m.customer_accounts { + ids = append(ids, id) + } + return +} + +// ResetCustomerAccounts resets all changes to the "customer_accounts" edge. +func (m *LedgerAccountMutation) ResetCustomerAccounts() { + m.customer_accounts = nil + m.clearedcustomer_accounts = false + m.removedcustomer_accounts = nil +} + // Where appends a list predicates to the LedgerAccountMutation builder. func (m *LedgerAccountMutation) Where(ps ...predicate.LedgerAccount) { m.predicates = append(m.predicates, ps...) @@ -82970,13 +83027,16 @@ func (m *LedgerAccountMutation) ResetField(name string) error { // AddedEdges returns all edge names that were set/added in this mutation. func (m *LedgerAccountMutation) AddedEdges() []string { - edges := make([]string, 0, 2) + edges := make([]string, 0, 3) if m.sub_accounts != nil { edges = append(edges, ledgeraccount.EdgeSubAccounts) } if m.sub_account_routes != nil { edges = append(edges, ledgeraccount.EdgeSubAccountRoutes) } + if m.customer_accounts != nil { + edges = append(edges, ledgeraccount.EdgeCustomerAccounts) + } return edges } @@ -82996,19 +83056,28 @@ func (m *LedgerAccountMutation) AddedIDs(name string) []ent.Value { ids = append(ids, id) } return ids + case ledgeraccount.EdgeCustomerAccounts: + ids := make([]ent.Value, 0, len(m.customer_accounts)) + for id := range m.customer_accounts { + ids = append(ids, id) + } + return ids } return nil } // RemovedEdges returns all edge names that were removed in this mutation. func (m *LedgerAccountMutation) RemovedEdges() []string { - edges := make([]string, 0, 2) + edges := make([]string, 0, 3) if m.removedsub_accounts != nil { edges = append(edges, ledgeraccount.EdgeSubAccounts) } if m.removedsub_account_routes != nil { edges = append(edges, ledgeraccount.EdgeSubAccountRoutes) } + if m.removedcustomer_accounts != nil { + edges = append(edges, ledgeraccount.EdgeCustomerAccounts) + } return edges } @@ -83028,19 +83097,28 @@ func (m *LedgerAccountMutation) RemovedIDs(name string) []ent.Value { ids = append(ids, id) } return ids + case ledgeraccount.EdgeCustomerAccounts: + ids := make([]ent.Value, 0, len(m.removedcustomer_accounts)) + for id := range m.removedcustomer_accounts { + ids = append(ids, id) + } + return ids } return nil } // ClearedEdges returns all edge names that were cleared in this mutation. func (m *LedgerAccountMutation) ClearedEdges() []string { - edges := make([]string, 0, 2) + edges := make([]string, 0, 3) if m.clearedsub_accounts { edges = append(edges, ledgeraccount.EdgeSubAccounts) } if m.clearedsub_account_routes { edges = append(edges, ledgeraccount.EdgeSubAccountRoutes) } + if m.clearedcustomer_accounts { + edges = append(edges, ledgeraccount.EdgeCustomerAccounts) + } return edges } @@ -83052,6 +83130,8 @@ func (m *LedgerAccountMutation) EdgeCleared(name string) bool { return m.clearedsub_accounts case ledgeraccount.EdgeSubAccountRoutes: return m.clearedsub_account_routes + case ledgeraccount.EdgeCustomerAccounts: + return m.clearedcustomer_accounts } return false } @@ -83074,6 +83154,9 @@ func (m *LedgerAccountMutation) ResetEdge(name string) error { case ledgeraccount.EdgeSubAccountRoutes: m.ResetSubAccountRoutes() return nil + case ledgeraccount.EdgeCustomerAccounts: + m.ResetCustomerAccounts() + return nil } return fmt.Errorf("unknown LedgerAccount edge %s", name) } @@ -83081,36 +83164,51 @@ func (m *LedgerAccountMutation) ResetEdge(name string) error { // LedgerBreakageRecordMutation represents an operation that mutates the LedgerBreakageRecord nodes in the graph. type LedgerBreakageRecordMutation struct { config - op Op - typ string - id *string - namespace *string - annotations *models.Annotations - created_at *time.Time - updated_at *time.Time - deleted_at *time.Time - kind *ledger.BreakageKind - amount *alpacadecimal.Decimal - customer_id *string - currency *currencyx.Code - credit_priority *int - addcredit_priority *int - expires_at *time.Time - source_kind *ledger.BreakageSourceKind - source_charge_id *string - source_transaction_group_id *string - source_transaction_id *string - source_entry_id *string - breakage_transaction_group_id *string - breakage_transaction_id *string - fbo_sub_account_id *string - breakage_sub_account_id *string - plan_id *string - release_id *string - clearedFields map[string]struct{} - done bool - oldValue func(context.Context) (*LedgerBreakageRecord, error) - predicates []predicate.LedgerBreakageRecord + op Op + typ string + id *string + namespace *string + annotations *models.Annotations + created_at *time.Time + updated_at *time.Time + deleted_at *time.Time + kind *ledger.BreakageKind + amount *alpacadecimal.Decimal + customer_id *string + currency *currencyx.Code + credit_priority *int + addcredit_priority *int + expires_at *time.Time + source_kind *ledger.BreakageSourceKind + source_charge_id *string + clearedFields map[string]struct{} + source_transaction_group *string + clearedsource_transaction_group bool + source_transaction *string + clearedsource_transaction bool + source_entry *string + clearedsource_entry bool + breakage_transaction_group *string + clearedbreakage_transaction_group bool + breakage_transaction *string + clearedbreakage_transaction bool + fbo_sub_account *string + clearedfbo_sub_account bool + breakage_sub_account *string + clearedbreakage_sub_account bool + planned_releases map[string]struct{} + removedplanned_releases map[string]struct{} + clearedplanned_releases bool + release_reopens map[string]struct{} + removedrelease_reopens map[string]struct{} + clearedrelease_reopens bool + plan *string + clearedplan bool + release *string + clearedrelease bool + done bool + oldValue func(context.Context) (*LedgerBreakageRecord, error) + predicates []predicate.LedgerBreakageRecord } var _ ent.Mutation = (*LedgerBreakageRecordMutation)(nil) @@ -83746,12 +83844,12 @@ func (m *LedgerBreakageRecordMutation) ResetSourceChargeID() { // SetSourceTransactionGroupID sets the "source_transaction_group_id" field. func (m *LedgerBreakageRecordMutation) SetSourceTransactionGroupID(s string) { - m.source_transaction_group_id = &s + m.source_transaction_group = &s } // SourceTransactionGroupID returns the value of the "source_transaction_group_id" field in the mutation. func (m *LedgerBreakageRecordMutation) SourceTransactionGroupID() (r string, exists bool) { - v := m.source_transaction_group_id + v := m.source_transaction_group if v == nil { return } @@ -83777,7 +83875,7 @@ func (m *LedgerBreakageRecordMutation) OldSourceTransactionGroupID(ctx context.C // ClearSourceTransactionGroupID clears the value of the "source_transaction_group_id" field. func (m *LedgerBreakageRecordMutation) ClearSourceTransactionGroupID() { - m.source_transaction_group_id = nil + m.source_transaction_group = nil m.clearedFields[ledgerbreakagerecord.FieldSourceTransactionGroupID] = struct{}{} } @@ -83789,18 +83887,18 @@ func (m *LedgerBreakageRecordMutation) SourceTransactionGroupIDCleared() bool { // ResetSourceTransactionGroupID resets all changes to the "source_transaction_group_id" field. func (m *LedgerBreakageRecordMutation) ResetSourceTransactionGroupID() { - m.source_transaction_group_id = nil + m.source_transaction_group = nil delete(m.clearedFields, ledgerbreakagerecord.FieldSourceTransactionGroupID) } // SetSourceTransactionID sets the "source_transaction_id" field. func (m *LedgerBreakageRecordMutation) SetSourceTransactionID(s string) { - m.source_transaction_id = &s + m.source_transaction = &s } // SourceTransactionID returns the value of the "source_transaction_id" field in the mutation. func (m *LedgerBreakageRecordMutation) SourceTransactionID() (r string, exists bool) { - v := m.source_transaction_id + v := m.source_transaction if v == nil { return } @@ -83826,7 +83924,7 @@ func (m *LedgerBreakageRecordMutation) OldSourceTransactionID(ctx context.Contex // ClearSourceTransactionID clears the value of the "source_transaction_id" field. func (m *LedgerBreakageRecordMutation) ClearSourceTransactionID() { - m.source_transaction_id = nil + m.source_transaction = nil m.clearedFields[ledgerbreakagerecord.FieldSourceTransactionID] = struct{}{} } @@ -83838,18 +83936,18 @@ func (m *LedgerBreakageRecordMutation) SourceTransactionIDCleared() bool { // ResetSourceTransactionID resets all changes to the "source_transaction_id" field. func (m *LedgerBreakageRecordMutation) ResetSourceTransactionID() { - m.source_transaction_id = nil + m.source_transaction = nil delete(m.clearedFields, ledgerbreakagerecord.FieldSourceTransactionID) } // SetSourceEntryID sets the "source_entry_id" field. func (m *LedgerBreakageRecordMutation) SetSourceEntryID(s string) { - m.source_entry_id = &s + m.source_entry = &s } // SourceEntryID returns the value of the "source_entry_id" field in the mutation. func (m *LedgerBreakageRecordMutation) SourceEntryID() (r string, exists bool) { - v := m.source_entry_id + v := m.source_entry if v == nil { return } @@ -83875,7 +83973,7 @@ func (m *LedgerBreakageRecordMutation) OldSourceEntryID(ctx context.Context) (v // ClearSourceEntryID clears the value of the "source_entry_id" field. func (m *LedgerBreakageRecordMutation) ClearSourceEntryID() { - m.source_entry_id = nil + m.source_entry = nil m.clearedFields[ledgerbreakagerecord.FieldSourceEntryID] = struct{}{} } @@ -83887,18 +83985,18 @@ func (m *LedgerBreakageRecordMutation) SourceEntryIDCleared() bool { // ResetSourceEntryID resets all changes to the "source_entry_id" field. func (m *LedgerBreakageRecordMutation) ResetSourceEntryID() { - m.source_entry_id = nil + m.source_entry = nil delete(m.clearedFields, ledgerbreakagerecord.FieldSourceEntryID) } // SetBreakageTransactionGroupID sets the "breakage_transaction_group_id" field. func (m *LedgerBreakageRecordMutation) SetBreakageTransactionGroupID(s string) { - m.breakage_transaction_group_id = &s + m.breakage_transaction_group = &s } // BreakageTransactionGroupID returns the value of the "breakage_transaction_group_id" field in the mutation. func (m *LedgerBreakageRecordMutation) BreakageTransactionGroupID() (r string, exists bool) { - v := m.breakage_transaction_group_id + v := m.breakage_transaction_group if v == nil { return } @@ -83924,17 +84022,17 @@ func (m *LedgerBreakageRecordMutation) OldBreakageTransactionGroupID(ctx context // ResetBreakageTransactionGroupID resets all changes to the "breakage_transaction_group_id" field. func (m *LedgerBreakageRecordMutation) ResetBreakageTransactionGroupID() { - m.breakage_transaction_group_id = nil + m.breakage_transaction_group = nil } // SetBreakageTransactionID sets the "breakage_transaction_id" field. func (m *LedgerBreakageRecordMutation) SetBreakageTransactionID(s string) { - m.breakage_transaction_id = &s + m.breakage_transaction = &s } // BreakageTransactionID returns the value of the "breakage_transaction_id" field in the mutation. func (m *LedgerBreakageRecordMutation) BreakageTransactionID() (r string, exists bool) { - v := m.breakage_transaction_id + v := m.breakage_transaction if v == nil { return } @@ -83960,17 +84058,17 @@ func (m *LedgerBreakageRecordMutation) OldBreakageTransactionID(ctx context.Cont // ResetBreakageTransactionID resets all changes to the "breakage_transaction_id" field. func (m *LedgerBreakageRecordMutation) ResetBreakageTransactionID() { - m.breakage_transaction_id = nil + m.breakage_transaction = nil } // SetFboSubAccountID sets the "fbo_sub_account_id" field. func (m *LedgerBreakageRecordMutation) SetFboSubAccountID(s string) { - m.fbo_sub_account_id = &s + m.fbo_sub_account = &s } // FboSubAccountID returns the value of the "fbo_sub_account_id" field in the mutation. func (m *LedgerBreakageRecordMutation) FboSubAccountID() (r string, exists bool) { - v := m.fbo_sub_account_id + v := m.fbo_sub_account if v == nil { return } @@ -83996,17 +84094,17 @@ func (m *LedgerBreakageRecordMutation) OldFboSubAccountID(ctx context.Context) ( // ResetFboSubAccountID resets all changes to the "fbo_sub_account_id" field. func (m *LedgerBreakageRecordMutation) ResetFboSubAccountID() { - m.fbo_sub_account_id = nil + m.fbo_sub_account = nil } // SetBreakageSubAccountID sets the "breakage_sub_account_id" field. func (m *LedgerBreakageRecordMutation) SetBreakageSubAccountID(s string) { - m.breakage_sub_account_id = &s + m.breakage_sub_account = &s } // BreakageSubAccountID returns the value of the "breakage_sub_account_id" field in the mutation. func (m *LedgerBreakageRecordMutation) BreakageSubAccountID() (r string, exists bool) { - v := m.breakage_sub_account_id + v := m.breakage_sub_account if v == nil { return } @@ -84032,17 +84130,17 @@ func (m *LedgerBreakageRecordMutation) OldBreakageSubAccountID(ctx context.Conte // ResetBreakageSubAccountID resets all changes to the "breakage_sub_account_id" field. func (m *LedgerBreakageRecordMutation) ResetBreakageSubAccountID() { - m.breakage_sub_account_id = nil + m.breakage_sub_account = nil } // SetPlanID sets the "plan_id" field. func (m *LedgerBreakageRecordMutation) SetPlanID(s string) { - m.plan_id = &s + m.plan = &s } // PlanID returns the value of the "plan_id" field in the mutation. func (m *LedgerBreakageRecordMutation) PlanID() (r string, exists bool) { - v := m.plan_id + v := m.plan if v == nil { return } @@ -84068,7 +84166,7 @@ func (m *LedgerBreakageRecordMutation) OldPlanID(ctx context.Context) (v *string // ClearPlanID clears the value of the "plan_id" field. func (m *LedgerBreakageRecordMutation) ClearPlanID() { - m.plan_id = nil + m.plan = nil m.clearedFields[ledgerbreakagerecord.FieldPlanID] = struct{}{} } @@ -84080,18 +84178,18 @@ func (m *LedgerBreakageRecordMutation) PlanIDCleared() bool { // ResetPlanID resets all changes to the "plan_id" field. func (m *LedgerBreakageRecordMutation) ResetPlanID() { - m.plan_id = nil + m.plan = nil delete(m.clearedFields, ledgerbreakagerecord.FieldPlanID) } // SetReleaseID sets the "release_id" field. func (m *LedgerBreakageRecordMutation) SetReleaseID(s string) { - m.release_id = &s + m.release = &s } // ReleaseID returns the value of the "release_id" field in the mutation. func (m *LedgerBreakageRecordMutation) ReleaseID() (r string, exists bool) { - v := m.release_id + v := m.release if v == nil { return } @@ -84117,7 +84215,7 @@ func (m *LedgerBreakageRecordMutation) OldReleaseID(ctx context.Context) (v *str // ClearReleaseID clears the value of the "release_id" field. func (m *LedgerBreakageRecordMutation) ClearReleaseID() { - m.release_id = nil + m.release = nil m.clearedFields[ledgerbreakagerecord.FieldReleaseID] = struct{}{} } @@ -84129,10 +84227,361 @@ func (m *LedgerBreakageRecordMutation) ReleaseIDCleared() bool { // ResetReleaseID resets all changes to the "release_id" field. func (m *LedgerBreakageRecordMutation) ResetReleaseID() { - m.release_id = nil + m.release = nil delete(m.clearedFields, ledgerbreakagerecord.FieldReleaseID) } +// ClearSourceTransactionGroup clears the "source_transaction_group" edge to the LedgerTransactionGroup entity. +func (m *LedgerBreakageRecordMutation) ClearSourceTransactionGroup() { + m.clearedsource_transaction_group = true + m.clearedFields[ledgerbreakagerecord.FieldSourceTransactionGroupID] = struct{}{} +} + +// SourceTransactionGroupCleared reports if the "source_transaction_group" edge to the LedgerTransactionGroup entity was cleared. +func (m *LedgerBreakageRecordMutation) SourceTransactionGroupCleared() bool { + return m.SourceTransactionGroupIDCleared() || m.clearedsource_transaction_group +} + +// SourceTransactionGroupIDs returns the "source_transaction_group" edge IDs in the mutation. +// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use +// SourceTransactionGroupID instead. It exists only for internal usage by the builders. +func (m *LedgerBreakageRecordMutation) SourceTransactionGroupIDs() (ids []string) { + if id := m.source_transaction_group; id != nil { + ids = append(ids, *id) + } + return +} + +// ResetSourceTransactionGroup resets all changes to the "source_transaction_group" edge. +func (m *LedgerBreakageRecordMutation) ResetSourceTransactionGroup() { + m.source_transaction_group = nil + m.clearedsource_transaction_group = false +} + +// ClearSourceTransaction clears the "source_transaction" edge to the LedgerTransaction entity. +func (m *LedgerBreakageRecordMutation) ClearSourceTransaction() { + m.clearedsource_transaction = true + m.clearedFields[ledgerbreakagerecord.FieldSourceTransactionID] = struct{}{} +} + +// SourceTransactionCleared reports if the "source_transaction" edge to the LedgerTransaction entity was cleared. +func (m *LedgerBreakageRecordMutation) SourceTransactionCleared() bool { + return m.SourceTransactionIDCleared() || m.clearedsource_transaction +} + +// SourceTransactionIDs returns the "source_transaction" edge IDs in the mutation. +// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use +// SourceTransactionID instead. It exists only for internal usage by the builders. +func (m *LedgerBreakageRecordMutation) SourceTransactionIDs() (ids []string) { + if id := m.source_transaction; id != nil { + ids = append(ids, *id) + } + return +} + +// ResetSourceTransaction resets all changes to the "source_transaction" edge. +func (m *LedgerBreakageRecordMutation) ResetSourceTransaction() { + m.source_transaction = nil + m.clearedsource_transaction = false +} + +// ClearSourceEntry clears the "source_entry" edge to the LedgerEntry entity. +func (m *LedgerBreakageRecordMutation) ClearSourceEntry() { + m.clearedsource_entry = true + m.clearedFields[ledgerbreakagerecord.FieldSourceEntryID] = struct{}{} +} + +// SourceEntryCleared reports if the "source_entry" edge to the LedgerEntry entity was cleared. +func (m *LedgerBreakageRecordMutation) SourceEntryCleared() bool { + return m.SourceEntryIDCleared() || m.clearedsource_entry +} + +// SourceEntryIDs returns the "source_entry" edge IDs in the mutation. +// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use +// SourceEntryID instead. It exists only for internal usage by the builders. +func (m *LedgerBreakageRecordMutation) SourceEntryIDs() (ids []string) { + if id := m.source_entry; id != nil { + ids = append(ids, *id) + } + return +} + +// ResetSourceEntry resets all changes to the "source_entry" edge. +func (m *LedgerBreakageRecordMutation) ResetSourceEntry() { + m.source_entry = nil + m.clearedsource_entry = false +} + +// ClearBreakageTransactionGroup clears the "breakage_transaction_group" edge to the LedgerTransactionGroup entity. +func (m *LedgerBreakageRecordMutation) ClearBreakageTransactionGroup() { + m.clearedbreakage_transaction_group = true + m.clearedFields[ledgerbreakagerecord.FieldBreakageTransactionGroupID] = struct{}{} +} + +// BreakageTransactionGroupCleared reports if the "breakage_transaction_group" edge to the LedgerTransactionGroup entity was cleared. +func (m *LedgerBreakageRecordMutation) BreakageTransactionGroupCleared() bool { + return m.clearedbreakage_transaction_group +} + +// BreakageTransactionGroupIDs returns the "breakage_transaction_group" edge IDs in the mutation. +// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use +// BreakageTransactionGroupID instead. It exists only for internal usage by the builders. +func (m *LedgerBreakageRecordMutation) BreakageTransactionGroupIDs() (ids []string) { + if id := m.breakage_transaction_group; id != nil { + ids = append(ids, *id) + } + return +} + +// ResetBreakageTransactionGroup resets all changes to the "breakage_transaction_group" edge. +func (m *LedgerBreakageRecordMutation) ResetBreakageTransactionGroup() { + m.breakage_transaction_group = nil + m.clearedbreakage_transaction_group = false +} + +// ClearBreakageTransaction clears the "breakage_transaction" edge to the LedgerTransaction entity. +func (m *LedgerBreakageRecordMutation) ClearBreakageTransaction() { + m.clearedbreakage_transaction = true + m.clearedFields[ledgerbreakagerecord.FieldBreakageTransactionID] = struct{}{} +} + +// BreakageTransactionCleared reports if the "breakage_transaction" edge to the LedgerTransaction entity was cleared. +func (m *LedgerBreakageRecordMutation) BreakageTransactionCleared() bool { + return m.clearedbreakage_transaction +} + +// BreakageTransactionIDs returns the "breakage_transaction" edge IDs in the mutation. +// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use +// BreakageTransactionID instead. It exists only for internal usage by the builders. +func (m *LedgerBreakageRecordMutation) BreakageTransactionIDs() (ids []string) { + if id := m.breakage_transaction; id != nil { + ids = append(ids, *id) + } + return +} + +// ResetBreakageTransaction resets all changes to the "breakage_transaction" edge. +func (m *LedgerBreakageRecordMutation) ResetBreakageTransaction() { + m.breakage_transaction = nil + m.clearedbreakage_transaction = false +} + +// ClearFboSubAccount clears the "fbo_sub_account" edge to the LedgerSubAccount entity. +func (m *LedgerBreakageRecordMutation) ClearFboSubAccount() { + m.clearedfbo_sub_account = true + m.clearedFields[ledgerbreakagerecord.FieldFboSubAccountID] = struct{}{} +} + +// FboSubAccountCleared reports if the "fbo_sub_account" edge to the LedgerSubAccount entity was cleared. +func (m *LedgerBreakageRecordMutation) FboSubAccountCleared() bool { + return m.clearedfbo_sub_account +} + +// FboSubAccountIDs returns the "fbo_sub_account" edge IDs in the mutation. +// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use +// FboSubAccountID instead. It exists only for internal usage by the builders. +func (m *LedgerBreakageRecordMutation) FboSubAccountIDs() (ids []string) { + if id := m.fbo_sub_account; id != nil { + ids = append(ids, *id) + } + return +} + +// ResetFboSubAccount resets all changes to the "fbo_sub_account" edge. +func (m *LedgerBreakageRecordMutation) ResetFboSubAccount() { + m.fbo_sub_account = nil + m.clearedfbo_sub_account = false +} + +// ClearBreakageSubAccount clears the "breakage_sub_account" edge to the LedgerSubAccount entity. +func (m *LedgerBreakageRecordMutation) ClearBreakageSubAccount() { + m.clearedbreakage_sub_account = true + m.clearedFields[ledgerbreakagerecord.FieldBreakageSubAccountID] = struct{}{} +} + +// BreakageSubAccountCleared reports if the "breakage_sub_account" edge to the LedgerSubAccount entity was cleared. +func (m *LedgerBreakageRecordMutation) BreakageSubAccountCleared() bool { + return m.clearedbreakage_sub_account +} + +// BreakageSubAccountIDs returns the "breakage_sub_account" edge IDs in the mutation. +// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use +// BreakageSubAccountID instead. It exists only for internal usage by the builders. +func (m *LedgerBreakageRecordMutation) BreakageSubAccountIDs() (ids []string) { + if id := m.breakage_sub_account; id != nil { + ids = append(ids, *id) + } + return +} + +// ResetBreakageSubAccount resets all changes to the "breakage_sub_account" edge. +func (m *LedgerBreakageRecordMutation) ResetBreakageSubAccount() { + m.breakage_sub_account = nil + m.clearedbreakage_sub_account = false +} + +// AddPlannedReleaseIDs adds the "planned_releases" edge to the LedgerBreakageRecord entity by ids. +func (m *LedgerBreakageRecordMutation) AddPlannedReleaseIDs(ids ...string) { + if m.planned_releases == nil { + m.planned_releases = make(map[string]struct{}) + } + for i := range ids { + m.planned_releases[ids[i]] = struct{}{} + } +} + +// ClearPlannedReleases clears the "planned_releases" edge to the LedgerBreakageRecord entity. +func (m *LedgerBreakageRecordMutation) ClearPlannedReleases() { + m.clearedplanned_releases = true +} + +// PlannedReleasesCleared reports if the "planned_releases" edge to the LedgerBreakageRecord entity was cleared. +func (m *LedgerBreakageRecordMutation) PlannedReleasesCleared() bool { + return m.clearedplanned_releases +} + +// RemovePlannedReleaseIDs removes the "planned_releases" edge to the LedgerBreakageRecord entity by IDs. +func (m *LedgerBreakageRecordMutation) RemovePlannedReleaseIDs(ids ...string) { + if m.removedplanned_releases == nil { + m.removedplanned_releases = make(map[string]struct{}) + } + for i := range ids { + delete(m.planned_releases, ids[i]) + m.removedplanned_releases[ids[i]] = struct{}{} + } +} + +// RemovedPlannedReleases returns the removed IDs of the "planned_releases" edge to the LedgerBreakageRecord entity. +func (m *LedgerBreakageRecordMutation) RemovedPlannedReleasesIDs() (ids []string) { + for id := range m.removedplanned_releases { + ids = append(ids, id) + } + return +} + +// PlannedReleasesIDs returns the "planned_releases" edge IDs in the mutation. +func (m *LedgerBreakageRecordMutation) PlannedReleasesIDs() (ids []string) { + for id := range m.planned_releases { + ids = append(ids, id) + } + return +} + +// ResetPlannedReleases resets all changes to the "planned_releases" edge. +func (m *LedgerBreakageRecordMutation) ResetPlannedReleases() { + m.planned_releases = nil + m.clearedplanned_releases = false + m.removedplanned_releases = nil +} + +// AddReleaseReopenIDs adds the "release_reopens" edge to the LedgerBreakageRecord entity by ids. +func (m *LedgerBreakageRecordMutation) AddReleaseReopenIDs(ids ...string) { + if m.release_reopens == nil { + m.release_reopens = make(map[string]struct{}) + } + for i := range ids { + m.release_reopens[ids[i]] = struct{}{} + } +} + +// ClearReleaseReopens clears the "release_reopens" edge to the LedgerBreakageRecord entity. +func (m *LedgerBreakageRecordMutation) ClearReleaseReopens() { + m.clearedrelease_reopens = true +} + +// ReleaseReopensCleared reports if the "release_reopens" edge to the LedgerBreakageRecord entity was cleared. +func (m *LedgerBreakageRecordMutation) ReleaseReopensCleared() bool { + return m.clearedrelease_reopens +} + +// RemoveReleaseReopenIDs removes the "release_reopens" edge to the LedgerBreakageRecord entity by IDs. +func (m *LedgerBreakageRecordMutation) RemoveReleaseReopenIDs(ids ...string) { + if m.removedrelease_reopens == nil { + m.removedrelease_reopens = make(map[string]struct{}) + } + for i := range ids { + delete(m.release_reopens, ids[i]) + m.removedrelease_reopens[ids[i]] = struct{}{} + } +} + +// RemovedReleaseReopens returns the removed IDs of the "release_reopens" edge to the LedgerBreakageRecord entity. +func (m *LedgerBreakageRecordMutation) RemovedReleaseReopensIDs() (ids []string) { + for id := range m.removedrelease_reopens { + ids = append(ids, id) + } + return +} + +// ReleaseReopensIDs returns the "release_reopens" edge IDs in the mutation. +func (m *LedgerBreakageRecordMutation) ReleaseReopensIDs() (ids []string) { + for id := range m.release_reopens { + ids = append(ids, id) + } + return +} + +// ResetReleaseReopens resets all changes to the "release_reopens" edge. +func (m *LedgerBreakageRecordMutation) ResetReleaseReopens() { + m.release_reopens = nil + m.clearedrelease_reopens = false + m.removedrelease_reopens = nil +} + +// ClearPlan clears the "plan" edge to the LedgerBreakageRecord entity. +func (m *LedgerBreakageRecordMutation) ClearPlan() { + m.clearedplan = true + m.clearedFields[ledgerbreakagerecord.FieldPlanID] = struct{}{} +} + +// PlanCleared reports if the "plan" edge to the LedgerBreakageRecord entity was cleared. +func (m *LedgerBreakageRecordMutation) PlanCleared() bool { + return m.PlanIDCleared() || m.clearedplan +} + +// PlanIDs returns the "plan" edge IDs in the mutation. +// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use +// PlanID instead. It exists only for internal usage by the builders. +func (m *LedgerBreakageRecordMutation) PlanIDs() (ids []string) { + if id := m.plan; id != nil { + ids = append(ids, *id) + } + return +} + +// ResetPlan resets all changes to the "plan" edge. +func (m *LedgerBreakageRecordMutation) ResetPlan() { + m.plan = nil + m.clearedplan = false +} + +// ClearRelease clears the "release" edge to the LedgerBreakageRecord entity. +func (m *LedgerBreakageRecordMutation) ClearRelease() { + m.clearedrelease = true + m.clearedFields[ledgerbreakagerecord.FieldReleaseID] = struct{}{} +} + +// ReleaseCleared reports if the "release" edge to the LedgerBreakageRecord entity was cleared. +func (m *LedgerBreakageRecordMutation) ReleaseCleared() bool { + return m.ReleaseIDCleared() || m.clearedrelease +} + +// ReleaseIDs returns the "release" edge IDs in the mutation. +// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use +// ReleaseID instead. It exists only for internal usage by the builders. +func (m *LedgerBreakageRecordMutation) ReleaseIDs() (ids []string) { + if id := m.release; id != nil { + ids = append(ids, *id) + } + return +} + +// ResetRelease resets all changes to the "release" edge. +func (m *LedgerBreakageRecordMutation) ResetRelease() { + m.release = nil + m.clearedrelease = false +} + // Where appends a list predicates to the LedgerBreakageRecordMutation builder. func (m *LedgerBreakageRecordMutation) Where(ps ...predicate.LedgerBreakageRecord) { m.predicates = append(m.predicates, ps...) @@ -84207,31 +84656,31 @@ func (m *LedgerBreakageRecordMutation) Fields() []string { if m.source_charge_id != nil { fields = append(fields, ledgerbreakagerecord.FieldSourceChargeID) } - if m.source_transaction_group_id != nil { + if m.source_transaction_group != nil { fields = append(fields, ledgerbreakagerecord.FieldSourceTransactionGroupID) } - if m.source_transaction_id != nil { + if m.source_transaction != nil { fields = append(fields, ledgerbreakagerecord.FieldSourceTransactionID) } - if m.source_entry_id != nil { + if m.source_entry != nil { fields = append(fields, ledgerbreakagerecord.FieldSourceEntryID) } - if m.breakage_transaction_group_id != nil { + if m.breakage_transaction_group != nil { fields = append(fields, ledgerbreakagerecord.FieldBreakageTransactionGroupID) } - if m.breakage_transaction_id != nil { + if m.breakage_transaction != nil { fields = append(fields, ledgerbreakagerecord.FieldBreakageTransactionID) } - if m.fbo_sub_account_id != nil { + if m.fbo_sub_account != nil { fields = append(fields, ledgerbreakagerecord.FieldFboSubAccountID) } - if m.breakage_sub_account_id != nil { + if m.breakage_sub_account != nil { fields = append(fields, ledgerbreakagerecord.FieldBreakageSubAccountID) } - if m.plan_id != nil { + if m.plan != nil { fields = append(fields, ledgerbreakagerecord.FieldPlanID) } - if m.release_id != nil { + if m.release != nil { fields = append(fields, ledgerbreakagerecord.FieldReleaseID) } return fields @@ -84689,69 +85138,294 @@ func (m *LedgerBreakageRecordMutation) ResetField(name string) error { // AddedEdges returns all edge names that were set/added in this mutation. func (m *LedgerBreakageRecordMutation) AddedEdges() []string { - edges := make([]string, 0, 0) + edges := make([]string, 0, 11) + if m.source_transaction_group != nil { + edges = append(edges, ledgerbreakagerecord.EdgeSourceTransactionGroup) + } + if m.source_transaction != nil { + edges = append(edges, ledgerbreakagerecord.EdgeSourceTransaction) + } + if m.source_entry != nil { + edges = append(edges, ledgerbreakagerecord.EdgeSourceEntry) + } + if m.breakage_transaction_group != nil { + edges = append(edges, ledgerbreakagerecord.EdgeBreakageTransactionGroup) + } + if m.breakage_transaction != nil { + edges = append(edges, ledgerbreakagerecord.EdgeBreakageTransaction) + } + if m.fbo_sub_account != nil { + edges = append(edges, ledgerbreakagerecord.EdgeFboSubAccount) + } + if m.breakage_sub_account != nil { + edges = append(edges, ledgerbreakagerecord.EdgeBreakageSubAccount) + } + if m.planned_releases != nil { + edges = append(edges, ledgerbreakagerecord.EdgePlannedReleases) + } + if m.release_reopens != nil { + edges = append(edges, ledgerbreakagerecord.EdgeReleaseReopens) + } + if m.plan != nil { + edges = append(edges, ledgerbreakagerecord.EdgePlan) + } + if m.release != nil { + edges = append(edges, ledgerbreakagerecord.EdgeRelease) + } return edges } // AddedIDs returns all IDs (to other nodes) that were added for the given edge // name in this mutation. func (m *LedgerBreakageRecordMutation) AddedIDs(name string) []ent.Value { + switch name { + case ledgerbreakagerecord.EdgeSourceTransactionGroup: + if id := m.source_transaction_group; id != nil { + return []ent.Value{*id} + } + case ledgerbreakagerecord.EdgeSourceTransaction: + if id := m.source_transaction; id != nil { + return []ent.Value{*id} + } + case ledgerbreakagerecord.EdgeSourceEntry: + if id := m.source_entry; id != nil { + return []ent.Value{*id} + } + case ledgerbreakagerecord.EdgeBreakageTransactionGroup: + if id := m.breakage_transaction_group; id != nil { + return []ent.Value{*id} + } + case ledgerbreakagerecord.EdgeBreakageTransaction: + if id := m.breakage_transaction; id != nil { + return []ent.Value{*id} + } + case ledgerbreakagerecord.EdgeFboSubAccount: + if id := m.fbo_sub_account; id != nil { + return []ent.Value{*id} + } + case ledgerbreakagerecord.EdgeBreakageSubAccount: + if id := m.breakage_sub_account; id != nil { + return []ent.Value{*id} + } + case ledgerbreakagerecord.EdgePlannedReleases: + ids := make([]ent.Value, 0, len(m.planned_releases)) + for id := range m.planned_releases { + ids = append(ids, id) + } + return ids + case ledgerbreakagerecord.EdgeReleaseReopens: + ids := make([]ent.Value, 0, len(m.release_reopens)) + for id := range m.release_reopens { + ids = append(ids, id) + } + return ids + case ledgerbreakagerecord.EdgePlan: + if id := m.plan; id != nil { + return []ent.Value{*id} + } + case ledgerbreakagerecord.EdgeRelease: + if id := m.release; id != nil { + return []ent.Value{*id} + } + } return nil } // RemovedEdges returns all edge names that were removed in this mutation. func (m *LedgerBreakageRecordMutation) RemovedEdges() []string { - edges := make([]string, 0, 0) + edges := make([]string, 0, 11) + if m.removedplanned_releases != nil { + edges = append(edges, ledgerbreakagerecord.EdgePlannedReleases) + } + if m.removedrelease_reopens != nil { + edges = append(edges, ledgerbreakagerecord.EdgeReleaseReopens) + } return edges } // RemovedIDs returns all IDs (to other nodes) that were removed for the edge with // the given name in this mutation. func (m *LedgerBreakageRecordMutation) RemovedIDs(name string) []ent.Value { + switch name { + case ledgerbreakagerecord.EdgePlannedReleases: + ids := make([]ent.Value, 0, len(m.removedplanned_releases)) + for id := range m.removedplanned_releases { + ids = append(ids, id) + } + return ids + case ledgerbreakagerecord.EdgeReleaseReopens: + ids := make([]ent.Value, 0, len(m.removedrelease_reopens)) + for id := range m.removedrelease_reopens { + ids = append(ids, id) + } + return ids + } return nil } // ClearedEdges returns all edge names that were cleared in this mutation. func (m *LedgerBreakageRecordMutation) ClearedEdges() []string { - edges := make([]string, 0, 0) + edges := make([]string, 0, 11) + if m.clearedsource_transaction_group { + edges = append(edges, ledgerbreakagerecord.EdgeSourceTransactionGroup) + } + if m.clearedsource_transaction { + edges = append(edges, ledgerbreakagerecord.EdgeSourceTransaction) + } + if m.clearedsource_entry { + edges = append(edges, ledgerbreakagerecord.EdgeSourceEntry) + } + if m.clearedbreakage_transaction_group { + edges = append(edges, ledgerbreakagerecord.EdgeBreakageTransactionGroup) + } + if m.clearedbreakage_transaction { + edges = append(edges, ledgerbreakagerecord.EdgeBreakageTransaction) + } + if m.clearedfbo_sub_account { + edges = append(edges, ledgerbreakagerecord.EdgeFboSubAccount) + } + if m.clearedbreakage_sub_account { + edges = append(edges, ledgerbreakagerecord.EdgeBreakageSubAccount) + } + if m.clearedplanned_releases { + edges = append(edges, ledgerbreakagerecord.EdgePlannedReleases) + } + if m.clearedrelease_reopens { + edges = append(edges, ledgerbreakagerecord.EdgeReleaseReopens) + } + if m.clearedplan { + edges = append(edges, ledgerbreakagerecord.EdgePlan) + } + if m.clearedrelease { + edges = append(edges, ledgerbreakagerecord.EdgeRelease) + } return edges } // EdgeCleared returns a boolean which indicates if the edge with the given name // was cleared in this mutation. func (m *LedgerBreakageRecordMutation) EdgeCleared(name string) bool { + switch name { + case ledgerbreakagerecord.EdgeSourceTransactionGroup: + return m.clearedsource_transaction_group + case ledgerbreakagerecord.EdgeSourceTransaction: + return m.clearedsource_transaction + case ledgerbreakagerecord.EdgeSourceEntry: + return m.clearedsource_entry + case ledgerbreakagerecord.EdgeBreakageTransactionGroup: + return m.clearedbreakage_transaction_group + case ledgerbreakagerecord.EdgeBreakageTransaction: + return m.clearedbreakage_transaction + case ledgerbreakagerecord.EdgeFboSubAccount: + return m.clearedfbo_sub_account + case ledgerbreakagerecord.EdgeBreakageSubAccount: + return m.clearedbreakage_sub_account + case ledgerbreakagerecord.EdgePlannedReleases: + return m.clearedplanned_releases + case ledgerbreakagerecord.EdgeReleaseReopens: + return m.clearedrelease_reopens + case ledgerbreakagerecord.EdgePlan: + return m.clearedplan + case ledgerbreakagerecord.EdgeRelease: + return m.clearedrelease + } 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 *LedgerBreakageRecordMutation) ClearEdge(name string) error { + switch name { + case ledgerbreakagerecord.EdgeSourceTransactionGroup: + m.ClearSourceTransactionGroup() + return nil + case ledgerbreakagerecord.EdgeSourceTransaction: + m.ClearSourceTransaction() + return nil + case ledgerbreakagerecord.EdgeSourceEntry: + m.ClearSourceEntry() + return nil + case ledgerbreakagerecord.EdgeBreakageTransactionGroup: + m.ClearBreakageTransactionGroup() + return nil + case ledgerbreakagerecord.EdgeBreakageTransaction: + m.ClearBreakageTransaction() + return nil + case ledgerbreakagerecord.EdgeFboSubAccount: + m.ClearFboSubAccount() + return nil + case ledgerbreakagerecord.EdgeBreakageSubAccount: + m.ClearBreakageSubAccount() + return nil + case ledgerbreakagerecord.EdgePlan: + m.ClearPlan() + return nil + case ledgerbreakagerecord.EdgeRelease: + m.ClearRelease() + return nil + } return fmt.Errorf("unknown LedgerBreakageRecord 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 *LedgerBreakageRecordMutation) ResetEdge(name string) error { + switch name { + case ledgerbreakagerecord.EdgeSourceTransactionGroup: + m.ResetSourceTransactionGroup() + return nil + case ledgerbreakagerecord.EdgeSourceTransaction: + m.ResetSourceTransaction() + return nil + case ledgerbreakagerecord.EdgeSourceEntry: + m.ResetSourceEntry() + return nil + case ledgerbreakagerecord.EdgeBreakageTransactionGroup: + m.ResetBreakageTransactionGroup() + return nil + case ledgerbreakagerecord.EdgeBreakageTransaction: + m.ResetBreakageTransaction() + return nil + case ledgerbreakagerecord.EdgeFboSubAccount: + m.ResetFboSubAccount() + return nil + case ledgerbreakagerecord.EdgeBreakageSubAccount: + m.ResetBreakageSubAccount() + return nil + case ledgerbreakagerecord.EdgePlannedReleases: + m.ResetPlannedReleases() + return nil + case ledgerbreakagerecord.EdgeReleaseReopens: + m.ResetReleaseReopens() + return nil + case ledgerbreakagerecord.EdgePlan: + m.ResetPlan() + return nil + case ledgerbreakagerecord.EdgeRelease: + m.ResetRelease() + return nil + } return fmt.Errorf("unknown LedgerBreakageRecord edge %s", name) } // LedgerCustomerAccountMutation represents an operation that mutates the LedgerCustomerAccount nodes in the graph. type LedgerCustomerAccountMutation struct { config - op Op - typ string - id *string - namespace *string - created_at *time.Time - updated_at *time.Time - deleted_at *time.Time - customer_id *string - account_type *ledger.AccountType - account_id *string - clearedFields map[string]struct{} - done bool - oldValue func(context.Context) (*LedgerCustomerAccount, error) - predicates []predicate.LedgerCustomerAccount + op Op + typ string + id *string + namespace *string + created_at *time.Time + updated_at *time.Time + deleted_at *time.Time + customer_id *string + account_type *ledger.AccountType + clearedFields map[string]struct{} + account *string + clearedaccount bool + done bool + oldValue func(context.Context) (*LedgerCustomerAccount, error) + predicates []predicate.LedgerCustomerAccount } var _ ent.Mutation = (*LedgerCustomerAccountMutation)(nil) @@ -85089,12 +85763,12 @@ func (m *LedgerCustomerAccountMutation) ResetAccountType() { // SetAccountID sets the "account_id" field. func (m *LedgerCustomerAccountMutation) SetAccountID(s string) { - m.account_id = &s + m.account = &s } // AccountID returns the value of the "account_id" field in the mutation. func (m *LedgerCustomerAccountMutation) AccountID() (r string, exists bool) { - v := m.account_id + v := m.account if v == nil { return } @@ -85120,7 +85794,34 @@ func (m *LedgerCustomerAccountMutation) OldAccountID(ctx context.Context) (v str // ResetAccountID resets all changes to the "account_id" field. func (m *LedgerCustomerAccountMutation) ResetAccountID() { - m.account_id = nil + m.account = nil +} + +// ClearAccount clears the "account" edge to the LedgerAccount entity. +func (m *LedgerCustomerAccountMutation) ClearAccount() { + m.clearedaccount = true + m.clearedFields[ledgercustomeraccount.FieldAccountID] = struct{}{} +} + +// AccountCleared reports if the "account" edge to the LedgerAccount entity was cleared. +func (m *LedgerCustomerAccountMutation) AccountCleared() bool { + return m.clearedaccount +} + +// AccountIDs returns the "account" edge IDs in the mutation. +// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use +// AccountID instead. It exists only for internal usage by the builders. +func (m *LedgerCustomerAccountMutation) AccountIDs() (ids []string) { + if id := m.account; id != nil { + ids = append(ids, *id) + } + return +} + +// ResetAccount resets all changes to the "account" edge. +func (m *LedgerCustomerAccountMutation) ResetAccount() { + m.account = nil + m.clearedaccount = false } // Where appends a list predicates to the LedgerCustomerAccountMutation builder. @@ -85176,7 +85877,7 @@ func (m *LedgerCustomerAccountMutation) Fields() []string { if m.account_type != nil { fields = append(fields, ledgercustomeraccount.FieldAccountType) } - if m.account_id != nil { + if m.account != nil { fields = append(fields, ledgercustomeraccount.FieldAccountID) } return fields @@ -85367,19 +86068,28 @@ func (m *LedgerCustomerAccountMutation) ResetField(name string) error { // AddedEdges returns all edge names that were set/added in this mutation. func (m *LedgerCustomerAccountMutation) AddedEdges() []string { - edges := make([]string, 0, 0) + edges := make([]string, 0, 1) + if m.account != nil { + edges = append(edges, ledgercustomeraccount.EdgeAccount) + } return edges } // AddedIDs returns all IDs (to other nodes) that were added for the given edge // name in this mutation. func (m *LedgerCustomerAccountMutation) AddedIDs(name string) []ent.Value { + switch name { + case ledgercustomeraccount.EdgeAccount: + if id := m.account; id != nil { + return []ent.Value{*id} + } + } return nil } // RemovedEdges returns all edge names that were removed in this mutation. func (m *LedgerCustomerAccountMutation) RemovedEdges() []string { - edges := make([]string, 0, 0) + edges := make([]string, 0, 1) return edges } @@ -85391,53 +86101,73 @@ func (m *LedgerCustomerAccountMutation) RemovedIDs(name string) []ent.Value { // ClearedEdges returns all edge names that were cleared in this mutation. func (m *LedgerCustomerAccountMutation) ClearedEdges() []string { - edges := make([]string, 0, 0) + edges := make([]string, 0, 1) + if m.clearedaccount { + edges = append(edges, ledgercustomeraccount.EdgeAccount) + } return edges } // EdgeCleared returns a boolean which indicates if the edge with the given name // was cleared in this mutation. func (m *LedgerCustomerAccountMutation) EdgeCleared(name string) bool { + switch name { + case ledgercustomeraccount.EdgeAccount: + return m.clearedaccount + } 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 *LedgerCustomerAccountMutation) ClearEdge(name string) error { + switch name { + case ledgercustomeraccount.EdgeAccount: + m.ClearAccount() + return nil + } return fmt.Errorf("unknown LedgerCustomerAccount 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 *LedgerCustomerAccountMutation) ResetEdge(name string) error { + switch name { + case ledgercustomeraccount.EdgeAccount: + m.ResetAccount() + return nil + } return fmt.Errorf("unknown LedgerCustomerAccount edge %s", name) } // LedgerEntryMutation represents an operation that mutates the LedgerEntry nodes in the graph. type LedgerEntryMutation struct { config - op Op - typ string - id *string - namespace *string - annotations *models.Annotations - created_at *time.Time - updated_at *time.Time - deleted_at *time.Time - identity_key *string - schema_version *int - addschema_version *int - source_charge_id *string - spend_charge_id *string - amount *alpacadecimal.Decimal - clearedFields map[string]struct{} - transaction *string - clearedtransaction bool - sub_account *string - clearedsub_account bool - done bool - oldValue func(context.Context) (*LedgerEntry, error) - predicates []predicate.LedgerEntry + op Op + typ string + id *string + namespace *string + annotations *models.Annotations + created_at *time.Time + updated_at *time.Time + deleted_at *time.Time + identity_key *string + schema_version *int + addschema_version *int + source_charge_id *string + spend_charge_id *string + amount *alpacadecimal.Decimal + clearedFields map[string]struct{} + transaction *string + clearedtransaction bool + sub_account *string + clearedsub_account bool + source_breakage_records map[string]struct{} + removedsource_breakage_records map[string]struct{} + clearedsource_breakage_records bool + done bool + oldValue func(context.Context) (*LedgerEntry, error) + predicates []predicate.LedgerEntry } var _ ent.Mutation = (*LedgerEntryMutation)(nil) @@ -86102,6 +86832,60 @@ func (m *LedgerEntryMutation) ResetSubAccount() { m.clearedsub_account = false } +// AddSourceBreakageRecordIDs adds the "source_breakage_records" edge to the LedgerBreakageRecord entity by ids. +func (m *LedgerEntryMutation) AddSourceBreakageRecordIDs(ids ...string) { + if m.source_breakage_records == nil { + m.source_breakage_records = make(map[string]struct{}) + } + for i := range ids { + m.source_breakage_records[ids[i]] = struct{}{} + } +} + +// ClearSourceBreakageRecords clears the "source_breakage_records" edge to the LedgerBreakageRecord entity. +func (m *LedgerEntryMutation) ClearSourceBreakageRecords() { + m.clearedsource_breakage_records = true +} + +// SourceBreakageRecordsCleared reports if the "source_breakage_records" edge to the LedgerBreakageRecord entity was cleared. +func (m *LedgerEntryMutation) SourceBreakageRecordsCleared() bool { + return m.clearedsource_breakage_records +} + +// RemoveSourceBreakageRecordIDs removes the "source_breakage_records" edge to the LedgerBreakageRecord entity by IDs. +func (m *LedgerEntryMutation) RemoveSourceBreakageRecordIDs(ids ...string) { + if m.removedsource_breakage_records == nil { + m.removedsource_breakage_records = make(map[string]struct{}) + } + for i := range ids { + delete(m.source_breakage_records, ids[i]) + m.removedsource_breakage_records[ids[i]] = struct{}{} + } +} + +// RemovedSourceBreakageRecords returns the removed IDs of the "source_breakage_records" edge to the LedgerBreakageRecord entity. +func (m *LedgerEntryMutation) RemovedSourceBreakageRecordsIDs() (ids []string) { + for id := range m.removedsource_breakage_records { + ids = append(ids, id) + } + return +} + +// SourceBreakageRecordsIDs returns the "source_breakage_records" edge IDs in the mutation. +func (m *LedgerEntryMutation) SourceBreakageRecordsIDs() (ids []string) { + for id := range m.source_breakage_records { + ids = append(ids, id) + } + return +} + +// ResetSourceBreakageRecords resets all changes to the "source_breakage_records" edge. +func (m *LedgerEntryMutation) ResetSourceBreakageRecords() { + m.source_breakage_records = nil + m.clearedsource_breakage_records = false + m.removedsource_breakage_records = nil +} + // Where appends a list predicates to the LedgerEntryMutation builder. func (m *LedgerEntryMutation) Where(ps ...predicate.LedgerEntry) { m.predicates = append(m.predicates, ps...) @@ -86464,13 +87248,16 @@ func (m *LedgerEntryMutation) ResetField(name string) error { // AddedEdges returns all edge names that were set/added in this mutation. func (m *LedgerEntryMutation) AddedEdges() []string { - edges := make([]string, 0, 2) + edges := make([]string, 0, 3) if m.transaction != nil { edges = append(edges, ledgerentry.EdgeTransaction) } if m.sub_account != nil { edges = append(edges, ledgerentry.EdgeSubAccount) } + if m.source_breakage_records != nil { + edges = append(edges, ledgerentry.EdgeSourceBreakageRecords) + } return edges } @@ -86486,31 +87273,51 @@ func (m *LedgerEntryMutation) AddedIDs(name string) []ent.Value { if id := m.sub_account; id != nil { return []ent.Value{*id} } + case ledgerentry.EdgeSourceBreakageRecords: + ids := make([]ent.Value, 0, len(m.source_breakage_records)) + for id := range m.source_breakage_records { + ids = append(ids, id) + } + return ids } return nil } // RemovedEdges returns all edge names that were removed in this mutation. func (m *LedgerEntryMutation) RemovedEdges() []string { - edges := make([]string, 0, 2) + edges := make([]string, 0, 3) + if m.removedsource_breakage_records != nil { + edges = append(edges, ledgerentry.EdgeSourceBreakageRecords) + } return edges } // RemovedIDs returns all IDs (to other nodes) that were removed for the edge with // the given name in this mutation. func (m *LedgerEntryMutation) RemovedIDs(name string) []ent.Value { + switch name { + case ledgerentry.EdgeSourceBreakageRecords: + ids := make([]ent.Value, 0, len(m.removedsource_breakage_records)) + for id := range m.removedsource_breakage_records { + ids = append(ids, id) + } + return ids + } return nil } // ClearedEdges returns all edge names that were cleared in this mutation. func (m *LedgerEntryMutation) ClearedEdges() []string { - edges := make([]string, 0, 2) + edges := make([]string, 0, 3) if m.clearedtransaction { edges = append(edges, ledgerentry.EdgeTransaction) } if m.clearedsub_account { edges = append(edges, ledgerentry.EdgeSubAccount) } + if m.clearedsource_breakage_records { + edges = append(edges, ledgerentry.EdgeSourceBreakageRecords) + } return edges } @@ -86522,6 +87329,8 @@ func (m *LedgerEntryMutation) EdgeCleared(name string) bool { return m.clearedtransaction case ledgerentry.EdgeSubAccount: return m.clearedsub_account + case ledgerentry.EdgeSourceBreakageRecords: + return m.clearedsource_breakage_records } return false } @@ -86550,6 +87359,9 @@ func (m *LedgerEntryMutation) ResetEdge(name string) error { case ledgerentry.EdgeSubAccount: m.ResetSubAccount() return nil + case ledgerentry.EdgeSourceBreakageRecords: + m.ResetSourceBreakageRecords() + return nil } return fmt.Errorf("unknown LedgerEntry edge %s", name) } @@ -86557,25 +87369,31 @@ func (m *LedgerEntryMutation) ResetEdge(name string) error { // LedgerSubAccountMutation represents an operation that mutates the LedgerSubAccount nodes in the graph. type LedgerSubAccountMutation struct { config - op Op - typ string - id *string - namespace *string - annotations *models.Annotations - created_at *time.Time - updated_at *time.Time - deleted_at *time.Time - clearedFields map[string]struct{} - account *string - clearedaccount bool - route *string - clearedroute bool - entries map[string]struct{} - removedentries map[string]struct{} - clearedentries bool - done bool - oldValue func(context.Context) (*LedgerSubAccount, error) - predicates []predicate.LedgerSubAccount + op Op + typ string + id *string + namespace *string + annotations *models.Annotations + created_at *time.Time + updated_at *time.Time + deleted_at *time.Time + clearedFields map[string]struct{} + account *string + clearedaccount bool + route *string + clearedroute bool + entries map[string]struct{} + removedentries map[string]struct{} + clearedentries bool + fbo_breakage_records map[string]struct{} + removedfbo_breakage_records map[string]struct{} + clearedfbo_breakage_records bool + breakage_records map[string]struct{} + removedbreakage_records map[string]struct{} + clearedbreakage_records bool + done bool + oldValue func(context.Context) (*LedgerSubAccount, error) + predicates []predicate.LedgerSubAccount } var _ ent.Mutation = (*LedgerSubAccountMutation)(nil) @@ -87068,6 +87886,114 @@ func (m *LedgerSubAccountMutation) ResetEntries() { m.removedentries = nil } +// AddFboBreakageRecordIDs adds the "fbo_breakage_records" edge to the LedgerBreakageRecord entity by ids. +func (m *LedgerSubAccountMutation) AddFboBreakageRecordIDs(ids ...string) { + if m.fbo_breakage_records == nil { + m.fbo_breakage_records = make(map[string]struct{}) + } + for i := range ids { + m.fbo_breakage_records[ids[i]] = struct{}{} + } +} + +// ClearFboBreakageRecords clears the "fbo_breakage_records" edge to the LedgerBreakageRecord entity. +func (m *LedgerSubAccountMutation) ClearFboBreakageRecords() { + m.clearedfbo_breakage_records = true +} + +// FboBreakageRecordsCleared reports if the "fbo_breakage_records" edge to the LedgerBreakageRecord entity was cleared. +func (m *LedgerSubAccountMutation) FboBreakageRecordsCleared() bool { + return m.clearedfbo_breakage_records +} + +// RemoveFboBreakageRecordIDs removes the "fbo_breakage_records" edge to the LedgerBreakageRecord entity by IDs. +func (m *LedgerSubAccountMutation) RemoveFboBreakageRecordIDs(ids ...string) { + if m.removedfbo_breakage_records == nil { + m.removedfbo_breakage_records = make(map[string]struct{}) + } + for i := range ids { + delete(m.fbo_breakage_records, ids[i]) + m.removedfbo_breakage_records[ids[i]] = struct{}{} + } +} + +// RemovedFboBreakageRecords returns the removed IDs of the "fbo_breakage_records" edge to the LedgerBreakageRecord entity. +func (m *LedgerSubAccountMutation) RemovedFboBreakageRecordsIDs() (ids []string) { + for id := range m.removedfbo_breakage_records { + ids = append(ids, id) + } + return +} + +// FboBreakageRecordsIDs returns the "fbo_breakage_records" edge IDs in the mutation. +func (m *LedgerSubAccountMutation) FboBreakageRecordsIDs() (ids []string) { + for id := range m.fbo_breakage_records { + ids = append(ids, id) + } + return +} + +// ResetFboBreakageRecords resets all changes to the "fbo_breakage_records" edge. +func (m *LedgerSubAccountMutation) ResetFboBreakageRecords() { + m.fbo_breakage_records = nil + m.clearedfbo_breakage_records = false + m.removedfbo_breakage_records = nil +} + +// AddBreakageRecordIDs adds the "breakage_records" edge to the LedgerBreakageRecord entity by ids. +func (m *LedgerSubAccountMutation) AddBreakageRecordIDs(ids ...string) { + if m.breakage_records == nil { + m.breakage_records = make(map[string]struct{}) + } + for i := range ids { + m.breakage_records[ids[i]] = struct{}{} + } +} + +// ClearBreakageRecords clears the "breakage_records" edge to the LedgerBreakageRecord entity. +func (m *LedgerSubAccountMutation) ClearBreakageRecords() { + m.clearedbreakage_records = true +} + +// BreakageRecordsCleared reports if the "breakage_records" edge to the LedgerBreakageRecord entity was cleared. +func (m *LedgerSubAccountMutation) BreakageRecordsCleared() bool { + return m.clearedbreakage_records +} + +// RemoveBreakageRecordIDs removes the "breakage_records" edge to the LedgerBreakageRecord entity by IDs. +func (m *LedgerSubAccountMutation) RemoveBreakageRecordIDs(ids ...string) { + if m.removedbreakage_records == nil { + m.removedbreakage_records = make(map[string]struct{}) + } + for i := range ids { + delete(m.breakage_records, ids[i]) + m.removedbreakage_records[ids[i]] = struct{}{} + } +} + +// RemovedBreakageRecords returns the removed IDs of the "breakage_records" edge to the LedgerBreakageRecord entity. +func (m *LedgerSubAccountMutation) RemovedBreakageRecordsIDs() (ids []string) { + for id := range m.removedbreakage_records { + ids = append(ids, id) + } + return +} + +// BreakageRecordsIDs returns the "breakage_records" edge IDs in the mutation. +func (m *LedgerSubAccountMutation) BreakageRecordsIDs() (ids []string) { + for id := range m.breakage_records { + ids = append(ids, id) + } + return +} + +// ResetBreakageRecords resets all changes to the "breakage_records" edge. +func (m *LedgerSubAccountMutation) ResetBreakageRecords() { + m.breakage_records = nil + m.clearedbreakage_records = false + m.removedbreakage_records = nil +} + // Where appends a list predicates to the LedgerSubAccountMutation builder. func (m *LedgerSubAccountMutation) Where(ps ...predicate.LedgerSubAccount) { m.predicates = append(m.predicates, ps...) @@ -87318,7 +88244,7 @@ func (m *LedgerSubAccountMutation) ResetField(name string) error { // AddedEdges returns all edge names that were set/added in this mutation. func (m *LedgerSubAccountMutation) AddedEdges() []string { - edges := make([]string, 0, 3) + edges := make([]string, 0, 5) if m.account != nil { edges = append(edges, ledgersubaccount.EdgeAccount) } @@ -87328,6 +88254,12 @@ func (m *LedgerSubAccountMutation) AddedEdges() []string { if m.entries != nil { edges = append(edges, ledgersubaccount.EdgeEntries) } + if m.fbo_breakage_records != nil { + edges = append(edges, ledgersubaccount.EdgeFboBreakageRecords) + } + if m.breakage_records != nil { + edges = append(edges, ledgersubaccount.EdgeBreakageRecords) + } return edges } @@ -87349,16 +88281,34 @@ func (m *LedgerSubAccountMutation) AddedIDs(name string) []ent.Value { ids = append(ids, id) } return ids + case ledgersubaccount.EdgeFboBreakageRecords: + ids := make([]ent.Value, 0, len(m.fbo_breakage_records)) + for id := range m.fbo_breakage_records { + ids = append(ids, id) + } + return ids + case ledgersubaccount.EdgeBreakageRecords: + ids := make([]ent.Value, 0, len(m.breakage_records)) + for id := range m.breakage_records { + ids = append(ids, id) + } + return ids } return nil } // RemovedEdges returns all edge names that were removed in this mutation. func (m *LedgerSubAccountMutation) RemovedEdges() []string { - edges := make([]string, 0, 3) + edges := make([]string, 0, 5) if m.removedentries != nil { edges = append(edges, ledgersubaccount.EdgeEntries) } + if m.removedfbo_breakage_records != nil { + edges = append(edges, ledgersubaccount.EdgeFboBreakageRecords) + } + if m.removedbreakage_records != nil { + edges = append(edges, ledgersubaccount.EdgeBreakageRecords) + } return edges } @@ -87372,13 +88322,25 @@ func (m *LedgerSubAccountMutation) RemovedIDs(name string) []ent.Value { ids = append(ids, id) } return ids + case ledgersubaccount.EdgeFboBreakageRecords: + ids := make([]ent.Value, 0, len(m.removedfbo_breakage_records)) + for id := range m.removedfbo_breakage_records { + ids = append(ids, id) + } + return ids + case ledgersubaccount.EdgeBreakageRecords: + ids := make([]ent.Value, 0, len(m.removedbreakage_records)) + for id := range m.removedbreakage_records { + ids = append(ids, id) + } + return ids } return nil } // ClearedEdges returns all edge names that were cleared in this mutation. func (m *LedgerSubAccountMutation) ClearedEdges() []string { - edges := make([]string, 0, 3) + edges := make([]string, 0, 5) if m.clearedaccount { edges = append(edges, ledgersubaccount.EdgeAccount) } @@ -87388,6 +88350,12 @@ func (m *LedgerSubAccountMutation) ClearedEdges() []string { if m.clearedentries { edges = append(edges, ledgersubaccount.EdgeEntries) } + if m.clearedfbo_breakage_records { + edges = append(edges, ledgersubaccount.EdgeFboBreakageRecords) + } + if m.clearedbreakage_records { + edges = append(edges, ledgersubaccount.EdgeBreakageRecords) + } return edges } @@ -87401,6 +88369,10 @@ func (m *LedgerSubAccountMutation) EdgeCleared(name string) bool { return m.clearedroute case ledgersubaccount.EdgeEntries: return m.clearedentries + case ledgersubaccount.EdgeFboBreakageRecords: + return m.clearedfbo_breakage_records + case ledgersubaccount.EdgeBreakageRecords: + return m.clearedbreakage_records } return false } @@ -87432,6 +88404,12 @@ func (m *LedgerSubAccountMutation) ResetEdge(name string) error { case ledgersubaccount.EdgeEntries: m.ResetEntries() return nil + case ledgersubaccount.EdgeFboBreakageRecords: + m.ResetFboBreakageRecords() + return nil + case ledgersubaccount.EdgeBreakageRecords: + m.ResetBreakageRecords() + return nil } return fmt.Errorf("unknown LedgerSubAccount edge %s", name) } @@ -88785,24 +89763,30 @@ func (m *LedgerSubAccountRouteMutation) ResetEdge(name string) error { // LedgerTransactionMutation represents an operation that mutates the LedgerTransaction nodes in the graph. type LedgerTransactionMutation struct { config - op Op - typ string - id *string - namespace *string - annotations *models.Annotations - created_at *time.Time - updated_at *time.Time - deleted_at *time.Time - booked_at *time.Time - clearedFields map[string]struct{} - group *string - clearedgroup bool - entries map[string]struct{} - removedentries map[string]struct{} - clearedentries bool - done bool - oldValue func(context.Context) (*LedgerTransaction, error) - predicates []predicate.LedgerTransaction + op Op + typ string + id *string + namespace *string + annotations *models.Annotations + created_at *time.Time + updated_at *time.Time + deleted_at *time.Time + booked_at *time.Time + clearedFields map[string]struct{} + group *string + clearedgroup bool + entries map[string]struct{} + removedentries map[string]struct{} + clearedentries bool + source_breakage_records map[string]struct{} + removedsource_breakage_records map[string]struct{} + clearedsource_breakage_records bool + breakage_records map[string]struct{} + removedbreakage_records map[string]struct{} + clearedbreakage_records bool + done bool + oldValue func(context.Context) (*LedgerTransaction, error) + predicates []predicate.LedgerTransaction } var _ ent.Mutation = (*LedgerTransactionMutation)(nil) @@ -89268,6 +90252,114 @@ func (m *LedgerTransactionMutation) ResetEntries() { m.removedentries = nil } +// AddSourceBreakageRecordIDs adds the "source_breakage_records" edge to the LedgerBreakageRecord entity by ids. +func (m *LedgerTransactionMutation) AddSourceBreakageRecordIDs(ids ...string) { + if m.source_breakage_records == nil { + m.source_breakage_records = make(map[string]struct{}) + } + for i := range ids { + m.source_breakage_records[ids[i]] = struct{}{} + } +} + +// ClearSourceBreakageRecords clears the "source_breakage_records" edge to the LedgerBreakageRecord entity. +func (m *LedgerTransactionMutation) ClearSourceBreakageRecords() { + m.clearedsource_breakage_records = true +} + +// SourceBreakageRecordsCleared reports if the "source_breakage_records" edge to the LedgerBreakageRecord entity was cleared. +func (m *LedgerTransactionMutation) SourceBreakageRecordsCleared() bool { + return m.clearedsource_breakage_records +} + +// RemoveSourceBreakageRecordIDs removes the "source_breakage_records" edge to the LedgerBreakageRecord entity by IDs. +func (m *LedgerTransactionMutation) RemoveSourceBreakageRecordIDs(ids ...string) { + if m.removedsource_breakage_records == nil { + m.removedsource_breakage_records = make(map[string]struct{}) + } + for i := range ids { + delete(m.source_breakage_records, ids[i]) + m.removedsource_breakage_records[ids[i]] = struct{}{} + } +} + +// RemovedSourceBreakageRecords returns the removed IDs of the "source_breakage_records" edge to the LedgerBreakageRecord entity. +func (m *LedgerTransactionMutation) RemovedSourceBreakageRecordsIDs() (ids []string) { + for id := range m.removedsource_breakage_records { + ids = append(ids, id) + } + return +} + +// SourceBreakageRecordsIDs returns the "source_breakage_records" edge IDs in the mutation. +func (m *LedgerTransactionMutation) SourceBreakageRecordsIDs() (ids []string) { + for id := range m.source_breakage_records { + ids = append(ids, id) + } + return +} + +// ResetSourceBreakageRecords resets all changes to the "source_breakage_records" edge. +func (m *LedgerTransactionMutation) ResetSourceBreakageRecords() { + m.source_breakage_records = nil + m.clearedsource_breakage_records = false + m.removedsource_breakage_records = nil +} + +// AddBreakageRecordIDs adds the "breakage_records" edge to the LedgerBreakageRecord entity by ids. +func (m *LedgerTransactionMutation) AddBreakageRecordIDs(ids ...string) { + if m.breakage_records == nil { + m.breakage_records = make(map[string]struct{}) + } + for i := range ids { + m.breakage_records[ids[i]] = struct{}{} + } +} + +// ClearBreakageRecords clears the "breakage_records" edge to the LedgerBreakageRecord entity. +func (m *LedgerTransactionMutation) ClearBreakageRecords() { + m.clearedbreakage_records = true +} + +// BreakageRecordsCleared reports if the "breakage_records" edge to the LedgerBreakageRecord entity was cleared. +func (m *LedgerTransactionMutation) BreakageRecordsCleared() bool { + return m.clearedbreakage_records +} + +// RemoveBreakageRecordIDs removes the "breakage_records" edge to the LedgerBreakageRecord entity by IDs. +func (m *LedgerTransactionMutation) RemoveBreakageRecordIDs(ids ...string) { + if m.removedbreakage_records == nil { + m.removedbreakage_records = make(map[string]struct{}) + } + for i := range ids { + delete(m.breakage_records, ids[i]) + m.removedbreakage_records[ids[i]] = struct{}{} + } +} + +// RemovedBreakageRecords returns the removed IDs of the "breakage_records" edge to the LedgerBreakageRecord entity. +func (m *LedgerTransactionMutation) RemovedBreakageRecordsIDs() (ids []string) { + for id := range m.removedbreakage_records { + ids = append(ids, id) + } + return +} + +// BreakageRecordsIDs returns the "breakage_records" edge IDs in the mutation. +func (m *LedgerTransactionMutation) BreakageRecordsIDs() (ids []string) { + for id := range m.breakage_records { + ids = append(ids, id) + } + return +} + +// ResetBreakageRecords resets all changes to the "breakage_records" edge. +func (m *LedgerTransactionMutation) ResetBreakageRecords() { + m.breakage_records = nil + m.clearedbreakage_records = false + m.removedbreakage_records = nil +} + // Where appends a list predicates to the LedgerTransactionMutation builder. func (m *LedgerTransactionMutation) Where(ps ...predicate.LedgerTransaction) { m.predicates = append(m.predicates, ps...) @@ -89518,13 +90610,19 @@ func (m *LedgerTransactionMutation) ResetField(name string) error { // AddedEdges returns all edge names that were set/added in this mutation. func (m *LedgerTransactionMutation) AddedEdges() []string { - edges := make([]string, 0, 2) + edges := make([]string, 0, 4) if m.group != nil { edges = append(edges, ledgertransaction.EdgeGroup) } if m.entries != nil { edges = append(edges, ledgertransaction.EdgeEntries) } + if m.source_breakage_records != nil { + edges = append(edges, ledgertransaction.EdgeSourceBreakageRecords) + } + if m.breakage_records != nil { + edges = append(edges, ledgertransaction.EdgeBreakageRecords) + } return edges } @@ -89542,16 +90640,34 @@ func (m *LedgerTransactionMutation) AddedIDs(name string) []ent.Value { ids = append(ids, id) } return ids + case ledgertransaction.EdgeSourceBreakageRecords: + ids := make([]ent.Value, 0, len(m.source_breakage_records)) + for id := range m.source_breakage_records { + ids = append(ids, id) + } + return ids + case ledgertransaction.EdgeBreakageRecords: + ids := make([]ent.Value, 0, len(m.breakage_records)) + for id := range m.breakage_records { + ids = append(ids, id) + } + return ids } return nil } // RemovedEdges returns all edge names that were removed in this mutation. func (m *LedgerTransactionMutation) RemovedEdges() []string { - edges := make([]string, 0, 2) + edges := make([]string, 0, 4) if m.removedentries != nil { edges = append(edges, ledgertransaction.EdgeEntries) } + if m.removedsource_breakage_records != nil { + edges = append(edges, ledgertransaction.EdgeSourceBreakageRecords) + } + if m.removedbreakage_records != nil { + edges = append(edges, ledgertransaction.EdgeBreakageRecords) + } return edges } @@ -89565,19 +90681,37 @@ func (m *LedgerTransactionMutation) RemovedIDs(name string) []ent.Value { ids = append(ids, id) } return ids + case ledgertransaction.EdgeSourceBreakageRecords: + ids := make([]ent.Value, 0, len(m.removedsource_breakage_records)) + for id := range m.removedsource_breakage_records { + ids = append(ids, id) + } + return ids + case ledgertransaction.EdgeBreakageRecords: + ids := make([]ent.Value, 0, len(m.removedbreakage_records)) + for id := range m.removedbreakage_records { + ids = append(ids, id) + } + return ids } return nil } // ClearedEdges returns all edge names that were cleared in this mutation. func (m *LedgerTransactionMutation) ClearedEdges() []string { - edges := make([]string, 0, 2) + edges := make([]string, 0, 4) if m.clearedgroup { edges = append(edges, ledgertransaction.EdgeGroup) } if m.clearedentries { edges = append(edges, ledgertransaction.EdgeEntries) } + if m.clearedsource_breakage_records { + edges = append(edges, ledgertransaction.EdgeSourceBreakageRecords) + } + if m.clearedbreakage_records { + edges = append(edges, ledgertransaction.EdgeBreakageRecords) + } return edges } @@ -89589,6 +90723,10 @@ func (m *LedgerTransactionMutation) EdgeCleared(name string) bool { return m.clearedgroup case ledgertransaction.EdgeEntries: return m.clearedentries + case ledgertransaction.EdgeSourceBreakageRecords: + return m.clearedsource_breakage_records + case ledgertransaction.EdgeBreakageRecords: + return m.clearedbreakage_records } return false } @@ -89614,6 +90752,12 @@ func (m *LedgerTransactionMutation) ResetEdge(name string) error { case ledgertransaction.EdgeEntries: m.ResetEntries() return nil + case ledgertransaction.EdgeSourceBreakageRecords: + m.ResetSourceBreakageRecords() + return nil + case ledgertransaction.EdgeBreakageRecords: + m.ResetBreakageRecords() + return nil } return fmt.Errorf("unknown LedgerTransaction edge %s", name) } @@ -89621,21 +90765,27 @@ func (m *LedgerTransactionMutation) ResetEdge(name string) error { // LedgerTransactionGroupMutation represents an operation that mutates the LedgerTransactionGroup nodes in the graph. type LedgerTransactionGroupMutation struct { config - op Op - typ string - id *string - namespace *string - annotations *models.Annotations - created_at *time.Time - updated_at *time.Time - deleted_at *time.Time - clearedFields map[string]struct{} - transactions map[string]struct{} - removedtransactions map[string]struct{} - clearedtransactions bool - done bool - oldValue func(context.Context) (*LedgerTransactionGroup, error) - predicates []predicate.LedgerTransactionGroup + op Op + typ string + id *string + namespace *string + annotations *models.Annotations + created_at *time.Time + updated_at *time.Time + deleted_at *time.Time + clearedFields map[string]struct{} + transactions map[string]struct{} + removedtransactions map[string]struct{} + clearedtransactions bool + source_breakage_records map[string]struct{} + removedsource_breakage_records map[string]struct{} + clearedsource_breakage_records bool + breakage_records map[string]struct{} + removedbreakage_records map[string]struct{} + clearedbreakage_records bool + done bool + oldValue func(context.Context) (*LedgerTransactionGroup, error) + predicates []predicate.LedgerTransactionGroup } var _ ent.Mutation = (*LedgerTransactionGroupMutation)(nil) @@ -90002,6 +91152,114 @@ func (m *LedgerTransactionGroupMutation) ResetTransactions() { m.removedtransactions = nil } +// AddSourceBreakageRecordIDs adds the "source_breakage_records" edge to the LedgerBreakageRecord entity by ids. +func (m *LedgerTransactionGroupMutation) AddSourceBreakageRecordIDs(ids ...string) { + if m.source_breakage_records == nil { + m.source_breakage_records = make(map[string]struct{}) + } + for i := range ids { + m.source_breakage_records[ids[i]] = struct{}{} + } +} + +// ClearSourceBreakageRecords clears the "source_breakage_records" edge to the LedgerBreakageRecord entity. +func (m *LedgerTransactionGroupMutation) ClearSourceBreakageRecords() { + m.clearedsource_breakage_records = true +} + +// SourceBreakageRecordsCleared reports if the "source_breakage_records" edge to the LedgerBreakageRecord entity was cleared. +func (m *LedgerTransactionGroupMutation) SourceBreakageRecordsCleared() bool { + return m.clearedsource_breakage_records +} + +// RemoveSourceBreakageRecordIDs removes the "source_breakage_records" edge to the LedgerBreakageRecord entity by IDs. +func (m *LedgerTransactionGroupMutation) RemoveSourceBreakageRecordIDs(ids ...string) { + if m.removedsource_breakage_records == nil { + m.removedsource_breakage_records = make(map[string]struct{}) + } + for i := range ids { + delete(m.source_breakage_records, ids[i]) + m.removedsource_breakage_records[ids[i]] = struct{}{} + } +} + +// RemovedSourceBreakageRecords returns the removed IDs of the "source_breakage_records" edge to the LedgerBreakageRecord entity. +func (m *LedgerTransactionGroupMutation) RemovedSourceBreakageRecordsIDs() (ids []string) { + for id := range m.removedsource_breakage_records { + ids = append(ids, id) + } + return +} + +// SourceBreakageRecordsIDs returns the "source_breakage_records" edge IDs in the mutation. +func (m *LedgerTransactionGroupMutation) SourceBreakageRecordsIDs() (ids []string) { + for id := range m.source_breakage_records { + ids = append(ids, id) + } + return +} + +// ResetSourceBreakageRecords resets all changes to the "source_breakage_records" edge. +func (m *LedgerTransactionGroupMutation) ResetSourceBreakageRecords() { + m.source_breakage_records = nil + m.clearedsource_breakage_records = false + m.removedsource_breakage_records = nil +} + +// AddBreakageRecordIDs adds the "breakage_records" edge to the LedgerBreakageRecord entity by ids. +func (m *LedgerTransactionGroupMutation) AddBreakageRecordIDs(ids ...string) { + if m.breakage_records == nil { + m.breakage_records = make(map[string]struct{}) + } + for i := range ids { + m.breakage_records[ids[i]] = struct{}{} + } +} + +// ClearBreakageRecords clears the "breakage_records" edge to the LedgerBreakageRecord entity. +func (m *LedgerTransactionGroupMutation) ClearBreakageRecords() { + m.clearedbreakage_records = true +} + +// BreakageRecordsCleared reports if the "breakage_records" edge to the LedgerBreakageRecord entity was cleared. +func (m *LedgerTransactionGroupMutation) BreakageRecordsCleared() bool { + return m.clearedbreakage_records +} + +// RemoveBreakageRecordIDs removes the "breakage_records" edge to the LedgerBreakageRecord entity by IDs. +func (m *LedgerTransactionGroupMutation) RemoveBreakageRecordIDs(ids ...string) { + if m.removedbreakage_records == nil { + m.removedbreakage_records = make(map[string]struct{}) + } + for i := range ids { + delete(m.breakage_records, ids[i]) + m.removedbreakage_records[ids[i]] = struct{}{} + } +} + +// RemovedBreakageRecords returns the removed IDs of the "breakage_records" edge to the LedgerBreakageRecord entity. +func (m *LedgerTransactionGroupMutation) RemovedBreakageRecordsIDs() (ids []string) { + for id := range m.removedbreakage_records { + ids = append(ids, id) + } + return +} + +// BreakageRecordsIDs returns the "breakage_records" edge IDs in the mutation. +func (m *LedgerTransactionGroupMutation) BreakageRecordsIDs() (ids []string) { + for id := range m.breakage_records { + ids = append(ids, id) + } + return +} + +// ResetBreakageRecords resets all changes to the "breakage_records" edge. +func (m *LedgerTransactionGroupMutation) ResetBreakageRecords() { + m.breakage_records = nil + m.clearedbreakage_records = false + m.removedbreakage_records = nil +} + // Where appends a list predicates to the LedgerTransactionGroupMutation builder. func (m *LedgerTransactionGroupMutation) Where(ps ...predicate.LedgerTransactionGroup) { m.predicates = append(m.predicates, ps...) @@ -90218,10 +91476,16 @@ func (m *LedgerTransactionGroupMutation) ResetField(name string) error { // AddedEdges returns all edge names that were set/added in this mutation. func (m *LedgerTransactionGroupMutation) AddedEdges() []string { - edges := make([]string, 0, 1) + edges := make([]string, 0, 3) if m.transactions != nil { edges = append(edges, ledgertransactiongroup.EdgeTransactions) } + if m.source_breakage_records != nil { + edges = append(edges, ledgertransactiongroup.EdgeSourceBreakageRecords) + } + if m.breakage_records != nil { + edges = append(edges, ledgertransactiongroup.EdgeBreakageRecords) + } return edges } @@ -90235,16 +91499,34 @@ func (m *LedgerTransactionGroupMutation) AddedIDs(name string) []ent.Value { ids = append(ids, id) } return ids + case ledgertransactiongroup.EdgeSourceBreakageRecords: + ids := make([]ent.Value, 0, len(m.source_breakage_records)) + for id := range m.source_breakage_records { + ids = append(ids, id) + } + return ids + case ledgertransactiongroup.EdgeBreakageRecords: + ids := make([]ent.Value, 0, len(m.breakage_records)) + for id := range m.breakage_records { + ids = append(ids, id) + } + return ids } return nil } // RemovedEdges returns all edge names that were removed in this mutation. func (m *LedgerTransactionGroupMutation) RemovedEdges() []string { - edges := make([]string, 0, 1) + edges := make([]string, 0, 3) if m.removedtransactions != nil { edges = append(edges, ledgertransactiongroup.EdgeTransactions) } + if m.removedsource_breakage_records != nil { + edges = append(edges, ledgertransactiongroup.EdgeSourceBreakageRecords) + } + if m.removedbreakage_records != nil { + edges = append(edges, ledgertransactiongroup.EdgeBreakageRecords) + } return edges } @@ -90258,16 +91540,34 @@ func (m *LedgerTransactionGroupMutation) RemovedIDs(name string) []ent.Value { ids = append(ids, id) } return ids + case ledgertransactiongroup.EdgeSourceBreakageRecords: + ids := make([]ent.Value, 0, len(m.removedsource_breakage_records)) + for id := range m.removedsource_breakage_records { + ids = append(ids, id) + } + return ids + case ledgertransactiongroup.EdgeBreakageRecords: + ids := make([]ent.Value, 0, len(m.removedbreakage_records)) + for id := range m.removedbreakage_records { + ids = append(ids, id) + } + return ids } return nil } // ClearedEdges returns all edge names that were cleared in this mutation. func (m *LedgerTransactionGroupMutation) ClearedEdges() []string { - edges := make([]string, 0, 1) + edges := make([]string, 0, 3) if m.clearedtransactions { edges = append(edges, ledgertransactiongroup.EdgeTransactions) } + if m.clearedsource_breakage_records { + edges = append(edges, ledgertransactiongroup.EdgeSourceBreakageRecords) + } + if m.clearedbreakage_records { + edges = append(edges, ledgertransactiongroup.EdgeBreakageRecords) + } return edges } @@ -90277,6 +91577,10 @@ func (m *LedgerTransactionGroupMutation) EdgeCleared(name string) bool { switch name { case ledgertransactiongroup.EdgeTransactions: return m.clearedtransactions + case ledgertransactiongroup.EdgeSourceBreakageRecords: + return m.clearedsource_breakage_records + case ledgertransactiongroup.EdgeBreakageRecords: + return m.clearedbreakage_records } return false } @@ -90296,6 +91600,12 @@ func (m *LedgerTransactionGroupMutation) ResetEdge(name string) error { case ledgertransactiongroup.EdgeTransactions: m.ResetTransactions() return nil + case ledgertransactiongroup.EdgeSourceBreakageRecords: + m.ResetSourceBreakageRecords() + return nil + case ledgertransactiongroup.EdgeBreakageRecords: + m.ResetBreakageRecords() + return nil } return fmt.Errorf("unknown LedgerTransactionGroup edge %s", name) } diff --git a/openmeter/ent/schema/ledger_account.go b/openmeter/ent/schema/ledger_account.go index e311048cc1..8576762c2b 100644 --- a/openmeter/ent/schema/ledger_account.go +++ b/openmeter/ent/schema/ledger_account.go @@ -42,6 +42,7 @@ func (LedgerAccount) Edges() []ent.Edge { return []ent.Edge{ edge.To("sub_accounts", LedgerSubAccount.Type), edge.To("sub_account_routes", LedgerSubAccountRoute.Type), + edge.To("customer_accounts", LedgerCustomerAccount.Type), } } @@ -90,6 +91,8 @@ func (LedgerSubAccount) Edges() []ent.Edge { Immutable(). Unique(), edge.To("entries", LedgerEntry.Type), + edge.To("fbo_breakage_records", LedgerBreakageRecord.Type), + edge.To("breakage_records", LedgerBreakageRecord.Type), } } diff --git a/openmeter/ent/schema/ledger_breakage_record.go b/openmeter/ent/schema/ledger_breakage_record.go index f5fa8c6d0b..db00c2bbd2 100644 --- a/openmeter/ent/schema/ledger_breakage_record.go +++ b/openmeter/ent/schema/ledger_breakage_record.go @@ -3,6 +3,8 @@ package schema import ( "entgo.io/ent" "entgo.io/ent/dialect" + "entgo.io/ent/dialect/entsql" + "entgo.io/ent/schema/edge" "entgo.io/ent/schema/field" "entgo.io/ent/schema/index" "github.com/alpacahq/alpacadecimal" @@ -125,6 +127,64 @@ func (LedgerBreakageRecord) Fields() []ent.Field { } } +func (LedgerBreakageRecord) Edges() []ent.Edge { + return []ent.Edge{ + edge.From("source_transaction_group", LedgerTransactionGroup.Type). + Ref("source_breakage_records"). + Field("source_transaction_group_id"). + Immutable(). + Unique(), + edge.From("source_transaction", LedgerTransaction.Type). + Ref("source_breakage_records"). + Field("source_transaction_id"). + Immutable(). + Unique(), + edge.From("source_entry", LedgerEntry.Type). + Ref("source_breakage_records"). + Field("source_entry_id"). + Immutable(). + Unique(), + edge.From("breakage_transaction_group", LedgerTransactionGroup.Type). + Ref("breakage_records"). + Field("breakage_transaction_group_id"). + Required(). + Immutable(). + Unique(), + edge.From("breakage_transaction", LedgerTransaction.Type). + Ref("breakage_records"). + Field("breakage_transaction_id"). + Required(). + Immutable(). + Unique(), + edge.From("fbo_sub_account", LedgerSubAccount.Type). + Ref("fbo_breakage_records"). + Field("fbo_sub_account_id"). + Required(). + Immutable(). + Unique(), + edge.From("breakage_sub_account", LedgerSubAccount.Type). + Ref("breakage_records"). + Field("breakage_sub_account_id"). + Required(). + Immutable(). + Unique(), + edge.To("planned_releases", LedgerBreakageRecord.Type). + Annotations(entsql.OnDelete(entsql.Restrict)), + edge.To("release_reopens", LedgerBreakageRecord.Type). + Annotations(entsql.OnDelete(entsql.Restrict)), + edge.From("plan", LedgerBreakageRecord.Type). + Ref("planned_releases"). + Field("plan_id"). + Immutable(). + Unique(), + edge.From("release", LedgerBreakageRecord.Type). + Ref("release_reopens"). + Field("release_id"). + Immutable(). + Unique(), + } +} + func (LedgerBreakageRecord) Indexes() []ent.Index { return []ent.Index{ index.Fields("namespace", "customer_id", "currency", "credit_priority", "expires_at", "id"). diff --git a/openmeter/ent/schema/ledger_customer_account.go b/openmeter/ent/schema/ledger_customer_account.go index c590653d9f..d567af1ce4 100644 --- a/openmeter/ent/schema/ledger_customer_account.go +++ b/openmeter/ent/schema/ledger_customer_account.go @@ -2,6 +2,8 @@ package schema import ( "entgo.io/ent" + "entgo.io/ent/dialect" + "entgo.io/ent/schema/edge" "entgo.io/ent/schema/field" "entgo.io/ent/schema/index" @@ -27,7 +29,9 @@ func (LedgerCustomerAccount) Fields() []ent.Field { return []ent.Field{ field.String("customer_id").Immutable(), field.String("account_type").GoType(ledger.AccountType("")).Immutable(), - field.String("account_id").Immutable(), + field.String("account_id").SchemaType(map[string]string{ + dialect.Postgres: "char(26)", + }).Immutable(), } } @@ -40,5 +44,12 @@ func (LedgerCustomerAccount) Indexes() []ent.Index { } func (LedgerCustomerAccount) Edges() []ent.Edge { - return nil + return []ent.Edge{ + edge.From("account", LedgerAccount.Type). + Ref("customer_accounts"). + Field("account_id"). + Required(). + Immutable(). + Unique(), + } } diff --git a/openmeter/ent/schema/ledger_entry.go b/openmeter/ent/schema/ledger_entry.go index ea0116fc18..1ebb66c64d 100644 --- a/openmeter/ent/schema/ledger_entry.go +++ b/openmeter/ent/schema/ledger_entry.go @@ -75,6 +75,8 @@ func (LedgerEntry) Edges() []ent.Edge { Required(). Immutable(). Unique(), + edge.To("source_breakage_records", LedgerBreakageRecord.Type). + Annotations(entsql.OnDelete(entsql.Restrict)), } } diff --git a/openmeter/ent/schema/ledger_transaction.go b/openmeter/ent/schema/ledger_transaction.go index 02b54e1aa8..5fc1b7351e 100644 --- a/openmeter/ent/schema/ledger_transaction.go +++ b/openmeter/ent/schema/ledger_transaction.go @@ -3,6 +3,7 @@ package schema import ( "entgo.io/ent" "entgo.io/ent/dialect" + "entgo.io/ent/dialect/entsql" "entgo.io/ent/schema/edge" "entgo.io/ent/schema/field" "entgo.io/ent/schema/index" @@ -41,6 +42,9 @@ func (LedgerTransaction) Edges() []ent.Edge { Immutable(). Unique(), edge.To("entries", LedgerEntry.Type), + edge.To("source_breakage_records", LedgerBreakageRecord.Type). + Annotations(entsql.OnDelete(entsql.Restrict)), + edge.To("breakage_records", LedgerBreakageRecord.Type), } } diff --git a/openmeter/ent/schema/ledger_transaction_group.go b/openmeter/ent/schema/ledger_transaction_group.go index 728f849cb7..c61b51e806 100644 --- a/openmeter/ent/schema/ledger_transaction_group.go +++ b/openmeter/ent/schema/ledger_transaction_group.go @@ -2,6 +2,7 @@ package schema import ( "entgo.io/ent" + "entgo.io/ent/dialect/entsql" "entgo.io/ent/schema/edge" "entgo.io/ent/schema/index" @@ -24,6 +25,9 @@ func (LedgerTransactionGroup) Mixin() []ent.Mixin { func (LedgerTransactionGroup) Edges() []ent.Edge { return []ent.Edge{ edge.To("transactions", LedgerTransaction.Type), + edge.To("source_breakage_records", LedgerBreakageRecord.Type). + Annotations(entsql.OnDelete(entsql.Restrict)), + edge.To("breakage_records", LedgerBreakageRecord.Type), } } diff --git a/openmeter/ledger/breakage/adapter/record_test.go b/openmeter/ledger/breakage/adapter/record_test.go index 04437d639c..70aa605c2d 100644 --- a/openmeter/ledger/breakage/adapter/record_test.go +++ b/openmeter/ledger/breakage/adapter/record_test.go @@ -9,10 +9,10 @@ import ( "github.com/samber/mo" "github.com/stretchr/testify/require" - "github.com/openmeterio/openmeter/openmeter/customer" "github.com/openmeterio/openmeter/openmeter/ledger" "github.com/openmeterio/openmeter/openmeter/ledger/breakage" ledgertestutils "github.com/openmeterio/openmeter/openmeter/ledger/testutils" + transactionstestutils "github.com/openmeterio/openmeter/openmeter/ledger/transactions/testutils" "github.com/openmeterio/openmeter/pkg/currencyx" "github.com/openmeterio/openmeter/pkg/models" ) @@ -25,14 +25,13 @@ func TestAdapter_ListExpiredRecordsFiltersByRoute(t *testing.T) { expiresAt := time.Date(2026, 1, 2, 0, 0, 0, 0, time.UTC) asOf := expiresAt.Add(time.Minute) - breakageSubAccountID := env.BreakageSubAccountWithCostBasis(t, nil).Address().SubAccountID() records := []breakage.Record{ - newExpiredRecord(t, env.CustomerID, env.Currency, "unrestricted", env.CustomerAccounts.FBOAccount, breakageSubAccountID, nil, expiresAt), - newExpiredRecord(t, env.CustomerID, env.Currency, "feature-a", env.CustomerAccounts.FBOAccount, breakageSubAccountID, []string{"feature-a"}, expiresAt), - newExpiredRecord(t, env.CustomerID, env.Currency, "feature-a-b", env.CustomerAccounts.FBOAccount, breakageSubAccountID, []string{"feature-a", "feature-b"}, expiresAt), - newExpiredRecord(t, env.CustomerID, env.Currency, "feature-b", env.CustomerAccounts.FBOAccount, breakageSubAccountID, []string{"feature-b"}, expiresAt), - newExpiredRecord(t, env.CustomerID, currencyx.Code("EUR"), "eur-unrestricted", env.CustomerAccounts.FBOAccount, breakageSubAccountID, nil, expiresAt), + newExpiredRecord(t, env, env.Currency, "unrestricted", nil, expiresAt), + newExpiredRecord(t, env, env.Currency, "feature-a", []string{"feature-a"}, expiresAt), + newExpiredRecord(t, env, env.Currency, "feature-a-b", []string{"feature-a", "feature-b"}, expiresAt), + newExpiredRecord(t, env, env.Currency, "feature-b", []string{"feature-b"}, expiresAt), + newExpiredRecord(t, env, currencyx.Code("EUR"), "eur-unrestricted", nil, expiresAt), } require.NoError(t, a.CreateRecords(t.Context(), breakage.CreateRecordsInput{Records: records})) @@ -102,39 +101,59 @@ func TestAdapter_ListExpiredRecordsFiltersByRoute(t *testing.T) { func newExpiredRecord( t *testing.T, - customerID customer.CustomerID, + env *ledgertestutils.IntegrationEnv, currency currencyx.Code, name string, - fboAccount ledger.CustomerFBOAccount, - breakageSubAccountID string, features []string, expiresAt time.Time, ) breakage.Record { t.Helper() - fboSubAccount, err := fboAccount.GetSubAccountForRoute(t.Context(), ledger.CustomerFBORouteParams{ + fboSubAccount, err := env.CustomerAccounts.FBOAccount.GetSubAccountForRoute(t.Context(), ledger.CustomerFBORouteParams{ Currency: currency, CreditPriority: ledger.DefaultCustomerFBOPriority, Features: features, }) require.NoError(t, err) + breakageSubAccount, err := env.BusinessAccounts.BreakageAccount.GetSubAccountForRoute(t.Context(), ledger.BusinessRouteParams{ + Currency: currency, + }) + require.NoError(t, err) + + txInput := &transactionstestutils.AnyTransactionInput{ + BookedAtValue: expiresAt, + EntryInputsValues: []*transactionstestutils.AnyEntryInput{ + { + Address: fboSubAccount.Address(), + AmountValue: alpacadecimal.NewFromInt(-1), + }, + { + Address: breakageSubAccount.Address(), + AmountValue: alpacadecimal.NewFromInt(1), + }, + }, + } + group, err := env.Deps.HistoricalLedger.CommitGroup(t.Context(), txInput.AsGroupInput(env.Namespace, nil)) + require.NoError(t, err) + require.Len(t, group.Transactions(), 1) + return breakage.Record{ ID: models.NamespacedID{ - Namespace: customerID.Namespace, + Namespace: env.CustomerID.Namespace, ID: ulid.Make().String(), }, Kind: ledger.BreakageKindPlan, Amount: alpacadecimal.NewFromInt(1), - CustomerID: customerID, + CustomerID: env.CustomerID, Currency: currency, CreditPriority: ledger.DefaultCustomerFBOPriority, ExpiresAt: expiresAt, SourceKind: breakage.SourceKindCreditPurchase, - BreakageTransactionGroupID: ulid.Make().String(), - BreakageTransactionID: ulid.Make().String(), + BreakageTransactionGroupID: group.ID().ID, + BreakageTransactionID: group.Transactions()[0].ID().ID, FBOSubAccountID: fboSubAccount.Address().SubAccountID(), - BreakageSubAccountID: breakageSubAccountID, + BreakageSubAccountID: breakageSubAccount.Address().SubAccountID(), Annotations: models.Annotations{ "name": name, }, diff --git a/tools/migrate/migrations/20260706130134_add_ledger_internal_fks.down.sql b/tools/migrate/migrations/20260706130134_add_ledger_internal_fks.down.sql new file mode 100644 index 0000000000..719d621af0 --- /dev/null +++ b/tools/migrate/migrations/20260706130134_add_ledger_internal_fks.down.sql @@ -0,0 +1,4 @@ +-- reverse: modify "ledger_customer_accounts" table +ALTER TABLE "ledger_customer_accounts" DROP CONSTRAINT "ledger_customer_accounts_ledger_accounts_customer_accounts", ALTER COLUMN "account_id" TYPE character varying; +-- reverse: modify "ledger_breakage_records" table +ALTER TABLE "ledger_breakage_records" DROP CONSTRAINT "ledger_breakage_records_ledger_transactions_source_breakage_rec", DROP CONSTRAINT "ledger_breakage_records_ledger_transactions_breakage_records", DROP CONSTRAINT "ledger_breakage_records_ledger_transaction_groups_source_breaka", DROP CONSTRAINT "ledger_breakage_records_ledger_transaction_groups_breakage_reco", DROP CONSTRAINT "ledger_breakage_records_ledger_sub_accounts_fbo_breakage_record", DROP CONSTRAINT "ledger_breakage_records_ledger_sub_accounts_breakage_records", DROP CONSTRAINT "ledger_breakage_records_ledger_entries_source_breakage_records", DROP CONSTRAINT "ledger_breakage_records_ledger_breakage_records_release_reopens", DROP CONSTRAINT "ledger_breakage_records_ledger_breakage_records_planned_release"; diff --git a/tools/migrate/migrations/20260706130134_add_ledger_internal_fks.up.sql b/tools/migrate/migrations/20260706130134_add_ledger_internal_fks.up.sql new file mode 100644 index 0000000000..889ba3ba0f --- /dev/null +++ b/tools/migrate/migrations/20260706130134_add_ledger_internal_fks.up.sql @@ -0,0 +1,6 @@ +-- modify "ledger_breakage_records" table +-- Manual post-generation step: add these foreign keys as NOT VALID so the migration job enforces new writes without validating historical rows. Validate them separately after orphan preflight. +ALTER TABLE "ledger_breakage_records" ADD CONSTRAINT "ledger_breakage_records_ledger_breakage_records_planned_release" FOREIGN KEY ("plan_id") REFERENCES "ledger_breakage_records" ("id") ON UPDATE NO ACTION ON DELETE RESTRICT NOT VALID, ADD CONSTRAINT "ledger_breakage_records_ledger_breakage_records_release_reopens" FOREIGN KEY ("release_id") REFERENCES "ledger_breakage_records" ("id") ON UPDATE NO ACTION ON DELETE RESTRICT NOT VALID, ADD CONSTRAINT "ledger_breakage_records_ledger_entries_source_breakage_records" FOREIGN KEY ("source_entry_id") REFERENCES "ledger_entries" ("id") ON UPDATE NO ACTION ON DELETE RESTRICT NOT VALID, ADD CONSTRAINT "ledger_breakage_records_ledger_sub_accounts_breakage_records" FOREIGN KEY ("breakage_sub_account_id") REFERENCES "ledger_sub_accounts" ("id") ON UPDATE NO ACTION ON DELETE NO ACTION NOT VALID, ADD CONSTRAINT "ledger_breakage_records_ledger_sub_accounts_fbo_breakage_record" FOREIGN KEY ("fbo_sub_account_id") REFERENCES "ledger_sub_accounts" ("id") ON UPDATE NO ACTION ON DELETE NO ACTION NOT VALID, ADD CONSTRAINT "ledger_breakage_records_ledger_transaction_groups_breakage_reco" FOREIGN KEY ("breakage_transaction_group_id") REFERENCES "ledger_transaction_groups" ("id") ON UPDATE NO ACTION ON DELETE NO ACTION NOT VALID, ADD CONSTRAINT "ledger_breakage_records_ledger_transaction_groups_source_breaka" FOREIGN KEY ("source_transaction_group_id") REFERENCES "ledger_transaction_groups" ("id") ON UPDATE NO ACTION ON DELETE RESTRICT NOT VALID, ADD CONSTRAINT "ledger_breakage_records_ledger_transactions_breakage_records" FOREIGN KEY ("breakage_transaction_id") REFERENCES "ledger_transactions" ("id") ON UPDATE NO ACTION ON DELETE NO ACTION NOT VALID, ADD CONSTRAINT "ledger_breakage_records_ledger_transactions_source_breakage_rec" FOREIGN KEY ("source_transaction_id") REFERENCES "ledger_transactions" ("id") ON UPDATE NO ACTION ON DELETE RESTRICT NOT VALID; +-- modify "ledger_customer_accounts" table +-- Manual post-generation step: keep this foreign key NOT VALID for the same rollout reason as above. +ALTER TABLE "ledger_customer_accounts" ALTER COLUMN "account_id" TYPE character(26), ADD CONSTRAINT "ledger_customer_accounts_ledger_accounts_customer_accounts" FOREIGN KEY ("account_id") REFERENCES "ledger_accounts" ("id") ON UPDATE NO ACTION ON DELETE NO ACTION NOT VALID; diff --git a/tools/migrate/migrations/atlas.sum b/tools/migrate/migrations/atlas.sum index 9b6991eba1..63ccfc4f14 100644 --- a/tools/migrate/migrations/atlas.sum +++ b/tools/migrate/migrations/atlas.sum @@ -1,4 +1,4 @@ -h1:QuvnrMCD6JzSpttSUluCLu/s8fX/mas7elUFUCJL+B4= +h1:B8txv2nOhXth25IBNDiu/GaEHdobTJQ76ew6D4r/d4A= 20240826120919_init.up.sql h1:tc1V91/smlmaeJGQ8h+MzTEeFjjnrrFDbDAjOYJK91o= 20240903155435_entitlement-expired-index.up.sql h1:Hp8u5uckmLXc1cRvWU0AtVnnK8ShlpzZNp8pbiJLhac= 20240917172257_billing-entities.up.sql h1:Q1dAMo0Vjiit76OybClNfYPGC5nmvov2/M2W1ioi4Kw= @@ -224,5 +224,6 @@ h1:QuvnrMCD6JzSpttSUluCLu/s8fX/mas7elUFUCJL+B4= 20260630181340_add_breakage_record_source_charge_id.up.sql h1:OLPQPKq1S5J941TXL7tHceMSrvMWk5E/nAc3rAnXhZM= 20260701084156_add_currency_cost_basis_effective_to.up.sql h1:31ASikUUszFmPpArKruD3TeAnTIA7ebqMJdt2DzMH6A= 20260703084504_applied-unit-config-snapshot.up.sql h1:s8DVZu17GDewYm3YbCQusADdv9fbaiiaD5x0WEp/VrU= -20260707142444_om_399_subscription_unit_config.up.sql h1:NfIgaPJWptTtGaxyMzwUV/jts/Z6AVvbp3COxEgDOtQ= -20260709132435_repair_usagebased_deleted_invoice_runs.up.sql h1:4Wo2RUrKLTkYqOqrRyXku75I04OEuycJfJbDqEo3kfI= +20260706130134_add_ledger_internal_fks.up.sql h1:jQkl333hKlRt/dvXKV1bEYfPUdZKPvo2L5254DMpRsY= +20260707142444_om_399_subscription_unit_config.up.sql h1:ouleCP42iBHCGVdxv3LRt5mfEza0S5GcF83E7Bv/D3s= +20260709132435_repair_usagebased_deleted_invoice_runs.up.sql h1:P7YJjTgt8lR5g4K7YeLa2CKjmgHFiVQl9LfbMn9C7dI= From aae08617c938cba188e5b353d2017518436be258 Mon Sep 17 00:00:00 2001 From: Alex Goth <64845621+GAlexIHU@users.noreply.github.com> Date: Tue, 7 Jul 2026 10:14:17 +0200 Subject: [PATCH 2/3] docs(ledger): add FK migration guide --- ...2026-07-07-ledger-internal-foreign-keys.md | 30 +++++++++++++++++++ 1 file changed, 30 insertions(+) create mode 100644 docs/migration-guides/2026-07-07-ledger-internal-foreign-keys.md diff --git a/docs/migration-guides/2026-07-07-ledger-internal-foreign-keys.md b/docs/migration-guides/2026-07-07-ledger-internal-foreign-keys.md new file mode 100644 index 0000000000..cf9ffc69ff --- /dev/null +++ b/docs/migration-guides/2026-07-07-ledger-internal-foreign-keys.md @@ -0,0 +1,30 @@ +# Ledger Internal Foreign Key Validation + +This migration adds foreign keys for ledger-owned references in `ledger_customer_accounts` and `ledger_breakage_records`. + +The migration creates these constraints as `NOT VALID`. New writes are checked immediately, but existing rows are not scanned during the migration. This keeps the migration job short and lets operators validate historical rows separately. + +## Migration Steps + +First, apply OpenMeter migrations as usual. + +After the migration has been applied, validate the new constraints manually: + +```sql +SET lock_timeout = '5s'; +SET statement_timeout = '0'; + +ALTER TABLE ledger_breakage_records VALIDATE CONSTRAINT ledger_breakage_records_ledger_breakage_records_planned_release; +ALTER TABLE ledger_breakage_records VALIDATE CONSTRAINT ledger_breakage_records_ledger_breakage_records_release_reopens; +ALTER TABLE ledger_breakage_records VALIDATE CONSTRAINT ledger_breakage_records_ledger_entries_source_breakage_records; +ALTER TABLE ledger_breakage_records VALIDATE CONSTRAINT ledger_breakage_records_ledger_sub_accounts_breakage_records; +ALTER TABLE ledger_breakage_records VALIDATE CONSTRAINT ledger_breakage_records_ledger_sub_accounts_fbo_breakage_record; +ALTER TABLE ledger_breakage_records VALIDATE CONSTRAINT ledger_breakage_records_ledger_transaction_groups_breakage_reco; +ALTER TABLE ledger_breakage_records VALIDATE CONSTRAINT ledger_breakage_records_ledger_transaction_groups_source_breaka; +ALTER TABLE ledger_breakage_records VALIDATE CONSTRAINT ledger_breakage_records_ledger_transactions_breakage_records; +ALTER TABLE ledger_breakage_records VALIDATE CONSTRAINT ledger_breakage_records_ledger_transactions_source_breakage_rec; + +ALTER TABLE ledger_customer_accounts VALIDATE CONSTRAINT ledger_customer_accounts_ledger_accounts_customer_accounts; +``` + +For large databases, run these statements one at a time. If validation fails, the failed constraint identifies the relationship with orphaned historical rows. Fix those rows and rerun the failed validation statement. From f06b56cd358f3de0962fb4a19f190d4ae7afc51f Mon Sep 17 00:00:00 2001 From: Alex Goth <64845621+GAlexIHU@users.noreply.github.com> Date: Thu, 9 Jul 2026 13:45:53 +0200 Subject: [PATCH 3/3] fix(ledger): move FK migration to tail --- ...ql => 20260709134422_add_ledger_internal_fks.down.sql} | 0 ....sql => 20260709134422_add_ledger_internal_fks.up.sql} | 0 tools/migrate/migrations/atlas.sum | 8 ++++---- 3 files changed, 4 insertions(+), 4 deletions(-) rename tools/migrate/migrations/{20260706130134_add_ledger_internal_fks.down.sql => 20260709134422_add_ledger_internal_fks.down.sql} (100%) rename tools/migrate/migrations/{20260706130134_add_ledger_internal_fks.up.sql => 20260709134422_add_ledger_internal_fks.up.sql} (100%) diff --git a/tools/migrate/migrations/20260706130134_add_ledger_internal_fks.down.sql b/tools/migrate/migrations/20260709134422_add_ledger_internal_fks.down.sql similarity index 100% rename from tools/migrate/migrations/20260706130134_add_ledger_internal_fks.down.sql rename to tools/migrate/migrations/20260709134422_add_ledger_internal_fks.down.sql diff --git a/tools/migrate/migrations/20260706130134_add_ledger_internal_fks.up.sql b/tools/migrate/migrations/20260709134422_add_ledger_internal_fks.up.sql similarity index 100% rename from tools/migrate/migrations/20260706130134_add_ledger_internal_fks.up.sql rename to tools/migrate/migrations/20260709134422_add_ledger_internal_fks.up.sql diff --git a/tools/migrate/migrations/atlas.sum b/tools/migrate/migrations/atlas.sum index 63ccfc4f14..9f053b75ba 100644 --- a/tools/migrate/migrations/atlas.sum +++ b/tools/migrate/migrations/atlas.sum @@ -1,4 +1,4 @@ -h1:B8txv2nOhXth25IBNDiu/GaEHdobTJQ76ew6D4r/d4A= +h1:B9MwpYFJh32EmzJgZD3xN/pXUnEtnug0bOLzTB7wDdw= 20240826120919_init.up.sql h1:tc1V91/smlmaeJGQ8h+MzTEeFjjnrrFDbDAjOYJK91o= 20240903155435_entitlement-expired-index.up.sql h1:Hp8u5uckmLXc1cRvWU0AtVnnK8ShlpzZNp8pbiJLhac= 20240917172257_billing-entities.up.sql h1:Q1dAMo0Vjiit76OybClNfYPGC5nmvov2/M2W1ioi4Kw= @@ -224,6 +224,6 @@ h1:B8txv2nOhXth25IBNDiu/GaEHdobTJQ76ew6D4r/d4A= 20260630181340_add_breakage_record_source_charge_id.up.sql h1:OLPQPKq1S5J941TXL7tHceMSrvMWk5E/nAc3rAnXhZM= 20260701084156_add_currency_cost_basis_effective_to.up.sql h1:31ASikUUszFmPpArKruD3TeAnTIA7ebqMJdt2DzMH6A= 20260703084504_applied-unit-config-snapshot.up.sql h1:s8DVZu17GDewYm3YbCQusADdv9fbaiiaD5x0WEp/VrU= -20260706130134_add_ledger_internal_fks.up.sql h1:jQkl333hKlRt/dvXKV1bEYfPUdZKPvo2L5254DMpRsY= -20260707142444_om_399_subscription_unit_config.up.sql h1:ouleCP42iBHCGVdxv3LRt5mfEza0S5GcF83E7Bv/D3s= -20260709132435_repair_usagebased_deleted_invoice_runs.up.sql h1:P7YJjTgt8lR5g4K7YeLa2CKjmgHFiVQl9LfbMn9C7dI= +20260707142444_om_399_subscription_unit_config.up.sql h1:NfIgaPJWptTtGaxyMzwUV/jts/Z6AVvbp3COxEgDOtQ= +20260709132435_repair_usagebased_deleted_invoice_runs.up.sql h1:4Wo2RUrKLTkYqOqrRyXku75I04OEuycJfJbDqEo3kfI= +20260709134422_add_ledger_internal_fks.up.sql h1:JE6z1+A8Vg64F0hwyr3RnoLXu/BdFKf3JD6wLJM9LG0=