97c441dab6
* implement highAvailability feature --------- Co-authored-by: Marco Mariani <marco@crowdsec.net>
8370 lines
243 KiB
Go
8370 lines
243 KiB
Go
// Code generated by ent, DO NOT EDIT.
|
|
|
|
package ent
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"sync"
|
|
"time"
|
|
|
|
"entgo.io/ent"
|
|
"entgo.io/ent/dialect/sql"
|
|
"github.com/crowdsecurity/crowdsec/pkg/database/ent/alert"
|
|
"github.com/crowdsecurity/crowdsec/pkg/database/ent/bouncer"
|
|
"github.com/crowdsecurity/crowdsec/pkg/database/ent/configitem"
|
|
"github.com/crowdsecurity/crowdsec/pkg/database/ent/decision"
|
|
"github.com/crowdsecurity/crowdsec/pkg/database/ent/event"
|
|
"github.com/crowdsecurity/crowdsec/pkg/database/ent/lock"
|
|
"github.com/crowdsecurity/crowdsec/pkg/database/ent/machine"
|
|
"github.com/crowdsecurity/crowdsec/pkg/database/ent/meta"
|
|
"github.com/crowdsecurity/crowdsec/pkg/database/ent/predicate"
|
|
)
|
|
|
|
const (
|
|
// Operation types.
|
|
OpCreate = ent.OpCreate
|
|
OpDelete = ent.OpDelete
|
|
OpDeleteOne = ent.OpDeleteOne
|
|
OpUpdate = ent.OpUpdate
|
|
OpUpdateOne = ent.OpUpdateOne
|
|
|
|
// Node types.
|
|
TypeAlert = "Alert"
|
|
TypeBouncer = "Bouncer"
|
|
TypeConfigItem = "ConfigItem"
|
|
TypeDecision = "Decision"
|
|
TypeEvent = "Event"
|
|
TypeLock = "Lock"
|
|
TypeMachine = "Machine"
|
|
TypeMeta = "Meta"
|
|
)
|
|
|
|
// AlertMutation represents an operation that mutates the Alert nodes in the graph.
|
|
type AlertMutation struct {
|
|
config
|
|
op Op
|
|
typ string
|
|
id *int
|
|
created_at *time.Time
|
|
updated_at *time.Time
|
|
scenario *string
|
|
bucketId *string
|
|
message *string
|
|
eventsCount *int32
|
|
addeventsCount *int32
|
|
startedAt *time.Time
|
|
stoppedAt *time.Time
|
|
sourceIp *string
|
|
sourceRange *string
|
|
sourceAsNumber *string
|
|
sourceAsName *string
|
|
sourceCountry *string
|
|
sourceLatitude *float32
|
|
addsourceLatitude *float32
|
|
sourceLongitude *float32
|
|
addsourceLongitude *float32
|
|
sourceScope *string
|
|
sourceValue *string
|
|
capacity *int32
|
|
addcapacity *int32
|
|
leakSpeed *string
|
|
scenarioVersion *string
|
|
scenarioHash *string
|
|
simulated *bool
|
|
uuid *string
|
|
clearedFields map[string]struct{}
|
|
owner *int
|
|
clearedowner bool
|
|
decisions map[int]struct{}
|
|
removeddecisions map[int]struct{}
|
|
cleareddecisions bool
|
|
events map[int]struct{}
|
|
removedevents map[int]struct{}
|
|
clearedevents bool
|
|
metas map[int]struct{}
|
|
removedmetas map[int]struct{}
|
|
clearedmetas bool
|
|
done bool
|
|
oldValue func(context.Context) (*Alert, error)
|
|
predicates []predicate.Alert
|
|
}
|
|
|
|
var _ ent.Mutation = (*AlertMutation)(nil)
|
|
|
|
// alertOption allows management of the mutation configuration using functional options.
|
|
type alertOption func(*AlertMutation)
|
|
|
|
// newAlertMutation creates new mutation for the Alert entity.
|
|
func newAlertMutation(c config, op Op, opts ...alertOption) *AlertMutation {
|
|
m := &AlertMutation{
|
|
config: c,
|
|
op: op,
|
|
typ: TypeAlert,
|
|
clearedFields: make(map[string]struct{}),
|
|
}
|
|
for _, opt := range opts {
|
|
opt(m)
|
|
}
|
|
return m
|
|
}
|
|
|
|
// withAlertID sets the ID field of the mutation.
|
|
func withAlertID(id int) alertOption {
|
|
return func(m *AlertMutation) {
|
|
var (
|
|
err error
|
|
once sync.Once
|
|
value *Alert
|
|
)
|
|
m.oldValue = func(ctx context.Context) (*Alert, error) {
|
|
once.Do(func() {
|
|
if m.done {
|
|
err = errors.New("querying old values post mutation is not allowed")
|
|
} else {
|
|
value, err = m.Client().Alert.Get(ctx, id)
|
|
}
|
|
})
|
|
return value, err
|
|
}
|
|
m.id = &id
|
|
}
|
|
}
|
|
|
|
// withAlert sets the old Alert of the mutation.
|
|
func withAlert(node *Alert) alertOption {
|
|
return func(m *AlertMutation) {
|
|
m.oldValue = func(context.Context) (*Alert, error) {
|
|
return node, nil
|
|
}
|
|
m.id = &node.ID
|
|
}
|
|
}
|
|
|
|
// Client returns a new `ent.Client` from the mutation. If the mutation was
|
|
// executed in a transaction (ent.Tx), a transactional client is returned.
|
|
func (m AlertMutation) Client() *Client {
|
|
client := &Client{config: m.config}
|
|
client.init()
|
|
return client
|
|
}
|
|
|
|
// Tx returns an `ent.Tx` for mutations that were executed in transactions;
|
|
// it returns an error otherwise.
|
|
func (m AlertMutation) Tx() (*Tx, error) {
|
|
if _, ok := m.driver.(*txDriver); !ok {
|
|
return nil, errors.New("ent: mutation is not running in a transaction")
|
|
}
|
|
tx := &Tx{config: m.config}
|
|
tx.init()
|
|
return tx, nil
|
|
}
|
|
|
|
// ID returns the ID value in the mutation. Note that the ID is only available
|
|
// if it was provided to the builder or after it was returned from the database.
|
|
func (m *AlertMutation) ID() (id int, exists bool) {
|
|
if m.id == nil {
|
|
return
|
|
}
|
|
return *m.id, true
|
|
}
|
|
|
|
// IDs queries the database and returns the entity ids that match the mutation's predicate.
|
|
// That means, if the mutation is applied within a transaction with an isolation level such
|
|
// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
|
|
// or updated by the mutation.
|
|
func (m *AlertMutation) IDs(ctx context.Context) ([]int, error) {
|
|
switch {
|
|
case m.op.Is(OpUpdateOne | OpDeleteOne):
|
|
id, exists := m.ID()
|
|
if exists {
|
|
return []int{id}, nil
|
|
}
|
|
fallthrough
|
|
case m.op.Is(OpUpdate | OpDelete):
|
|
return m.Client().Alert.Query().Where(m.predicates...).IDs(ctx)
|
|
default:
|
|
return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
|
|
}
|
|
}
|
|
|
|
// SetCreatedAt sets the "created_at" field.
|
|
func (m *AlertMutation) SetCreatedAt(t time.Time) {
|
|
m.created_at = &t
|
|
}
|
|
|
|
// CreatedAt returns the value of the "created_at" field in the mutation.
|
|
func (m *AlertMutation) CreatedAt() (r time.Time, exists bool) {
|
|
v := m.created_at
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldCreatedAt returns the old "created_at" field's value of the Alert entity.
|
|
// If the Alert object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *AlertMutation) OldCreatedAt(ctx context.Context) (v *time.Time, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldCreatedAt requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldCreatedAt: %w", err)
|
|
}
|
|
return oldValue.CreatedAt, nil
|
|
}
|
|
|
|
// ClearCreatedAt clears the value of the "created_at" field.
|
|
func (m *AlertMutation) ClearCreatedAt() {
|
|
m.created_at = nil
|
|
m.clearedFields[alert.FieldCreatedAt] = struct{}{}
|
|
}
|
|
|
|
// CreatedAtCleared returns if the "created_at" field was cleared in this mutation.
|
|
func (m *AlertMutation) CreatedAtCleared() bool {
|
|
_, ok := m.clearedFields[alert.FieldCreatedAt]
|
|
return ok
|
|
}
|
|
|
|
// ResetCreatedAt resets all changes to the "created_at" field.
|
|
func (m *AlertMutation) ResetCreatedAt() {
|
|
m.created_at = nil
|
|
delete(m.clearedFields, alert.FieldCreatedAt)
|
|
}
|
|
|
|
// SetUpdatedAt sets the "updated_at" field.
|
|
func (m *AlertMutation) SetUpdatedAt(t time.Time) {
|
|
m.updated_at = &t
|
|
}
|
|
|
|
// UpdatedAt returns the value of the "updated_at" field in the mutation.
|
|
func (m *AlertMutation) UpdatedAt() (r time.Time, exists bool) {
|
|
v := m.updated_at
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldUpdatedAt returns the old "updated_at" field's value of the Alert entity.
|
|
// If the Alert object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *AlertMutation) OldUpdatedAt(ctx context.Context) (v *time.Time, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldUpdatedAt requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldUpdatedAt: %w", err)
|
|
}
|
|
return oldValue.UpdatedAt, nil
|
|
}
|
|
|
|
// ClearUpdatedAt clears the value of the "updated_at" field.
|
|
func (m *AlertMutation) ClearUpdatedAt() {
|
|
m.updated_at = nil
|
|
m.clearedFields[alert.FieldUpdatedAt] = struct{}{}
|
|
}
|
|
|
|
// UpdatedAtCleared returns if the "updated_at" field was cleared in this mutation.
|
|
func (m *AlertMutation) UpdatedAtCleared() bool {
|
|
_, ok := m.clearedFields[alert.FieldUpdatedAt]
|
|
return ok
|
|
}
|
|
|
|
// ResetUpdatedAt resets all changes to the "updated_at" field.
|
|
func (m *AlertMutation) ResetUpdatedAt() {
|
|
m.updated_at = nil
|
|
delete(m.clearedFields, alert.FieldUpdatedAt)
|
|
}
|
|
|
|
// SetScenario sets the "scenario" field.
|
|
func (m *AlertMutation) SetScenario(s string) {
|
|
m.scenario = &s
|
|
}
|
|
|
|
// Scenario returns the value of the "scenario" field in the mutation.
|
|
func (m *AlertMutation) Scenario() (r string, exists bool) {
|
|
v := m.scenario
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldScenario returns the old "scenario" field's value of the Alert entity.
|
|
// If the Alert object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *AlertMutation) OldScenario(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldScenario is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldScenario requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldScenario: %w", err)
|
|
}
|
|
return oldValue.Scenario, nil
|
|
}
|
|
|
|
// ResetScenario resets all changes to the "scenario" field.
|
|
func (m *AlertMutation) ResetScenario() {
|
|
m.scenario = nil
|
|
}
|
|
|
|
// SetBucketId sets the "bucketId" field.
|
|
func (m *AlertMutation) SetBucketId(s string) {
|
|
m.bucketId = &s
|
|
}
|
|
|
|
// BucketId returns the value of the "bucketId" field in the mutation.
|
|
func (m *AlertMutation) BucketId() (r string, exists bool) {
|
|
v := m.bucketId
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldBucketId returns the old "bucketId" field's value of the Alert entity.
|
|
// If the Alert object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *AlertMutation) OldBucketId(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldBucketId is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldBucketId requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldBucketId: %w", err)
|
|
}
|
|
return oldValue.BucketId, nil
|
|
}
|
|
|
|
// ClearBucketId clears the value of the "bucketId" field.
|
|
func (m *AlertMutation) ClearBucketId() {
|
|
m.bucketId = nil
|
|
m.clearedFields[alert.FieldBucketId] = struct{}{}
|
|
}
|
|
|
|
// BucketIdCleared returns if the "bucketId" field was cleared in this mutation.
|
|
func (m *AlertMutation) BucketIdCleared() bool {
|
|
_, ok := m.clearedFields[alert.FieldBucketId]
|
|
return ok
|
|
}
|
|
|
|
// ResetBucketId resets all changes to the "bucketId" field.
|
|
func (m *AlertMutation) ResetBucketId() {
|
|
m.bucketId = nil
|
|
delete(m.clearedFields, alert.FieldBucketId)
|
|
}
|
|
|
|
// SetMessage sets the "message" field.
|
|
func (m *AlertMutation) SetMessage(s string) {
|
|
m.message = &s
|
|
}
|
|
|
|
// Message returns the value of the "message" field in the mutation.
|
|
func (m *AlertMutation) Message() (r string, exists bool) {
|
|
v := m.message
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldMessage returns the old "message" field's value of the Alert entity.
|
|
// If the Alert object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *AlertMutation) OldMessage(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldMessage is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldMessage requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldMessage: %w", err)
|
|
}
|
|
return oldValue.Message, nil
|
|
}
|
|
|
|
// ClearMessage clears the value of the "message" field.
|
|
func (m *AlertMutation) ClearMessage() {
|
|
m.message = nil
|
|
m.clearedFields[alert.FieldMessage] = struct{}{}
|
|
}
|
|
|
|
// MessageCleared returns if the "message" field was cleared in this mutation.
|
|
func (m *AlertMutation) MessageCleared() bool {
|
|
_, ok := m.clearedFields[alert.FieldMessage]
|
|
return ok
|
|
}
|
|
|
|
// ResetMessage resets all changes to the "message" field.
|
|
func (m *AlertMutation) ResetMessage() {
|
|
m.message = nil
|
|
delete(m.clearedFields, alert.FieldMessage)
|
|
}
|
|
|
|
// SetEventsCount sets the "eventsCount" field.
|
|
func (m *AlertMutation) SetEventsCount(i int32) {
|
|
m.eventsCount = &i
|
|
m.addeventsCount = nil
|
|
}
|
|
|
|
// EventsCount returns the value of the "eventsCount" field in the mutation.
|
|
func (m *AlertMutation) EventsCount() (r int32, exists bool) {
|
|
v := m.eventsCount
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldEventsCount returns the old "eventsCount" field's value of the Alert entity.
|
|
// If the Alert object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *AlertMutation) OldEventsCount(ctx context.Context) (v int32, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldEventsCount is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldEventsCount requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldEventsCount: %w", err)
|
|
}
|
|
return oldValue.EventsCount, nil
|
|
}
|
|
|
|
// AddEventsCount adds i to the "eventsCount" field.
|
|
func (m *AlertMutation) AddEventsCount(i int32) {
|
|
if m.addeventsCount != nil {
|
|
*m.addeventsCount += i
|
|
} else {
|
|
m.addeventsCount = &i
|
|
}
|
|
}
|
|
|
|
// AddedEventsCount returns the value that was added to the "eventsCount" field in this mutation.
|
|
func (m *AlertMutation) AddedEventsCount() (r int32, exists bool) {
|
|
v := m.addeventsCount
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// ClearEventsCount clears the value of the "eventsCount" field.
|
|
func (m *AlertMutation) ClearEventsCount() {
|
|
m.eventsCount = nil
|
|
m.addeventsCount = nil
|
|
m.clearedFields[alert.FieldEventsCount] = struct{}{}
|
|
}
|
|
|
|
// EventsCountCleared returns if the "eventsCount" field was cleared in this mutation.
|
|
func (m *AlertMutation) EventsCountCleared() bool {
|
|
_, ok := m.clearedFields[alert.FieldEventsCount]
|
|
return ok
|
|
}
|
|
|
|
// ResetEventsCount resets all changes to the "eventsCount" field.
|
|
func (m *AlertMutation) ResetEventsCount() {
|
|
m.eventsCount = nil
|
|
m.addeventsCount = nil
|
|
delete(m.clearedFields, alert.FieldEventsCount)
|
|
}
|
|
|
|
// SetStartedAt sets the "startedAt" field.
|
|
func (m *AlertMutation) SetStartedAt(t time.Time) {
|
|
m.startedAt = &t
|
|
}
|
|
|
|
// StartedAt returns the value of the "startedAt" field in the mutation.
|
|
func (m *AlertMutation) StartedAt() (r time.Time, exists bool) {
|
|
v := m.startedAt
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldStartedAt returns the old "startedAt" field's value of the Alert entity.
|
|
// If the Alert object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *AlertMutation) OldStartedAt(ctx context.Context) (v time.Time, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldStartedAt is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldStartedAt requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldStartedAt: %w", err)
|
|
}
|
|
return oldValue.StartedAt, nil
|
|
}
|
|
|
|
// ClearStartedAt clears the value of the "startedAt" field.
|
|
func (m *AlertMutation) ClearStartedAt() {
|
|
m.startedAt = nil
|
|
m.clearedFields[alert.FieldStartedAt] = struct{}{}
|
|
}
|
|
|
|
// StartedAtCleared returns if the "startedAt" field was cleared in this mutation.
|
|
func (m *AlertMutation) StartedAtCleared() bool {
|
|
_, ok := m.clearedFields[alert.FieldStartedAt]
|
|
return ok
|
|
}
|
|
|
|
// ResetStartedAt resets all changes to the "startedAt" field.
|
|
func (m *AlertMutation) ResetStartedAt() {
|
|
m.startedAt = nil
|
|
delete(m.clearedFields, alert.FieldStartedAt)
|
|
}
|
|
|
|
// SetStoppedAt sets the "stoppedAt" field.
|
|
func (m *AlertMutation) SetStoppedAt(t time.Time) {
|
|
m.stoppedAt = &t
|
|
}
|
|
|
|
// StoppedAt returns the value of the "stoppedAt" field in the mutation.
|
|
func (m *AlertMutation) StoppedAt() (r time.Time, exists bool) {
|
|
v := m.stoppedAt
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldStoppedAt returns the old "stoppedAt" field's value of the Alert entity.
|
|
// If the Alert object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *AlertMutation) OldStoppedAt(ctx context.Context) (v time.Time, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldStoppedAt is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldStoppedAt requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldStoppedAt: %w", err)
|
|
}
|
|
return oldValue.StoppedAt, nil
|
|
}
|
|
|
|
// ClearStoppedAt clears the value of the "stoppedAt" field.
|
|
func (m *AlertMutation) ClearStoppedAt() {
|
|
m.stoppedAt = nil
|
|
m.clearedFields[alert.FieldStoppedAt] = struct{}{}
|
|
}
|
|
|
|
// StoppedAtCleared returns if the "stoppedAt" field was cleared in this mutation.
|
|
func (m *AlertMutation) StoppedAtCleared() bool {
|
|
_, ok := m.clearedFields[alert.FieldStoppedAt]
|
|
return ok
|
|
}
|
|
|
|
// ResetStoppedAt resets all changes to the "stoppedAt" field.
|
|
func (m *AlertMutation) ResetStoppedAt() {
|
|
m.stoppedAt = nil
|
|
delete(m.clearedFields, alert.FieldStoppedAt)
|
|
}
|
|
|
|
// SetSourceIp sets the "sourceIp" field.
|
|
func (m *AlertMutation) SetSourceIp(s string) {
|
|
m.sourceIp = &s
|
|
}
|
|
|
|
// SourceIp returns the value of the "sourceIp" field in the mutation.
|
|
func (m *AlertMutation) SourceIp() (r string, exists bool) {
|
|
v := m.sourceIp
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldSourceIp returns the old "sourceIp" field's value of the Alert entity.
|
|
// If the Alert object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *AlertMutation) OldSourceIp(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldSourceIp is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldSourceIp requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldSourceIp: %w", err)
|
|
}
|
|
return oldValue.SourceIp, nil
|
|
}
|
|
|
|
// ClearSourceIp clears the value of the "sourceIp" field.
|
|
func (m *AlertMutation) ClearSourceIp() {
|
|
m.sourceIp = nil
|
|
m.clearedFields[alert.FieldSourceIp] = struct{}{}
|
|
}
|
|
|
|
// SourceIpCleared returns if the "sourceIp" field was cleared in this mutation.
|
|
func (m *AlertMutation) SourceIpCleared() bool {
|
|
_, ok := m.clearedFields[alert.FieldSourceIp]
|
|
return ok
|
|
}
|
|
|
|
// ResetSourceIp resets all changes to the "sourceIp" field.
|
|
func (m *AlertMutation) ResetSourceIp() {
|
|
m.sourceIp = nil
|
|
delete(m.clearedFields, alert.FieldSourceIp)
|
|
}
|
|
|
|
// SetSourceRange sets the "sourceRange" field.
|
|
func (m *AlertMutation) SetSourceRange(s string) {
|
|
m.sourceRange = &s
|
|
}
|
|
|
|
// SourceRange returns the value of the "sourceRange" field in the mutation.
|
|
func (m *AlertMutation) SourceRange() (r string, exists bool) {
|
|
v := m.sourceRange
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldSourceRange returns the old "sourceRange" field's value of the Alert entity.
|
|
// If the Alert object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *AlertMutation) OldSourceRange(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldSourceRange is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldSourceRange requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldSourceRange: %w", err)
|
|
}
|
|
return oldValue.SourceRange, nil
|
|
}
|
|
|
|
// ClearSourceRange clears the value of the "sourceRange" field.
|
|
func (m *AlertMutation) ClearSourceRange() {
|
|
m.sourceRange = nil
|
|
m.clearedFields[alert.FieldSourceRange] = struct{}{}
|
|
}
|
|
|
|
// SourceRangeCleared returns if the "sourceRange" field was cleared in this mutation.
|
|
func (m *AlertMutation) SourceRangeCleared() bool {
|
|
_, ok := m.clearedFields[alert.FieldSourceRange]
|
|
return ok
|
|
}
|
|
|
|
// ResetSourceRange resets all changes to the "sourceRange" field.
|
|
func (m *AlertMutation) ResetSourceRange() {
|
|
m.sourceRange = nil
|
|
delete(m.clearedFields, alert.FieldSourceRange)
|
|
}
|
|
|
|
// SetSourceAsNumber sets the "sourceAsNumber" field.
|
|
func (m *AlertMutation) SetSourceAsNumber(s string) {
|
|
m.sourceAsNumber = &s
|
|
}
|
|
|
|
// SourceAsNumber returns the value of the "sourceAsNumber" field in the mutation.
|
|
func (m *AlertMutation) SourceAsNumber() (r string, exists bool) {
|
|
v := m.sourceAsNumber
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldSourceAsNumber returns the old "sourceAsNumber" field's value of the Alert entity.
|
|
// If the Alert object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *AlertMutation) OldSourceAsNumber(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldSourceAsNumber is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldSourceAsNumber requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldSourceAsNumber: %w", err)
|
|
}
|
|
return oldValue.SourceAsNumber, nil
|
|
}
|
|
|
|
// ClearSourceAsNumber clears the value of the "sourceAsNumber" field.
|
|
func (m *AlertMutation) ClearSourceAsNumber() {
|
|
m.sourceAsNumber = nil
|
|
m.clearedFields[alert.FieldSourceAsNumber] = struct{}{}
|
|
}
|
|
|
|
// SourceAsNumberCleared returns if the "sourceAsNumber" field was cleared in this mutation.
|
|
func (m *AlertMutation) SourceAsNumberCleared() bool {
|
|
_, ok := m.clearedFields[alert.FieldSourceAsNumber]
|
|
return ok
|
|
}
|
|
|
|
// ResetSourceAsNumber resets all changes to the "sourceAsNumber" field.
|
|
func (m *AlertMutation) ResetSourceAsNumber() {
|
|
m.sourceAsNumber = nil
|
|
delete(m.clearedFields, alert.FieldSourceAsNumber)
|
|
}
|
|
|
|
// SetSourceAsName sets the "sourceAsName" field.
|
|
func (m *AlertMutation) SetSourceAsName(s string) {
|
|
m.sourceAsName = &s
|
|
}
|
|
|
|
// SourceAsName returns the value of the "sourceAsName" field in the mutation.
|
|
func (m *AlertMutation) SourceAsName() (r string, exists bool) {
|
|
v := m.sourceAsName
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldSourceAsName returns the old "sourceAsName" field's value of the Alert entity.
|
|
// If the Alert object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *AlertMutation) OldSourceAsName(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldSourceAsName is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldSourceAsName requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldSourceAsName: %w", err)
|
|
}
|
|
return oldValue.SourceAsName, nil
|
|
}
|
|
|
|
// ClearSourceAsName clears the value of the "sourceAsName" field.
|
|
func (m *AlertMutation) ClearSourceAsName() {
|
|
m.sourceAsName = nil
|
|
m.clearedFields[alert.FieldSourceAsName] = struct{}{}
|
|
}
|
|
|
|
// SourceAsNameCleared returns if the "sourceAsName" field was cleared in this mutation.
|
|
func (m *AlertMutation) SourceAsNameCleared() bool {
|
|
_, ok := m.clearedFields[alert.FieldSourceAsName]
|
|
return ok
|
|
}
|
|
|
|
// ResetSourceAsName resets all changes to the "sourceAsName" field.
|
|
func (m *AlertMutation) ResetSourceAsName() {
|
|
m.sourceAsName = nil
|
|
delete(m.clearedFields, alert.FieldSourceAsName)
|
|
}
|
|
|
|
// SetSourceCountry sets the "sourceCountry" field.
|
|
func (m *AlertMutation) SetSourceCountry(s string) {
|
|
m.sourceCountry = &s
|
|
}
|
|
|
|
// SourceCountry returns the value of the "sourceCountry" field in the mutation.
|
|
func (m *AlertMutation) SourceCountry() (r string, exists bool) {
|
|
v := m.sourceCountry
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldSourceCountry returns the old "sourceCountry" field's value of the Alert entity.
|
|
// If the Alert object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *AlertMutation) OldSourceCountry(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldSourceCountry is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldSourceCountry requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldSourceCountry: %w", err)
|
|
}
|
|
return oldValue.SourceCountry, nil
|
|
}
|
|
|
|
// ClearSourceCountry clears the value of the "sourceCountry" field.
|
|
func (m *AlertMutation) ClearSourceCountry() {
|
|
m.sourceCountry = nil
|
|
m.clearedFields[alert.FieldSourceCountry] = struct{}{}
|
|
}
|
|
|
|
// SourceCountryCleared returns if the "sourceCountry" field was cleared in this mutation.
|
|
func (m *AlertMutation) SourceCountryCleared() bool {
|
|
_, ok := m.clearedFields[alert.FieldSourceCountry]
|
|
return ok
|
|
}
|
|
|
|
// ResetSourceCountry resets all changes to the "sourceCountry" field.
|
|
func (m *AlertMutation) ResetSourceCountry() {
|
|
m.sourceCountry = nil
|
|
delete(m.clearedFields, alert.FieldSourceCountry)
|
|
}
|
|
|
|
// SetSourceLatitude sets the "sourceLatitude" field.
|
|
func (m *AlertMutation) SetSourceLatitude(f float32) {
|
|
m.sourceLatitude = &f
|
|
m.addsourceLatitude = nil
|
|
}
|
|
|
|
// SourceLatitude returns the value of the "sourceLatitude" field in the mutation.
|
|
func (m *AlertMutation) SourceLatitude() (r float32, exists bool) {
|
|
v := m.sourceLatitude
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldSourceLatitude returns the old "sourceLatitude" field's value of the Alert entity.
|
|
// If the Alert object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *AlertMutation) OldSourceLatitude(ctx context.Context) (v float32, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldSourceLatitude is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldSourceLatitude requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldSourceLatitude: %w", err)
|
|
}
|
|
return oldValue.SourceLatitude, nil
|
|
}
|
|
|
|
// AddSourceLatitude adds f to the "sourceLatitude" field.
|
|
func (m *AlertMutation) AddSourceLatitude(f float32) {
|
|
if m.addsourceLatitude != nil {
|
|
*m.addsourceLatitude += f
|
|
} else {
|
|
m.addsourceLatitude = &f
|
|
}
|
|
}
|
|
|
|
// AddedSourceLatitude returns the value that was added to the "sourceLatitude" field in this mutation.
|
|
func (m *AlertMutation) AddedSourceLatitude() (r float32, exists bool) {
|
|
v := m.addsourceLatitude
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// ClearSourceLatitude clears the value of the "sourceLatitude" field.
|
|
func (m *AlertMutation) ClearSourceLatitude() {
|
|
m.sourceLatitude = nil
|
|
m.addsourceLatitude = nil
|
|
m.clearedFields[alert.FieldSourceLatitude] = struct{}{}
|
|
}
|
|
|
|
// SourceLatitudeCleared returns if the "sourceLatitude" field was cleared in this mutation.
|
|
func (m *AlertMutation) SourceLatitudeCleared() bool {
|
|
_, ok := m.clearedFields[alert.FieldSourceLatitude]
|
|
return ok
|
|
}
|
|
|
|
// ResetSourceLatitude resets all changes to the "sourceLatitude" field.
|
|
func (m *AlertMutation) ResetSourceLatitude() {
|
|
m.sourceLatitude = nil
|
|
m.addsourceLatitude = nil
|
|
delete(m.clearedFields, alert.FieldSourceLatitude)
|
|
}
|
|
|
|
// SetSourceLongitude sets the "sourceLongitude" field.
|
|
func (m *AlertMutation) SetSourceLongitude(f float32) {
|
|
m.sourceLongitude = &f
|
|
m.addsourceLongitude = nil
|
|
}
|
|
|
|
// SourceLongitude returns the value of the "sourceLongitude" field in the mutation.
|
|
func (m *AlertMutation) SourceLongitude() (r float32, exists bool) {
|
|
v := m.sourceLongitude
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldSourceLongitude returns the old "sourceLongitude" field's value of the Alert entity.
|
|
// If the Alert object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *AlertMutation) OldSourceLongitude(ctx context.Context) (v float32, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldSourceLongitude is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldSourceLongitude requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldSourceLongitude: %w", err)
|
|
}
|
|
return oldValue.SourceLongitude, nil
|
|
}
|
|
|
|
// AddSourceLongitude adds f to the "sourceLongitude" field.
|
|
func (m *AlertMutation) AddSourceLongitude(f float32) {
|
|
if m.addsourceLongitude != nil {
|
|
*m.addsourceLongitude += f
|
|
} else {
|
|
m.addsourceLongitude = &f
|
|
}
|
|
}
|
|
|
|
// AddedSourceLongitude returns the value that was added to the "sourceLongitude" field in this mutation.
|
|
func (m *AlertMutation) AddedSourceLongitude() (r float32, exists bool) {
|
|
v := m.addsourceLongitude
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// ClearSourceLongitude clears the value of the "sourceLongitude" field.
|
|
func (m *AlertMutation) ClearSourceLongitude() {
|
|
m.sourceLongitude = nil
|
|
m.addsourceLongitude = nil
|
|
m.clearedFields[alert.FieldSourceLongitude] = struct{}{}
|
|
}
|
|
|
|
// SourceLongitudeCleared returns if the "sourceLongitude" field was cleared in this mutation.
|
|
func (m *AlertMutation) SourceLongitudeCleared() bool {
|
|
_, ok := m.clearedFields[alert.FieldSourceLongitude]
|
|
return ok
|
|
}
|
|
|
|
// ResetSourceLongitude resets all changes to the "sourceLongitude" field.
|
|
func (m *AlertMutation) ResetSourceLongitude() {
|
|
m.sourceLongitude = nil
|
|
m.addsourceLongitude = nil
|
|
delete(m.clearedFields, alert.FieldSourceLongitude)
|
|
}
|
|
|
|
// SetSourceScope sets the "sourceScope" field.
|
|
func (m *AlertMutation) SetSourceScope(s string) {
|
|
m.sourceScope = &s
|
|
}
|
|
|
|
// SourceScope returns the value of the "sourceScope" field in the mutation.
|
|
func (m *AlertMutation) SourceScope() (r string, exists bool) {
|
|
v := m.sourceScope
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldSourceScope returns the old "sourceScope" field's value of the Alert entity.
|
|
// If the Alert object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *AlertMutation) OldSourceScope(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldSourceScope is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldSourceScope requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldSourceScope: %w", err)
|
|
}
|
|
return oldValue.SourceScope, nil
|
|
}
|
|
|
|
// ClearSourceScope clears the value of the "sourceScope" field.
|
|
func (m *AlertMutation) ClearSourceScope() {
|
|
m.sourceScope = nil
|
|
m.clearedFields[alert.FieldSourceScope] = struct{}{}
|
|
}
|
|
|
|
// SourceScopeCleared returns if the "sourceScope" field was cleared in this mutation.
|
|
func (m *AlertMutation) SourceScopeCleared() bool {
|
|
_, ok := m.clearedFields[alert.FieldSourceScope]
|
|
return ok
|
|
}
|
|
|
|
// ResetSourceScope resets all changes to the "sourceScope" field.
|
|
func (m *AlertMutation) ResetSourceScope() {
|
|
m.sourceScope = nil
|
|
delete(m.clearedFields, alert.FieldSourceScope)
|
|
}
|
|
|
|
// SetSourceValue sets the "sourceValue" field.
|
|
func (m *AlertMutation) SetSourceValue(s string) {
|
|
m.sourceValue = &s
|
|
}
|
|
|
|
// SourceValue returns the value of the "sourceValue" field in the mutation.
|
|
func (m *AlertMutation) SourceValue() (r string, exists bool) {
|
|
v := m.sourceValue
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldSourceValue returns the old "sourceValue" field's value of the Alert entity.
|
|
// If the Alert object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *AlertMutation) OldSourceValue(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldSourceValue is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldSourceValue requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldSourceValue: %w", err)
|
|
}
|
|
return oldValue.SourceValue, nil
|
|
}
|
|
|
|
// ClearSourceValue clears the value of the "sourceValue" field.
|
|
func (m *AlertMutation) ClearSourceValue() {
|
|
m.sourceValue = nil
|
|
m.clearedFields[alert.FieldSourceValue] = struct{}{}
|
|
}
|
|
|
|
// SourceValueCleared returns if the "sourceValue" field was cleared in this mutation.
|
|
func (m *AlertMutation) SourceValueCleared() bool {
|
|
_, ok := m.clearedFields[alert.FieldSourceValue]
|
|
return ok
|
|
}
|
|
|
|
// ResetSourceValue resets all changes to the "sourceValue" field.
|
|
func (m *AlertMutation) ResetSourceValue() {
|
|
m.sourceValue = nil
|
|
delete(m.clearedFields, alert.FieldSourceValue)
|
|
}
|
|
|
|
// SetCapacity sets the "capacity" field.
|
|
func (m *AlertMutation) SetCapacity(i int32) {
|
|
m.capacity = &i
|
|
m.addcapacity = nil
|
|
}
|
|
|
|
// Capacity returns the value of the "capacity" field in the mutation.
|
|
func (m *AlertMutation) Capacity() (r int32, exists bool) {
|
|
v := m.capacity
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldCapacity returns the old "capacity" field's value of the Alert entity.
|
|
// If the Alert object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *AlertMutation) OldCapacity(ctx context.Context) (v int32, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldCapacity is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldCapacity requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldCapacity: %w", err)
|
|
}
|
|
return oldValue.Capacity, nil
|
|
}
|
|
|
|
// AddCapacity adds i to the "capacity" field.
|
|
func (m *AlertMutation) AddCapacity(i int32) {
|
|
if m.addcapacity != nil {
|
|
*m.addcapacity += i
|
|
} else {
|
|
m.addcapacity = &i
|
|
}
|
|
}
|
|
|
|
// AddedCapacity returns the value that was added to the "capacity" field in this mutation.
|
|
func (m *AlertMutation) AddedCapacity() (r int32, exists bool) {
|
|
v := m.addcapacity
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// ClearCapacity clears the value of the "capacity" field.
|
|
func (m *AlertMutation) ClearCapacity() {
|
|
m.capacity = nil
|
|
m.addcapacity = nil
|
|
m.clearedFields[alert.FieldCapacity] = struct{}{}
|
|
}
|
|
|
|
// CapacityCleared returns if the "capacity" field was cleared in this mutation.
|
|
func (m *AlertMutation) CapacityCleared() bool {
|
|
_, ok := m.clearedFields[alert.FieldCapacity]
|
|
return ok
|
|
}
|
|
|
|
// ResetCapacity resets all changes to the "capacity" field.
|
|
func (m *AlertMutation) ResetCapacity() {
|
|
m.capacity = nil
|
|
m.addcapacity = nil
|
|
delete(m.clearedFields, alert.FieldCapacity)
|
|
}
|
|
|
|
// SetLeakSpeed sets the "leakSpeed" field.
|
|
func (m *AlertMutation) SetLeakSpeed(s string) {
|
|
m.leakSpeed = &s
|
|
}
|
|
|
|
// LeakSpeed returns the value of the "leakSpeed" field in the mutation.
|
|
func (m *AlertMutation) LeakSpeed() (r string, exists bool) {
|
|
v := m.leakSpeed
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldLeakSpeed returns the old "leakSpeed" field's value of the Alert entity.
|
|
// If the Alert object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *AlertMutation) OldLeakSpeed(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldLeakSpeed is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldLeakSpeed requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldLeakSpeed: %w", err)
|
|
}
|
|
return oldValue.LeakSpeed, nil
|
|
}
|
|
|
|
// ClearLeakSpeed clears the value of the "leakSpeed" field.
|
|
func (m *AlertMutation) ClearLeakSpeed() {
|
|
m.leakSpeed = nil
|
|
m.clearedFields[alert.FieldLeakSpeed] = struct{}{}
|
|
}
|
|
|
|
// LeakSpeedCleared returns if the "leakSpeed" field was cleared in this mutation.
|
|
func (m *AlertMutation) LeakSpeedCleared() bool {
|
|
_, ok := m.clearedFields[alert.FieldLeakSpeed]
|
|
return ok
|
|
}
|
|
|
|
// ResetLeakSpeed resets all changes to the "leakSpeed" field.
|
|
func (m *AlertMutation) ResetLeakSpeed() {
|
|
m.leakSpeed = nil
|
|
delete(m.clearedFields, alert.FieldLeakSpeed)
|
|
}
|
|
|
|
// SetScenarioVersion sets the "scenarioVersion" field.
|
|
func (m *AlertMutation) SetScenarioVersion(s string) {
|
|
m.scenarioVersion = &s
|
|
}
|
|
|
|
// ScenarioVersion returns the value of the "scenarioVersion" field in the mutation.
|
|
func (m *AlertMutation) ScenarioVersion() (r string, exists bool) {
|
|
v := m.scenarioVersion
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldScenarioVersion returns the old "scenarioVersion" field's value of the Alert entity.
|
|
// If the Alert object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *AlertMutation) OldScenarioVersion(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldScenarioVersion is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldScenarioVersion requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldScenarioVersion: %w", err)
|
|
}
|
|
return oldValue.ScenarioVersion, nil
|
|
}
|
|
|
|
// ClearScenarioVersion clears the value of the "scenarioVersion" field.
|
|
func (m *AlertMutation) ClearScenarioVersion() {
|
|
m.scenarioVersion = nil
|
|
m.clearedFields[alert.FieldScenarioVersion] = struct{}{}
|
|
}
|
|
|
|
// ScenarioVersionCleared returns if the "scenarioVersion" field was cleared in this mutation.
|
|
func (m *AlertMutation) ScenarioVersionCleared() bool {
|
|
_, ok := m.clearedFields[alert.FieldScenarioVersion]
|
|
return ok
|
|
}
|
|
|
|
// ResetScenarioVersion resets all changes to the "scenarioVersion" field.
|
|
func (m *AlertMutation) ResetScenarioVersion() {
|
|
m.scenarioVersion = nil
|
|
delete(m.clearedFields, alert.FieldScenarioVersion)
|
|
}
|
|
|
|
// SetScenarioHash sets the "scenarioHash" field.
|
|
func (m *AlertMutation) SetScenarioHash(s string) {
|
|
m.scenarioHash = &s
|
|
}
|
|
|
|
// ScenarioHash returns the value of the "scenarioHash" field in the mutation.
|
|
func (m *AlertMutation) ScenarioHash() (r string, exists bool) {
|
|
v := m.scenarioHash
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldScenarioHash returns the old "scenarioHash" field's value of the Alert entity.
|
|
// If the Alert object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *AlertMutation) OldScenarioHash(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldScenarioHash is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldScenarioHash requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldScenarioHash: %w", err)
|
|
}
|
|
return oldValue.ScenarioHash, nil
|
|
}
|
|
|
|
// ClearScenarioHash clears the value of the "scenarioHash" field.
|
|
func (m *AlertMutation) ClearScenarioHash() {
|
|
m.scenarioHash = nil
|
|
m.clearedFields[alert.FieldScenarioHash] = struct{}{}
|
|
}
|
|
|
|
// ScenarioHashCleared returns if the "scenarioHash" field was cleared in this mutation.
|
|
func (m *AlertMutation) ScenarioHashCleared() bool {
|
|
_, ok := m.clearedFields[alert.FieldScenarioHash]
|
|
return ok
|
|
}
|
|
|
|
// ResetScenarioHash resets all changes to the "scenarioHash" field.
|
|
func (m *AlertMutation) ResetScenarioHash() {
|
|
m.scenarioHash = nil
|
|
delete(m.clearedFields, alert.FieldScenarioHash)
|
|
}
|
|
|
|
// SetSimulated sets the "simulated" field.
|
|
func (m *AlertMutation) SetSimulated(b bool) {
|
|
m.simulated = &b
|
|
}
|
|
|
|
// Simulated returns the value of the "simulated" field in the mutation.
|
|
func (m *AlertMutation) Simulated() (r bool, exists bool) {
|
|
v := m.simulated
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldSimulated returns the old "simulated" field's value of the Alert entity.
|
|
// If the Alert object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *AlertMutation) OldSimulated(ctx context.Context) (v bool, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldSimulated is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldSimulated requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldSimulated: %w", err)
|
|
}
|
|
return oldValue.Simulated, nil
|
|
}
|
|
|
|
// ResetSimulated resets all changes to the "simulated" field.
|
|
func (m *AlertMutation) ResetSimulated() {
|
|
m.simulated = nil
|
|
}
|
|
|
|
// SetUUID sets the "uuid" field.
|
|
func (m *AlertMutation) SetUUID(s string) {
|
|
m.uuid = &s
|
|
}
|
|
|
|
// UUID returns the value of the "uuid" field in the mutation.
|
|
func (m *AlertMutation) UUID() (r string, exists bool) {
|
|
v := m.uuid
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldUUID returns the old "uuid" field's value of the Alert entity.
|
|
// If the Alert object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *AlertMutation) OldUUID(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldUUID is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldUUID requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldUUID: %w", err)
|
|
}
|
|
return oldValue.UUID, nil
|
|
}
|
|
|
|
// ClearUUID clears the value of the "uuid" field.
|
|
func (m *AlertMutation) ClearUUID() {
|
|
m.uuid = nil
|
|
m.clearedFields[alert.FieldUUID] = struct{}{}
|
|
}
|
|
|
|
// UUIDCleared returns if the "uuid" field was cleared in this mutation.
|
|
func (m *AlertMutation) UUIDCleared() bool {
|
|
_, ok := m.clearedFields[alert.FieldUUID]
|
|
return ok
|
|
}
|
|
|
|
// ResetUUID resets all changes to the "uuid" field.
|
|
func (m *AlertMutation) ResetUUID() {
|
|
m.uuid = nil
|
|
delete(m.clearedFields, alert.FieldUUID)
|
|
}
|
|
|
|
// SetOwnerID sets the "owner" edge to the Machine entity by id.
|
|
func (m *AlertMutation) SetOwnerID(id int) {
|
|
m.owner = &id
|
|
}
|
|
|
|
// ClearOwner clears the "owner" edge to the Machine entity.
|
|
func (m *AlertMutation) ClearOwner() {
|
|
m.clearedowner = true
|
|
}
|
|
|
|
// OwnerCleared reports if the "owner" edge to the Machine entity was cleared.
|
|
func (m *AlertMutation) OwnerCleared() bool {
|
|
return m.clearedowner
|
|
}
|
|
|
|
// OwnerID returns the "owner" edge ID in the mutation.
|
|
func (m *AlertMutation) OwnerID() (id int, exists bool) {
|
|
if m.owner != nil {
|
|
return *m.owner, true
|
|
}
|
|
return
|
|
}
|
|
|
|
// OwnerIDs returns the "owner" edge IDs in the mutation.
|
|
// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use
|
|
// OwnerID instead. It exists only for internal usage by the builders.
|
|
func (m *AlertMutation) OwnerIDs() (ids []int) {
|
|
if id := m.owner; id != nil {
|
|
ids = append(ids, *id)
|
|
}
|
|
return
|
|
}
|
|
|
|
// ResetOwner resets all changes to the "owner" edge.
|
|
func (m *AlertMutation) ResetOwner() {
|
|
m.owner = nil
|
|
m.clearedowner = false
|
|
}
|
|
|
|
// AddDecisionIDs adds the "decisions" edge to the Decision entity by ids.
|
|
func (m *AlertMutation) AddDecisionIDs(ids ...int) {
|
|
if m.decisions == nil {
|
|
m.decisions = make(map[int]struct{})
|
|
}
|
|
for i := range ids {
|
|
m.decisions[ids[i]] = struct{}{}
|
|
}
|
|
}
|
|
|
|
// ClearDecisions clears the "decisions" edge to the Decision entity.
|
|
func (m *AlertMutation) ClearDecisions() {
|
|
m.cleareddecisions = true
|
|
}
|
|
|
|
// DecisionsCleared reports if the "decisions" edge to the Decision entity was cleared.
|
|
func (m *AlertMutation) DecisionsCleared() bool {
|
|
return m.cleareddecisions
|
|
}
|
|
|
|
// RemoveDecisionIDs removes the "decisions" edge to the Decision entity by IDs.
|
|
func (m *AlertMutation) RemoveDecisionIDs(ids ...int) {
|
|
if m.removeddecisions == nil {
|
|
m.removeddecisions = make(map[int]struct{})
|
|
}
|
|
for i := range ids {
|
|
delete(m.decisions, ids[i])
|
|
m.removeddecisions[ids[i]] = struct{}{}
|
|
}
|
|
}
|
|
|
|
// RemovedDecisions returns the removed IDs of the "decisions" edge to the Decision entity.
|
|
func (m *AlertMutation) RemovedDecisionsIDs() (ids []int) {
|
|
for id := range m.removeddecisions {
|
|
ids = append(ids, id)
|
|
}
|
|
return
|
|
}
|
|
|
|
// DecisionsIDs returns the "decisions" edge IDs in the mutation.
|
|
func (m *AlertMutation) DecisionsIDs() (ids []int) {
|
|
for id := range m.decisions {
|
|
ids = append(ids, id)
|
|
}
|
|
return
|
|
}
|
|
|
|
// ResetDecisions resets all changes to the "decisions" edge.
|
|
func (m *AlertMutation) ResetDecisions() {
|
|
m.decisions = nil
|
|
m.cleareddecisions = false
|
|
m.removeddecisions = nil
|
|
}
|
|
|
|
// AddEventIDs adds the "events" edge to the Event entity by ids.
|
|
func (m *AlertMutation) AddEventIDs(ids ...int) {
|
|
if m.events == nil {
|
|
m.events = make(map[int]struct{})
|
|
}
|
|
for i := range ids {
|
|
m.events[ids[i]] = struct{}{}
|
|
}
|
|
}
|
|
|
|
// ClearEvents clears the "events" edge to the Event entity.
|
|
func (m *AlertMutation) ClearEvents() {
|
|
m.clearedevents = true
|
|
}
|
|
|
|
// EventsCleared reports if the "events" edge to the Event entity was cleared.
|
|
func (m *AlertMutation) EventsCleared() bool {
|
|
return m.clearedevents
|
|
}
|
|
|
|
// RemoveEventIDs removes the "events" edge to the Event entity by IDs.
|
|
func (m *AlertMutation) RemoveEventIDs(ids ...int) {
|
|
if m.removedevents == nil {
|
|
m.removedevents = make(map[int]struct{})
|
|
}
|
|
for i := range ids {
|
|
delete(m.events, ids[i])
|
|
m.removedevents[ids[i]] = struct{}{}
|
|
}
|
|
}
|
|
|
|
// RemovedEvents returns the removed IDs of the "events" edge to the Event entity.
|
|
func (m *AlertMutation) RemovedEventsIDs() (ids []int) {
|
|
for id := range m.removedevents {
|
|
ids = append(ids, id)
|
|
}
|
|
return
|
|
}
|
|
|
|
// EventsIDs returns the "events" edge IDs in the mutation.
|
|
func (m *AlertMutation) EventsIDs() (ids []int) {
|
|
for id := range m.events {
|
|
ids = append(ids, id)
|
|
}
|
|
return
|
|
}
|
|
|
|
// ResetEvents resets all changes to the "events" edge.
|
|
func (m *AlertMutation) ResetEvents() {
|
|
m.events = nil
|
|
m.clearedevents = false
|
|
m.removedevents = nil
|
|
}
|
|
|
|
// AddMetaIDs adds the "metas" edge to the Meta entity by ids.
|
|
func (m *AlertMutation) AddMetaIDs(ids ...int) {
|
|
if m.metas == nil {
|
|
m.metas = make(map[int]struct{})
|
|
}
|
|
for i := range ids {
|
|
m.metas[ids[i]] = struct{}{}
|
|
}
|
|
}
|
|
|
|
// ClearMetas clears the "metas" edge to the Meta entity.
|
|
func (m *AlertMutation) ClearMetas() {
|
|
m.clearedmetas = true
|
|
}
|
|
|
|
// MetasCleared reports if the "metas" edge to the Meta entity was cleared.
|
|
func (m *AlertMutation) MetasCleared() bool {
|
|
return m.clearedmetas
|
|
}
|
|
|
|
// RemoveMetaIDs removes the "metas" edge to the Meta entity by IDs.
|
|
func (m *AlertMutation) RemoveMetaIDs(ids ...int) {
|
|
if m.removedmetas == nil {
|
|
m.removedmetas = make(map[int]struct{})
|
|
}
|
|
for i := range ids {
|
|
delete(m.metas, ids[i])
|
|
m.removedmetas[ids[i]] = struct{}{}
|
|
}
|
|
}
|
|
|
|
// RemovedMetas returns the removed IDs of the "metas" edge to the Meta entity.
|
|
func (m *AlertMutation) RemovedMetasIDs() (ids []int) {
|
|
for id := range m.removedmetas {
|
|
ids = append(ids, id)
|
|
}
|
|
return
|
|
}
|
|
|
|
// MetasIDs returns the "metas" edge IDs in the mutation.
|
|
func (m *AlertMutation) MetasIDs() (ids []int) {
|
|
for id := range m.metas {
|
|
ids = append(ids, id)
|
|
}
|
|
return
|
|
}
|
|
|
|
// ResetMetas resets all changes to the "metas" edge.
|
|
func (m *AlertMutation) ResetMetas() {
|
|
m.metas = nil
|
|
m.clearedmetas = false
|
|
m.removedmetas = nil
|
|
}
|
|
|
|
// Where appends a list predicates to the AlertMutation builder.
|
|
func (m *AlertMutation) Where(ps ...predicate.Alert) {
|
|
m.predicates = append(m.predicates, ps...)
|
|
}
|
|
|
|
// WhereP appends storage-level predicates to the AlertMutation builder. Using this method,
|
|
// users can use type-assertion to append predicates that do not depend on any generated package.
|
|
func (m *AlertMutation) WhereP(ps ...func(*sql.Selector)) {
|
|
p := make([]predicate.Alert, len(ps))
|
|
for i := range ps {
|
|
p[i] = ps[i]
|
|
}
|
|
m.Where(p...)
|
|
}
|
|
|
|
// Op returns the operation name.
|
|
func (m *AlertMutation) Op() Op {
|
|
return m.op
|
|
}
|
|
|
|
// SetOp allows setting the mutation operation.
|
|
func (m *AlertMutation) SetOp(op Op) {
|
|
m.op = op
|
|
}
|
|
|
|
// Type returns the node type of this mutation (Alert).
|
|
func (m *AlertMutation) Type() string {
|
|
return m.typ
|
|
}
|
|
|
|
// Fields returns all fields that were changed during this mutation. Note that in
|
|
// order to get all numeric fields that were incremented/decremented, call
|
|
// AddedFields().
|
|
func (m *AlertMutation) Fields() []string {
|
|
fields := make([]string, 0, 23)
|
|
if m.created_at != nil {
|
|
fields = append(fields, alert.FieldCreatedAt)
|
|
}
|
|
if m.updated_at != nil {
|
|
fields = append(fields, alert.FieldUpdatedAt)
|
|
}
|
|
if m.scenario != nil {
|
|
fields = append(fields, alert.FieldScenario)
|
|
}
|
|
if m.bucketId != nil {
|
|
fields = append(fields, alert.FieldBucketId)
|
|
}
|
|
if m.message != nil {
|
|
fields = append(fields, alert.FieldMessage)
|
|
}
|
|
if m.eventsCount != nil {
|
|
fields = append(fields, alert.FieldEventsCount)
|
|
}
|
|
if m.startedAt != nil {
|
|
fields = append(fields, alert.FieldStartedAt)
|
|
}
|
|
if m.stoppedAt != nil {
|
|
fields = append(fields, alert.FieldStoppedAt)
|
|
}
|
|
if m.sourceIp != nil {
|
|
fields = append(fields, alert.FieldSourceIp)
|
|
}
|
|
if m.sourceRange != nil {
|
|
fields = append(fields, alert.FieldSourceRange)
|
|
}
|
|
if m.sourceAsNumber != nil {
|
|
fields = append(fields, alert.FieldSourceAsNumber)
|
|
}
|
|
if m.sourceAsName != nil {
|
|
fields = append(fields, alert.FieldSourceAsName)
|
|
}
|
|
if m.sourceCountry != nil {
|
|
fields = append(fields, alert.FieldSourceCountry)
|
|
}
|
|
if m.sourceLatitude != nil {
|
|
fields = append(fields, alert.FieldSourceLatitude)
|
|
}
|
|
if m.sourceLongitude != nil {
|
|
fields = append(fields, alert.FieldSourceLongitude)
|
|
}
|
|
if m.sourceScope != nil {
|
|
fields = append(fields, alert.FieldSourceScope)
|
|
}
|
|
if m.sourceValue != nil {
|
|
fields = append(fields, alert.FieldSourceValue)
|
|
}
|
|
if m.capacity != nil {
|
|
fields = append(fields, alert.FieldCapacity)
|
|
}
|
|
if m.leakSpeed != nil {
|
|
fields = append(fields, alert.FieldLeakSpeed)
|
|
}
|
|
if m.scenarioVersion != nil {
|
|
fields = append(fields, alert.FieldScenarioVersion)
|
|
}
|
|
if m.scenarioHash != nil {
|
|
fields = append(fields, alert.FieldScenarioHash)
|
|
}
|
|
if m.simulated != nil {
|
|
fields = append(fields, alert.FieldSimulated)
|
|
}
|
|
if m.uuid != nil {
|
|
fields = append(fields, alert.FieldUUID)
|
|
}
|
|
return fields
|
|
}
|
|
|
|
// Field returns the value of a field with the given name. The second boolean
|
|
// return value indicates that this field was not set, or was not defined in the
|
|
// schema.
|
|
func (m *AlertMutation) Field(name string) (ent.Value, bool) {
|
|
switch name {
|
|
case alert.FieldCreatedAt:
|
|
return m.CreatedAt()
|
|
case alert.FieldUpdatedAt:
|
|
return m.UpdatedAt()
|
|
case alert.FieldScenario:
|
|
return m.Scenario()
|
|
case alert.FieldBucketId:
|
|
return m.BucketId()
|
|
case alert.FieldMessage:
|
|
return m.Message()
|
|
case alert.FieldEventsCount:
|
|
return m.EventsCount()
|
|
case alert.FieldStartedAt:
|
|
return m.StartedAt()
|
|
case alert.FieldStoppedAt:
|
|
return m.StoppedAt()
|
|
case alert.FieldSourceIp:
|
|
return m.SourceIp()
|
|
case alert.FieldSourceRange:
|
|
return m.SourceRange()
|
|
case alert.FieldSourceAsNumber:
|
|
return m.SourceAsNumber()
|
|
case alert.FieldSourceAsName:
|
|
return m.SourceAsName()
|
|
case alert.FieldSourceCountry:
|
|
return m.SourceCountry()
|
|
case alert.FieldSourceLatitude:
|
|
return m.SourceLatitude()
|
|
case alert.FieldSourceLongitude:
|
|
return m.SourceLongitude()
|
|
case alert.FieldSourceScope:
|
|
return m.SourceScope()
|
|
case alert.FieldSourceValue:
|
|
return m.SourceValue()
|
|
case alert.FieldCapacity:
|
|
return m.Capacity()
|
|
case alert.FieldLeakSpeed:
|
|
return m.LeakSpeed()
|
|
case alert.FieldScenarioVersion:
|
|
return m.ScenarioVersion()
|
|
case alert.FieldScenarioHash:
|
|
return m.ScenarioHash()
|
|
case alert.FieldSimulated:
|
|
return m.Simulated()
|
|
case alert.FieldUUID:
|
|
return m.UUID()
|
|
}
|
|
return nil, false
|
|
}
|
|
|
|
// OldField returns the old value of the field from the database. An error is
|
|
// returned if the mutation operation is not UpdateOne, or the query to the
|
|
// database failed.
|
|
func (m *AlertMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
|
|
switch name {
|
|
case alert.FieldCreatedAt:
|
|
return m.OldCreatedAt(ctx)
|
|
case alert.FieldUpdatedAt:
|
|
return m.OldUpdatedAt(ctx)
|
|
case alert.FieldScenario:
|
|
return m.OldScenario(ctx)
|
|
case alert.FieldBucketId:
|
|
return m.OldBucketId(ctx)
|
|
case alert.FieldMessage:
|
|
return m.OldMessage(ctx)
|
|
case alert.FieldEventsCount:
|
|
return m.OldEventsCount(ctx)
|
|
case alert.FieldStartedAt:
|
|
return m.OldStartedAt(ctx)
|
|
case alert.FieldStoppedAt:
|
|
return m.OldStoppedAt(ctx)
|
|
case alert.FieldSourceIp:
|
|
return m.OldSourceIp(ctx)
|
|
case alert.FieldSourceRange:
|
|
return m.OldSourceRange(ctx)
|
|
case alert.FieldSourceAsNumber:
|
|
return m.OldSourceAsNumber(ctx)
|
|
case alert.FieldSourceAsName:
|
|
return m.OldSourceAsName(ctx)
|
|
case alert.FieldSourceCountry:
|
|
return m.OldSourceCountry(ctx)
|
|
case alert.FieldSourceLatitude:
|
|
return m.OldSourceLatitude(ctx)
|
|
case alert.FieldSourceLongitude:
|
|
return m.OldSourceLongitude(ctx)
|
|
case alert.FieldSourceScope:
|
|
return m.OldSourceScope(ctx)
|
|
case alert.FieldSourceValue:
|
|
return m.OldSourceValue(ctx)
|
|
case alert.FieldCapacity:
|
|
return m.OldCapacity(ctx)
|
|
case alert.FieldLeakSpeed:
|
|
return m.OldLeakSpeed(ctx)
|
|
case alert.FieldScenarioVersion:
|
|
return m.OldScenarioVersion(ctx)
|
|
case alert.FieldScenarioHash:
|
|
return m.OldScenarioHash(ctx)
|
|
case alert.FieldSimulated:
|
|
return m.OldSimulated(ctx)
|
|
case alert.FieldUUID:
|
|
return m.OldUUID(ctx)
|
|
}
|
|
return nil, fmt.Errorf("unknown Alert field %s", name)
|
|
}
|
|
|
|
// SetField sets the value of a field with the given name. It returns an error if
|
|
// the field is not defined in the schema, or if the type mismatched the field
|
|
// type.
|
|
func (m *AlertMutation) SetField(name string, value ent.Value) error {
|
|
switch name {
|
|
case alert.FieldCreatedAt:
|
|
v, ok := value.(time.Time)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetCreatedAt(v)
|
|
return nil
|
|
case alert.FieldUpdatedAt:
|
|
v, ok := value.(time.Time)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetUpdatedAt(v)
|
|
return nil
|
|
case alert.FieldScenario:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetScenario(v)
|
|
return nil
|
|
case alert.FieldBucketId:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetBucketId(v)
|
|
return nil
|
|
case alert.FieldMessage:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetMessage(v)
|
|
return nil
|
|
case alert.FieldEventsCount:
|
|
v, ok := value.(int32)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetEventsCount(v)
|
|
return nil
|
|
case alert.FieldStartedAt:
|
|
v, ok := value.(time.Time)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetStartedAt(v)
|
|
return nil
|
|
case alert.FieldStoppedAt:
|
|
v, ok := value.(time.Time)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetStoppedAt(v)
|
|
return nil
|
|
case alert.FieldSourceIp:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetSourceIp(v)
|
|
return nil
|
|
case alert.FieldSourceRange:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetSourceRange(v)
|
|
return nil
|
|
case alert.FieldSourceAsNumber:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetSourceAsNumber(v)
|
|
return nil
|
|
case alert.FieldSourceAsName:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetSourceAsName(v)
|
|
return nil
|
|
case alert.FieldSourceCountry:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetSourceCountry(v)
|
|
return nil
|
|
case alert.FieldSourceLatitude:
|
|
v, ok := value.(float32)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetSourceLatitude(v)
|
|
return nil
|
|
case alert.FieldSourceLongitude:
|
|
v, ok := value.(float32)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetSourceLongitude(v)
|
|
return nil
|
|
case alert.FieldSourceScope:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetSourceScope(v)
|
|
return nil
|
|
case alert.FieldSourceValue:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetSourceValue(v)
|
|
return nil
|
|
case alert.FieldCapacity:
|
|
v, ok := value.(int32)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetCapacity(v)
|
|
return nil
|
|
case alert.FieldLeakSpeed:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetLeakSpeed(v)
|
|
return nil
|
|
case alert.FieldScenarioVersion:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetScenarioVersion(v)
|
|
return nil
|
|
case alert.FieldScenarioHash:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetScenarioHash(v)
|
|
return nil
|
|
case alert.FieldSimulated:
|
|
v, ok := value.(bool)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetSimulated(v)
|
|
return nil
|
|
case alert.FieldUUID:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetUUID(v)
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Alert field %s", name)
|
|
}
|
|
|
|
// AddedFields returns all numeric fields that were incremented/decremented during
|
|
// this mutation.
|
|
func (m *AlertMutation) AddedFields() []string {
|
|
var fields []string
|
|
if m.addeventsCount != nil {
|
|
fields = append(fields, alert.FieldEventsCount)
|
|
}
|
|
if m.addsourceLatitude != nil {
|
|
fields = append(fields, alert.FieldSourceLatitude)
|
|
}
|
|
if m.addsourceLongitude != nil {
|
|
fields = append(fields, alert.FieldSourceLongitude)
|
|
}
|
|
if m.addcapacity != nil {
|
|
fields = append(fields, alert.FieldCapacity)
|
|
}
|
|
return fields
|
|
}
|
|
|
|
// AddedField returns the numeric value that was incremented/decremented on a field
|
|
// with the given name. The second boolean return value indicates that this field
|
|
// was not set, or was not defined in the schema.
|
|
func (m *AlertMutation) AddedField(name string) (ent.Value, bool) {
|
|
switch name {
|
|
case alert.FieldEventsCount:
|
|
return m.AddedEventsCount()
|
|
case alert.FieldSourceLatitude:
|
|
return m.AddedSourceLatitude()
|
|
case alert.FieldSourceLongitude:
|
|
return m.AddedSourceLongitude()
|
|
case alert.FieldCapacity:
|
|
return m.AddedCapacity()
|
|
}
|
|
return nil, false
|
|
}
|
|
|
|
// AddField adds the value to the field with the given name. It returns an error if
|
|
// the field is not defined in the schema, or if the type mismatched the field
|
|
// type.
|
|
func (m *AlertMutation) AddField(name string, value ent.Value) error {
|
|
switch name {
|
|
case alert.FieldEventsCount:
|
|
v, ok := value.(int32)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.AddEventsCount(v)
|
|
return nil
|
|
case alert.FieldSourceLatitude:
|
|
v, ok := value.(float32)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.AddSourceLatitude(v)
|
|
return nil
|
|
case alert.FieldSourceLongitude:
|
|
v, ok := value.(float32)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.AddSourceLongitude(v)
|
|
return nil
|
|
case alert.FieldCapacity:
|
|
v, ok := value.(int32)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.AddCapacity(v)
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Alert numeric field %s", name)
|
|
}
|
|
|
|
// ClearedFields returns all nullable fields that were cleared during this
|
|
// mutation.
|
|
func (m *AlertMutation) ClearedFields() []string {
|
|
var fields []string
|
|
if m.FieldCleared(alert.FieldCreatedAt) {
|
|
fields = append(fields, alert.FieldCreatedAt)
|
|
}
|
|
if m.FieldCleared(alert.FieldUpdatedAt) {
|
|
fields = append(fields, alert.FieldUpdatedAt)
|
|
}
|
|
if m.FieldCleared(alert.FieldBucketId) {
|
|
fields = append(fields, alert.FieldBucketId)
|
|
}
|
|
if m.FieldCleared(alert.FieldMessage) {
|
|
fields = append(fields, alert.FieldMessage)
|
|
}
|
|
if m.FieldCleared(alert.FieldEventsCount) {
|
|
fields = append(fields, alert.FieldEventsCount)
|
|
}
|
|
if m.FieldCleared(alert.FieldStartedAt) {
|
|
fields = append(fields, alert.FieldStartedAt)
|
|
}
|
|
if m.FieldCleared(alert.FieldStoppedAt) {
|
|
fields = append(fields, alert.FieldStoppedAt)
|
|
}
|
|
if m.FieldCleared(alert.FieldSourceIp) {
|
|
fields = append(fields, alert.FieldSourceIp)
|
|
}
|
|
if m.FieldCleared(alert.FieldSourceRange) {
|
|
fields = append(fields, alert.FieldSourceRange)
|
|
}
|
|
if m.FieldCleared(alert.FieldSourceAsNumber) {
|
|
fields = append(fields, alert.FieldSourceAsNumber)
|
|
}
|
|
if m.FieldCleared(alert.FieldSourceAsName) {
|
|
fields = append(fields, alert.FieldSourceAsName)
|
|
}
|
|
if m.FieldCleared(alert.FieldSourceCountry) {
|
|
fields = append(fields, alert.FieldSourceCountry)
|
|
}
|
|
if m.FieldCleared(alert.FieldSourceLatitude) {
|
|
fields = append(fields, alert.FieldSourceLatitude)
|
|
}
|
|
if m.FieldCleared(alert.FieldSourceLongitude) {
|
|
fields = append(fields, alert.FieldSourceLongitude)
|
|
}
|
|
if m.FieldCleared(alert.FieldSourceScope) {
|
|
fields = append(fields, alert.FieldSourceScope)
|
|
}
|
|
if m.FieldCleared(alert.FieldSourceValue) {
|
|
fields = append(fields, alert.FieldSourceValue)
|
|
}
|
|
if m.FieldCleared(alert.FieldCapacity) {
|
|
fields = append(fields, alert.FieldCapacity)
|
|
}
|
|
if m.FieldCleared(alert.FieldLeakSpeed) {
|
|
fields = append(fields, alert.FieldLeakSpeed)
|
|
}
|
|
if m.FieldCleared(alert.FieldScenarioVersion) {
|
|
fields = append(fields, alert.FieldScenarioVersion)
|
|
}
|
|
if m.FieldCleared(alert.FieldScenarioHash) {
|
|
fields = append(fields, alert.FieldScenarioHash)
|
|
}
|
|
if m.FieldCleared(alert.FieldUUID) {
|
|
fields = append(fields, alert.FieldUUID)
|
|
}
|
|
return fields
|
|
}
|
|
|
|
// FieldCleared returns a boolean indicating if a field with the given name was
|
|
// cleared in this mutation.
|
|
func (m *AlertMutation) FieldCleared(name string) bool {
|
|
_, ok := m.clearedFields[name]
|
|
return ok
|
|
}
|
|
|
|
// ClearField clears the value of the field with the given name. It returns an
|
|
// error if the field is not defined in the schema.
|
|
func (m *AlertMutation) ClearField(name string) error {
|
|
switch name {
|
|
case alert.FieldCreatedAt:
|
|
m.ClearCreatedAt()
|
|
return nil
|
|
case alert.FieldUpdatedAt:
|
|
m.ClearUpdatedAt()
|
|
return nil
|
|
case alert.FieldBucketId:
|
|
m.ClearBucketId()
|
|
return nil
|
|
case alert.FieldMessage:
|
|
m.ClearMessage()
|
|
return nil
|
|
case alert.FieldEventsCount:
|
|
m.ClearEventsCount()
|
|
return nil
|
|
case alert.FieldStartedAt:
|
|
m.ClearStartedAt()
|
|
return nil
|
|
case alert.FieldStoppedAt:
|
|
m.ClearStoppedAt()
|
|
return nil
|
|
case alert.FieldSourceIp:
|
|
m.ClearSourceIp()
|
|
return nil
|
|
case alert.FieldSourceRange:
|
|
m.ClearSourceRange()
|
|
return nil
|
|
case alert.FieldSourceAsNumber:
|
|
m.ClearSourceAsNumber()
|
|
return nil
|
|
case alert.FieldSourceAsName:
|
|
m.ClearSourceAsName()
|
|
return nil
|
|
case alert.FieldSourceCountry:
|
|
m.ClearSourceCountry()
|
|
return nil
|
|
case alert.FieldSourceLatitude:
|
|
m.ClearSourceLatitude()
|
|
return nil
|
|
case alert.FieldSourceLongitude:
|
|
m.ClearSourceLongitude()
|
|
return nil
|
|
case alert.FieldSourceScope:
|
|
m.ClearSourceScope()
|
|
return nil
|
|
case alert.FieldSourceValue:
|
|
m.ClearSourceValue()
|
|
return nil
|
|
case alert.FieldCapacity:
|
|
m.ClearCapacity()
|
|
return nil
|
|
case alert.FieldLeakSpeed:
|
|
m.ClearLeakSpeed()
|
|
return nil
|
|
case alert.FieldScenarioVersion:
|
|
m.ClearScenarioVersion()
|
|
return nil
|
|
case alert.FieldScenarioHash:
|
|
m.ClearScenarioHash()
|
|
return nil
|
|
case alert.FieldUUID:
|
|
m.ClearUUID()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Alert nullable field %s", name)
|
|
}
|
|
|
|
// ResetField resets all changes in the mutation for the field with the given name.
|
|
// It returns an error if the field is not defined in the schema.
|
|
func (m *AlertMutation) ResetField(name string) error {
|
|
switch name {
|
|
case alert.FieldCreatedAt:
|
|
m.ResetCreatedAt()
|
|
return nil
|
|
case alert.FieldUpdatedAt:
|
|
m.ResetUpdatedAt()
|
|
return nil
|
|
case alert.FieldScenario:
|
|
m.ResetScenario()
|
|
return nil
|
|
case alert.FieldBucketId:
|
|
m.ResetBucketId()
|
|
return nil
|
|
case alert.FieldMessage:
|
|
m.ResetMessage()
|
|
return nil
|
|
case alert.FieldEventsCount:
|
|
m.ResetEventsCount()
|
|
return nil
|
|
case alert.FieldStartedAt:
|
|
m.ResetStartedAt()
|
|
return nil
|
|
case alert.FieldStoppedAt:
|
|
m.ResetStoppedAt()
|
|
return nil
|
|
case alert.FieldSourceIp:
|
|
m.ResetSourceIp()
|
|
return nil
|
|
case alert.FieldSourceRange:
|
|
m.ResetSourceRange()
|
|
return nil
|
|
case alert.FieldSourceAsNumber:
|
|
m.ResetSourceAsNumber()
|
|
return nil
|
|
case alert.FieldSourceAsName:
|
|
m.ResetSourceAsName()
|
|
return nil
|
|
case alert.FieldSourceCountry:
|
|
m.ResetSourceCountry()
|
|
return nil
|
|
case alert.FieldSourceLatitude:
|
|
m.ResetSourceLatitude()
|
|
return nil
|
|
case alert.FieldSourceLongitude:
|
|
m.ResetSourceLongitude()
|
|
return nil
|
|
case alert.FieldSourceScope:
|
|
m.ResetSourceScope()
|
|
return nil
|
|
case alert.FieldSourceValue:
|
|
m.ResetSourceValue()
|
|
return nil
|
|
case alert.FieldCapacity:
|
|
m.ResetCapacity()
|
|
return nil
|
|
case alert.FieldLeakSpeed:
|
|
m.ResetLeakSpeed()
|
|
return nil
|
|
case alert.FieldScenarioVersion:
|
|
m.ResetScenarioVersion()
|
|
return nil
|
|
case alert.FieldScenarioHash:
|
|
m.ResetScenarioHash()
|
|
return nil
|
|
case alert.FieldSimulated:
|
|
m.ResetSimulated()
|
|
return nil
|
|
case alert.FieldUUID:
|
|
m.ResetUUID()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Alert field %s", name)
|
|
}
|
|
|
|
// AddedEdges returns all edge names that were set/added in this mutation.
|
|
func (m *AlertMutation) AddedEdges() []string {
|
|
edges := make([]string, 0, 4)
|
|
if m.owner != nil {
|
|
edges = append(edges, alert.EdgeOwner)
|
|
}
|
|
if m.decisions != nil {
|
|
edges = append(edges, alert.EdgeDecisions)
|
|
}
|
|
if m.events != nil {
|
|
edges = append(edges, alert.EdgeEvents)
|
|
}
|
|
if m.metas != nil {
|
|
edges = append(edges, alert.EdgeMetas)
|
|
}
|
|
return edges
|
|
}
|
|
|
|
// AddedIDs returns all IDs (to other nodes) that were added for the given edge
|
|
// name in this mutation.
|
|
func (m *AlertMutation) AddedIDs(name string) []ent.Value {
|
|
switch name {
|
|
case alert.EdgeOwner:
|
|
if id := m.owner; id != nil {
|
|
return []ent.Value{*id}
|
|
}
|
|
case alert.EdgeDecisions:
|
|
ids := make([]ent.Value, 0, len(m.decisions))
|
|
for id := range m.decisions {
|
|
ids = append(ids, id)
|
|
}
|
|
return ids
|
|
case alert.EdgeEvents:
|
|
ids := make([]ent.Value, 0, len(m.events))
|
|
for id := range m.events {
|
|
ids = append(ids, id)
|
|
}
|
|
return ids
|
|
case alert.EdgeMetas:
|
|
ids := make([]ent.Value, 0, len(m.metas))
|
|
for id := range m.metas {
|
|
ids = append(ids, id)
|
|
}
|
|
return ids
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// RemovedEdges returns all edge names that were removed in this mutation.
|
|
func (m *AlertMutation) RemovedEdges() []string {
|
|
edges := make([]string, 0, 4)
|
|
if m.removeddecisions != nil {
|
|
edges = append(edges, alert.EdgeDecisions)
|
|
}
|
|
if m.removedevents != nil {
|
|
edges = append(edges, alert.EdgeEvents)
|
|
}
|
|
if m.removedmetas != nil {
|
|
edges = append(edges, alert.EdgeMetas)
|
|
}
|
|
return edges
|
|
}
|
|
|
|
// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
|
|
// the given name in this mutation.
|
|
func (m *AlertMutation) RemovedIDs(name string) []ent.Value {
|
|
switch name {
|
|
case alert.EdgeDecisions:
|
|
ids := make([]ent.Value, 0, len(m.removeddecisions))
|
|
for id := range m.removeddecisions {
|
|
ids = append(ids, id)
|
|
}
|
|
return ids
|
|
case alert.EdgeEvents:
|
|
ids := make([]ent.Value, 0, len(m.removedevents))
|
|
for id := range m.removedevents {
|
|
ids = append(ids, id)
|
|
}
|
|
return ids
|
|
case alert.EdgeMetas:
|
|
ids := make([]ent.Value, 0, len(m.removedmetas))
|
|
for id := range m.removedmetas {
|
|
ids = append(ids, id)
|
|
}
|
|
return ids
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// ClearedEdges returns all edge names that were cleared in this mutation.
|
|
func (m *AlertMutation) ClearedEdges() []string {
|
|
edges := make([]string, 0, 4)
|
|
if m.clearedowner {
|
|
edges = append(edges, alert.EdgeOwner)
|
|
}
|
|
if m.cleareddecisions {
|
|
edges = append(edges, alert.EdgeDecisions)
|
|
}
|
|
if m.clearedevents {
|
|
edges = append(edges, alert.EdgeEvents)
|
|
}
|
|
if m.clearedmetas {
|
|
edges = append(edges, alert.EdgeMetas)
|
|
}
|
|
return edges
|
|
}
|
|
|
|
// EdgeCleared returns a boolean which indicates if the edge with the given name
|
|
// was cleared in this mutation.
|
|
func (m *AlertMutation) EdgeCleared(name string) bool {
|
|
switch name {
|
|
case alert.EdgeOwner:
|
|
return m.clearedowner
|
|
case alert.EdgeDecisions:
|
|
return m.cleareddecisions
|
|
case alert.EdgeEvents:
|
|
return m.clearedevents
|
|
case alert.EdgeMetas:
|
|
return m.clearedmetas
|
|
}
|
|
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 *AlertMutation) ClearEdge(name string) error {
|
|
switch name {
|
|
case alert.EdgeOwner:
|
|
m.ClearOwner()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Alert 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 *AlertMutation) ResetEdge(name string) error {
|
|
switch name {
|
|
case alert.EdgeOwner:
|
|
m.ResetOwner()
|
|
return nil
|
|
case alert.EdgeDecisions:
|
|
m.ResetDecisions()
|
|
return nil
|
|
case alert.EdgeEvents:
|
|
m.ResetEvents()
|
|
return nil
|
|
case alert.EdgeMetas:
|
|
m.ResetMetas()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Alert edge %s", name)
|
|
}
|
|
|
|
// BouncerMutation represents an operation that mutates the Bouncer nodes in the graph.
|
|
type BouncerMutation struct {
|
|
config
|
|
op Op
|
|
typ string
|
|
id *int
|
|
created_at *time.Time
|
|
updated_at *time.Time
|
|
name *string
|
|
api_key *string
|
|
revoked *bool
|
|
ip_address *string
|
|
_type *string
|
|
version *string
|
|
until *time.Time
|
|
last_pull *time.Time
|
|
auth_type *string
|
|
clearedFields map[string]struct{}
|
|
done bool
|
|
oldValue func(context.Context) (*Bouncer, error)
|
|
predicates []predicate.Bouncer
|
|
}
|
|
|
|
var _ ent.Mutation = (*BouncerMutation)(nil)
|
|
|
|
// bouncerOption allows management of the mutation configuration using functional options.
|
|
type bouncerOption func(*BouncerMutation)
|
|
|
|
// newBouncerMutation creates new mutation for the Bouncer entity.
|
|
func newBouncerMutation(c config, op Op, opts ...bouncerOption) *BouncerMutation {
|
|
m := &BouncerMutation{
|
|
config: c,
|
|
op: op,
|
|
typ: TypeBouncer,
|
|
clearedFields: make(map[string]struct{}),
|
|
}
|
|
for _, opt := range opts {
|
|
opt(m)
|
|
}
|
|
return m
|
|
}
|
|
|
|
// withBouncerID sets the ID field of the mutation.
|
|
func withBouncerID(id int) bouncerOption {
|
|
return func(m *BouncerMutation) {
|
|
var (
|
|
err error
|
|
once sync.Once
|
|
value *Bouncer
|
|
)
|
|
m.oldValue = func(ctx context.Context) (*Bouncer, error) {
|
|
once.Do(func() {
|
|
if m.done {
|
|
err = errors.New("querying old values post mutation is not allowed")
|
|
} else {
|
|
value, err = m.Client().Bouncer.Get(ctx, id)
|
|
}
|
|
})
|
|
return value, err
|
|
}
|
|
m.id = &id
|
|
}
|
|
}
|
|
|
|
// withBouncer sets the old Bouncer of the mutation.
|
|
func withBouncer(node *Bouncer) bouncerOption {
|
|
return func(m *BouncerMutation) {
|
|
m.oldValue = func(context.Context) (*Bouncer, error) {
|
|
return node, nil
|
|
}
|
|
m.id = &node.ID
|
|
}
|
|
}
|
|
|
|
// Client returns a new `ent.Client` from the mutation. If the mutation was
|
|
// executed in a transaction (ent.Tx), a transactional client is returned.
|
|
func (m BouncerMutation) Client() *Client {
|
|
client := &Client{config: m.config}
|
|
client.init()
|
|
return client
|
|
}
|
|
|
|
// Tx returns an `ent.Tx` for mutations that were executed in transactions;
|
|
// it returns an error otherwise.
|
|
func (m BouncerMutation) Tx() (*Tx, error) {
|
|
if _, ok := m.driver.(*txDriver); !ok {
|
|
return nil, errors.New("ent: mutation is not running in a transaction")
|
|
}
|
|
tx := &Tx{config: m.config}
|
|
tx.init()
|
|
return tx, nil
|
|
}
|
|
|
|
// ID returns the ID value in the mutation. Note that the ID is only available
|
|
// if it was provided to the builder or after it was returned from the database.
|
|
func (m *BouncerMutation) ID() (id int, exists bool) {
|
|
if m.id == nil {
|
|
return
|
|
}
|
|
return *m.id, true
|
|
}
|
|
|
|
// IDs queries the database and returns the entity ids that match the mutation's predicate.
|
|
// That means, if the mutation is applied within a transaction with an isolation level such
|
|
// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
|
|
// or updated by the mutation.
|
|
func (m *BouncerMutation) IDs(ctx context.Context) ([]int, error) {
|
|
switch {
|
|
case m.op.Is(OpUpdateOne | OpDeleteOne):
|
|
id, exists := m.ID()
|
|
if exists {
|
|
return []int{id}, nil
|
|
}
|
|
fallthrough
|
|
case m.op.Is(OpUpdate | OpDelete):
|
|
return m.Client().Bouncer.Query().Where(m.predicates...).IDs(ctx)
|
|
default:
|
|
return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
|
|
}
|
|
}
|
|
|
|
// SetCreatedAt sets the "created_at" field.
|
|
func (m *BouncerMutation) SetCreatedAt(t time.Time) {
|
|
m.created_at = &t
|
|
}
|
|
|
|
// CreatedAt returns the value of the "created_at" field in the mutation.
|
|
func (m *BouncerMutation) CreatedAt() (r time.Time, exists bool) {
|
|
v := m.created_at
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldCreatedAt returns the old "created_at" field's value of the Bouncer entity.
|
|
// If the Bouncer object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *BouncerMutation) OldCreatedAt(ctx context.Context) (v *time.Time, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldCreatedAt requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldCreatedAt: %w", err)
|
|
}
|
|
return oldValue.CreatedAt, nil
|
|
}
|
|
|
|
// ClearCreatedAt clears the value of the "created_at" field.
|
|
func (m *BouncerMutation) ClearCreatedAt() {
|
|
m.created_at = nil
|
|
m.clearedFields[bouncer.FieldCreatedAt] = struct{}{}
|
|
}
|
|
|
|
// CreatedAtCleared returns if the "created_at" field was cleared in this mutation.
|
|
func (m *BouncerMutation) CreatedAtCleared() bool {
|
|
_, ok := m.clearedFields[bouncer.FieldCreatedAt]
|
|
return ok
|
|
}
|
|
|
|
// ResetCreatedAt resets all changes to the "created_at" field.
|
|
func (m *BouncerMutation) ResetCreatedAt() {
|
|
m.created_at = nil
|
|
delete(m.clearedFields, bouncer.FieldCreatedAt)
|
|
}
|
|
|
|
// SetUpdatedAt sets the "updated_at" field.
|
|
func (m *BouncerMutation) SetUpdatedAt(t time.Time) {
|
|
m.updated_at = &t
|
|
}
|
|
|
|
// UpdatedAt returns the value of the "updated_at" field in the mutation.
|
|
func (m *BouncerMutation) UpdatedAt() (r time.Time, exists bool) {
|
|
v := m.updated_at
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldUpdatedAt returns the old "updated_at" field's value of the Bouncer entity.
|
|
// If the Bouncer object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *BouncerMutation) OldUpdatedAt(ctx context.Context) (v *time.Time, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldUpdatedAt requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldUpdatedAt: %w", err)
|
|
}
|
|
return oldValue.UpdatedAt, nil
|
|
}
|
|
|
|
// ClearUpdatedAt clears the value of the "updated_at" field.
|
|
func (m *BouncerMutation) ClearUpdatedAt() {
|
|
m.updated_at = nil
|
|
m.clearedFields[bouncer.FieldUpdatedAt] = struct{}{}
|
|
}
|
|
|
|
// UpdatedAtCleared returns if the "updated_at" field was cleared in this mutation.
|
|
func (m *BouncerMutation) UpdatedAtCleared() bool {
|
|
_, ok := m.clearedFields[bouncer.FieldUpdatedAt]
|
|
return ok
|
|
}
|
|
|
|
// ResetUpdatedAt resets all changes to the "updated_at" field.
|
|
func (m *BouncerMutation) ResetUpdatedAt() {
|
|
m.updated_at = nil
|
|
delete(m.clearedFields, bouncer.FieldUpdatedAt)
|
|
}
|
|
|
|
// SetName sets the "name" field.
|
|
func (m *BouncerMutation) SetName(s string) {
|
|
m.name = &s
|
|
}
|
|
|
|
// Name returns the value of the "name" field in the mutation.
|
|
func (m *BouncerMutation) Name() (r string, exists bool) {
|
|
v := m.name
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldName returns the old "name" field's value of the Bouncer entity.
|
|
// If the Bouncer object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *BouncerMutation) OldName(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldName is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldName requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldName: %w", err)
|
|
}
|
|
return oldValue.Name, nil
|
|
}
|
|
|
|
// ResetName resets all changes to the "name" field.
|
|
func (m *BouncerMutation) ResetName() {
|
|
m.name = nil
|
|
}
|
|
|
|
// SetAPIKey sets the "api_key" field.
|
|
func (m *BouncerMutation) SetAPIKey(s string) {
|
|
m.api_key = &s
|
|
}
|
|
|
|
// APIKey returns the value of the "api_key" field in the mutation.
|
|
func (m *BouncerMutation) APIKey() (r string, exists bool) {
|
|
v := m.api_key
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldAPIKey returns the old "api_key" field's value of the Bouncer entity.
|
|
// If the Bouncer object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *BouncerMutation) OldAPIKey(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldAPIKey is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldAPIKey requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldAPIKey: %w", err)
|
|
}
|
|
return oldValue.APIKey, nil
|
|
}
|
|
|
|
// ResetAPIKey resets all changes to the "api_key" field.
|
|
func (m *BouncerMutation) ResetAPIKey() {
|
|
m.api_key = nil
|
|
}
|
|
|
|
// SetRevoked sets the "revoked" field.
|
|
func (m *BouncerMutation) SetRevoked(b bool) {
|
|
m.revoked = &b
|
|
}
|
|
|
|
// Revoked returns the value of the "revoked" field in the mutation.
|
|
func (m *BouncerMutation) Revoked() (r bool, exists bool) {
|
|
v := m.revoked
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldRevoked returns the old "revoked" field's value of the Bouncer entity.
|
|
// If the Bouncer object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *BouncerMutation) OldRevoked(ctx context.Context) (v bool, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldRevoked is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldRevoked requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldRevoked: %w", err)
|
|
}
|
|
return oldValue.Revoked, nil
|
|
}
|
|
|
|
// ResetRevoked resets all changes to the "revoked" field.
|
|
func (m *BouncerMutation) ResetRevoked() {
|
|
m.revoked = nil
|
|
}
|
|
|
|
// SetIPAddress sets the "ip_address" field.
|
|
func (m *BouncerMutation) SetIPAddress(s string) {
|
|
m.ip_address = &s
|
|
}
|
|
|
|
// IPAddress returns the value of the "ip_address" field in the mutation.
|
|
func (m *BouncerMutation) IPAddress() (r string, exists bool) {
|
|
v := m.ip_address
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldIPAddress returns the old "ip_address" field's value of the Bouncer entity.
|
|
// If the Bouncer object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *BouncerMutation) OldIPAddress(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldIPAddress is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldIPAddress requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldIPAddress: %w", err)
|
|
}
|
|
return oldValue.IPAddress, nil
|
|
}
|
|
|
|
// ClearIPAddress clears the value of the "ip_address" field.
|
|
func (m *BouncerMutation) ClearIPAddress() {
|
|
m.ip_address = nil
|
|
m.clearedFields[bouncer.FieldIPAddress] = struct{}{}
|
|
}
|
|
|
|
// IPAddressCleared returns if the "ip_address" field was cleared in this mutation.
|
|
func (m *BouncerMutation) IPAddressCleared() bool {
|
|
_, ok := m.clearedFields[bouncer.FieldIPAddress]
|
|
return ok
|
|
}
|
|
|
|
// ResetIPAddress resets all changes to the "ip_address" field.
|
|
func (m *BouncerMutation) ResetIPAddress() {
|
|
m.ip_address = nil
|
|
delete(m.clearedFields, bouncer.FieldIPAddress)
|
|
}
|
|
|
|
// SetType sets the "type" field.
|
|
func (m *BouncerMutation) SetType(s string) {
|
|
m._type = &s
|
|
}
|
|
|
|
// GetType returns the value of the "type" field in the mutation.
|
|
func (m *BouncerMutation) GetType() (r string, exists bool) {
|
|
v := m._type
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldType returns the old "type" field's value of the Bouncer entity.
|
|
// If the Bouncer object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *BouncerMutation) OldType(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldType is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldType requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldType: %w", err)
|
|
}
|
|
return oldValue.Type, nil
|
|
}
|
|
|
|
// ClearType clears the value of the "type" field.
|
|
func (m *BouncerMutation) ClearType() {
|
|
m._type = nil
|
|
m.clearedFields[bouncer.FieldType] = struct{}{}
|
|
}
|
|
|
|
// TypeCleared returns if the "type" field was cleared in this mutation.
|
|
func (m *BouncerMutation) TypeCleared() bool {
|
|
_, ok := m.clearedFields[bouncer.FieldType]
|
|
return ok
|
|
}
|
|
|
|
// ResetType resets all changes to the "type" field.
|
|
func (m *BouncerMutation) ResetType() {
|
|
m._type = nil
|
|
delete(m.clearedFields, bouncer.FieldType)
|
|
}
|
|
|
|
// SetVersion sets the "version" field.
|
|
func (m *BouncerMutation) SetVersion(s string) {
|
|
m.version = &s
|
|
}
|
|
|
|
// Version returns the value of the "version" field in the mutation.
|
|
func (m *BouncerMutation) Version() (r string, exists bool) {
|
|
v := m.version
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldVersion returns the old "version" field's value of the Bouncer entity.
|
|
// If the Bouncer object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *BouncerMutation) OldVersion(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldVersion is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldVersion requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldVersion: %w", err)
|
|
}
|
|
return oldValue.Version, nil
|
|
}
|
|
|
|
// ClearVersion clears the value of the "version" field.
|
|
func (m *BouncerMutation) ClearVersion() {
|
|
m.version = nil
|
|
m.clearedFields[bouncer.FieldVersion] = struct{}{}
|
|
}
|
|
|
|
// VersionCleared returns if the "version" field was cleared in this mutation.
|
|
func (m *BouncerMutation) VersionCleared() bool {
|
|
_, ok := m.clearedFields[bouncer.FieldVersion]
|
|
return ok
|
|
}
|
|
|
|
// ResetVersion resets all changes to the "version" field.
|
|
func (m *BouncerMutation) ResetVersion() {
|
|
m.version = nil
|
|
delete(m.clearedFields, bouncer.FieldVersion)
|
|
}
|
|
|
|
// SetUntil sets the "until" field.
|
|
func (m *BouncerMutation) SetUntil(t time.Time) {
|
|
m.until = &t
|
|
}
|
|
|
|
// Until returns the value of the "until" field in the mutation.
|
|
func (m *BouncerMutation) Until() (r time.Time, exists bool) {
|
|
v := m.until
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldUntil returns the old "until" field's value of the Bouncer entity.
|
|
// If the Bouncer object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *BouncerMutation) OldUntil(ctx context.Context) (v time.Time, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldUntil is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldUntil requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldUntil: %w", err)
|
|
}
|
|
return oldValue.Until, nil
|
|
}
|
|
|
|
// ClearUntil clears the value of the "until" field.
|
|
func (m *BouncerMutation) ClearUntil() {
|
|
m.until = nil
|
|
m.clearedFields[bouncer.FieldUntil] = struct{}{}
|
|
}
|
|
|
|
// UntilCleared returns if the "until" field was cleared in this mutation.
|
|
func (m *BouncerMutation) UntilCleared() bool {
|
|
_, ok := m.clearedFields[bouncer.FieldUntil]
|
|
return ok
|
|
}
|
|
|
|
// ResetUntil resets all changes to the "until" field.
|
|
func (m *BouncerMutation) ResetUntil() {
|
|
m.until = nil
|
|
delete(m.clearedFields, bouncer.FieldUntil)
|
|
}
|
|
|
|
// SetLastPull sets the "last_pull" field.
|
|
func (m *BouncerMutation) SetLastPull(t time.Time) {
|
|
m.last_pull = &t
|
|
}
|
|
|
|
// LastPull returns the value of the "last_pull" field in the mutation.
|
|
func (m *BouncerMutation) LastPull() (r time.Time, exists bool) {
|
|
v := m.last_pull
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldLastPull returns the old "last_pull" field's value of the Bouncer entity.
|
|
// If the Bouncer object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *BouncerMutation) OldLastPull(ctx context.Context) (v time.Time, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldLastPull is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldLastPull requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldLastPull: %w", err)
|
|
}
|
|
return oldValue.LastPull, nil
|
|
}
|
|
|
|
// ResetLastPull resets all changes to the "last_pull" field.
|
|
func (m *BouncerMutation) ResetLastPull() {
|
|
m.last_pull = nil
|
|
}
|
|
|
|
// SetAuthType sets the "auth_type" field.
|
|
func (m *BouncerMutation) SetAuthType(s string) {
|
|
m.auth_type = &s
|
|
}
|
|
|
|
// AuthType returns the value of the "auth_type" field in the mutation.
|
|
func (m *BouncerMutation) AuthType() (r string, exists bool) {
|
|
v := m.auth_type
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldAuthType returns the old "auth_type" field's value of the Bouncer entity.
|
|
// If the Bouncer object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *BouncerMutation) OldAuthType(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldAuthType is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldAuthType requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldAuthType: %w", err)
|
|
}
|
|
return oldValue.AuthType, nil
|
|
}
|
|
|
|
// ResetAuthType resets all changes to the "auth_type" field.
|
|
func (m *BouncerMutation) ResetAuthType() {
|
|
m.auth_type = nil
|
|
}
|
|
|
|
// Where appends a list predicates to the BouncerMutation builder.
|
|
func (m *BouncerMutation) Where(ps ...predicate.Bouncer) {
|
|
m.predicates = append(m.predicates, ps...)
|
|
}
|
|
|
|
// WhereP appends storage-level predicates to the BouncerMutation builder. Using this method,
|
|
// users can use type-assertion to append predicates that do not depend on any generated package.
|
|
func (m *BouncerMutation) WhereP(ps ...func(*sql.Selector)) {
|
|
p := make([]predicate.Bouncer, len(ps))
|
|
for i := range ps {
|
|
p[i] = ps[i]
|
|
}
|
|
m.Where(p...)
|
|
}
|
|
|
|
// Op returns the operation name.
|
|
func (m *BouncerMutation) Op() Op {
|
|
return m.op
|
|
}
|
|
|
|
// SetOp allows setting the mutation operation.
|
|
func (m *BouncerMutation) SetOp(op Op) {
|
|
m.op = op
|
|
}
|
|
|
|
// Type returns the node type of this mutation (Bouncer).
|
|
func (m *BouncerMutation) Type() string {
|
|
return m.typ
|
|
}
|
|
|
|
// Fields returns all fields that were changed during this mutation. Note that in
|
|
// order to get all numeric fields that were incremented/decremented, call
|
|
// AddedFields().
|
|
func (m *BouncerMutation) Fields() []string {
|
|
fields := make([]string, 0, 11)
|
|
if m.created_at != nil {
|
|
fields = append(fields, bouncer.FieldCreatedAt)
|
|
}
|
|
if m.updated_at != nil {
|
|
fields = append(fields, bouncer.FieldUpdatedAt)
|
|
}
|
|
if m.name != nil {
|
|
fields = append(fields, bouncer.FieldName)
|
|
}
|
|
if m.api_key != nil {
|
|
fields = append(fields, bouncer.FieldAPIKey)
|
|
}
|
|
if m.revoked != nil {
|
|
fields = append(fields, bouncer.FieldRevoked)
|
|
}
|
|
if m.ip_address != nil {
|
|
fields = append(fields, bouncer.FieldIPAddress)
|
|
}
|
|
if m._type != nil {
|
|
fields = append(fields, bouncer.FieldType)
|
|
}
|
|
if m.version != nil {
|
|
fields = append(fields, bouncer.FieldVersion)
|
|
}
|
|
if m.until != nil {
|
|
fields = append(fields, bouncer.FieldUntil)
|
|
}
|
|
if m.last_pull != nil {
|
|
fields = append(fields, bouncer.FieldLastPull)
|
|
}
|
|
if m.auth_type != nil {
|
|
fields = append(fields, bouncer.FieldAuthType)
|
|
}
|
|
return fields
|
|
}
|
|
|
|
// Field returns the value of a field with the given name. The second boolean
|
|
// return value indicates that this field was not set, or was not defined in the
|
|
// schema.
|
|
func (m *BouncerMutation) Field(name string) (ent.Value, bool) {
|
|
switch name {
|
|
case bouncer.FieldCreatedAt:
|
|
return m.CreatedAt()
|
|
case bouncer.FieldUpdatedAt:
|
|
return m.UpdatedAt()
|
|
case bouncer.FieldName:
|
|
return m.Name()
|
|
case bouncer.FieldAPIKey:
|
|
return m.APIKey()
|
|
case bouncer.FieldRevoked:
|
|
return m.Revoked()
|
|
case bouncer.FieldIPAddress:
|
|
return m.IPAddress()
|
|
case bouncer.FieldType:
|
|
return m.GetType()
|
|
case bouncer.FieldVersion:
|
|
return m.Version()
|
|
case bouncer.FieldUntil:
|
|
return m.Until()
|
|
case bouncer.FieldLastPull:
|
|
return m.LastPull()
|
|
case bouncer.FieldAuthType:
|
|
return m.AuthType()
|
|
}
|
|
return nil, false
|
|
}
|
|
|
|
// OldField returns the old value of the field from the database. An error is
|
|
// returned if the mutation operation is not UpdateOne, or the query to the
|
|
// database failed.
|
|
func (m *BouncerMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
|
|
switch name {
|
|
case bouncer.FieldCreatedAt:
|
|
return m.OldCreatedAt(ctx)
|
|
case bouncer.FieldUpdatedAt:
|
|
return m.OldUpdatedAt(ctx)
|
|
case bouncer.FieldName:
|
|
return m.OldName(ctx)
|
|
case bouncer.FieldAPIKey:
|
|
return m.OldAPIKey(ctx)
|
|
case bouncer.FieldRevoked:
|
|
return m.OldRevoked(ctx)
|
|
case bouncer.FieldIPAddress:
|
|
return m.OldIPAddress(ctx)
|
|
case bouncer.FieldType:
|
|
return m.OldType(ctx)
|
|
case bouncer.FieldVersion:
|
|
return m.OldVersion(ctx)
|
|
case bouncer.FieldUntil:
|
|
return m.OldUntil(ctx)
|
|
case bouncer.FieldLastPull:
|
|
return m.OldLastPull(ctx)
|
|
case bouncer.FieldAuthType:
|
|
return m.OldAuthType(ctx)
|
|
}
|
|
return nil, fmt.Errorf("unknown Bouncer field %s", name)
|
|
}
|
|
|
|
// SetField sets the value of a field with the given name. It returns an error if
|
|
// the field is not defined in the schema, or if the type mismatched the field
|
|
// type.
|
|
func (m *BouncerMutation) SetField(name string, value ent.Value) error {
|
|
switch name {
|
|
case bouncer.FieldCreatedAt:
|
|
v, ok := value.(time.Time)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetCreatedAt(v)
|
|
return nil
|
|
case bouncer.FieldUpdatedAt:
|
|
v, ok := value.(time.Time)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetUpdatedAt(v)
|
|
return nil
|
|
case bouncer.FieldName:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetName(v)
|
|
return nil
|
|
case bouncer.FieldAPIKey:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetAPIKey(v)
|
|
return nil
|
|
case bouncer.FieldRevoked:
|
|
v, ok := value.(bool)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetRevoked(v)
|
|
return nil
|
|
case bouncer.FieldIPAddress:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetIPAddress(v)
|
|
return nil
|
|
case bouncer.FieldType:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetType(v)
|
|
return nil
|
|
case bouncer.FieldVersion:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetVersion(v)
|
|
return nil
|
|
case bouncer.FieldUntil:
|
|
v, ok := value.(time.Time)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetUntil(v)
|
|
return nil
|
|
case bouncer.FieldLastPull:
|
|
v, ok := value.(time.Time)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetLastPull(v)
|
|
return nil
|
|
case bouncer.FieldAuthType:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetAuthType(v)
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Bouncer field %s", name)
|
|
}
|
|
|
|
// AddedFields returns all numeric fields that were incremented/decremented during
|
|
// this mutation.
|
|
func (m *BouncerMutation) AddedFields() []string {
|
|
return nil
|
|
}
|
|
|
|
// AddedField returns the numeric value that was incremented/decremented on a field
|
|
// with the given name. The second boolean return value indicates that this field
|
|
// was not set, or was not defined in the schema.
|
|
func (m *BouncerMutation) AddedField(name string) (ent.Value, bool) {
|
|
return nil, false
|
|
}
|
|
|
|
// AddField adds the value to the field with the given name. It returns an error if
|
|
// the field is not defined in the schema, or if the type mismatched the field
|
|
// type.
|
|
func (m *BouncerMutation) AddField(name string, value ent.Value) error {
|
|
switch name {
|
|
}
|
|
return fmt.Errorf("unknown Bouncer numeric field %s", name)
|
|
}
|
|
|
|
// ClearedFields returns all nullable fields that were cleared during this
|
|
// mutation.
|
|
func (m *BouncerMutation) ClearedFields() []string {
|
|
var fields []string
|
|
if m.FieldCleared(bouncer.FieldCreatedAt) {
|
|
fields = append(fields, bouncer.FieldCreatedAt)
|
|
}
|
|
if m.FieldCleared(bouncer.FieldUpdatedAt) {
|
|
fields = append(fields, bouncer.FieldUpdatedAt)
|
|
}
|
|
if m.FieldCleared(bouncer.FieldIPAddress) {
|
|
fields = append(fields, bouncer.FieldIPAddress)
|
|
}
|
|
if m.FieldCleared(bouncer.FieldType) {
|
|
fields = append(fields, bouncer.FieldType)
|
|
}
|
|
if m.FieldCleared(bouncer.FieldVersion) {
|
|
fields = append(fields, bouncer.FieldVersion)
|
|
}
|
|
if m.FieldCleared(bouncer.FieldUntil) {
|
|
fields = append(fields, bouncer.FieldUntil)
|
|
}
|
|
return fields
|
|
}
|
|
|
|
// FieldCleared returns a boolean indicating if a field with the given name was
|
|
// cleared in this mutation.
|
|
func (m *BouncerMutation) FieldCleared(name string) bool {
|
|
_, ok := m.clearedFields[name]
|
|
return ok
|
|
}
|
|
|
|
// ClearField clears the value of the field with the given name. It returns an
|
|
// error if the field is not defined in the schema.
|
|
func (m *BouncerMutation) ClearField(name string) error {
|
|
switch name {
|
|
case bouncer.FieldCreatedAt:
|
|
m.ClearCreatedAt()
|
|
return nil
|
|
case bouncer.FieldUpdatedAt:
|
|
m.ClearUpdatedAt()
|
|
return nil
|
|
case bouncer.FieldIPAddress:
|
|
m.ClearIPAddress()
|
|
return nil
|
|
case bouncer.FieldType:
|
|
m.ClearType()
|
|
return nil
|
|
case bouncer.FieldVersion:
|
|
m.ClearVersion()
|
|
return nil
|
|
case bouncer.FieldUntil:
|
|
m.ClearUntil()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Bouncer nullable field %s", name)
|
|
}
|
|
|
|
// ResetField resets all changes in the mutation for the field with the given name.
|
|
// It returns an error if the field is not defined in the schema.
|
|
func (m *BouncerMutation) ResetField(name string) error {
|
|
switch name {
|
|
case bouncer.FieldCreatedAt:
|
|
m.ResetCreatedAt()
|
|
return nil
|
|
case bouncer.FieldUpdatedAt:
|
|
m.ResetUpdatedAt()
|
|
return nil
|
|
case bouncer.FieldName:
|
|
m.ResetName()
|
|
return nil
|
|
case bouncer.FieldAPIKey:
|
|
m.ResetAPIKey()
|
|
return nil
|
|
case bouncer.FieldRevoked:
|
|
m.ResetRevoked()
|
|
return nil
|
|
case bouncer.FieldIPAddress:
|
|
m.ResetIPAddress()
|
|
return nil
|
|
case bouncer.FieldType:
|
|
m.ResetType()
|
|
return nil
|
|
case bouncer.FieldVersion:
|
|
m.ResetVersion()
|
|
return nil
|
|
case bouncer.FieldUntil:
|
|
m.ResetUntil()
|
|
return nil
|
|
case bouncer.FieldLastPull:
|
|
m.ResetLastPull()
|
|
return nil
|
|
case bouncer.FieldAuthType:
|
|
m.ResetAuthType()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Bouncer field %s", name)
|
|
}
|
|
|
|
// AddedEdges returns all edge names that were set/added in this mutation.
|
|
func (m *BouncerMutation) AddedEdges() []string {
|
|
edges := make([]string, 0, 0)
|
|
return edges
|
|
}
|
|
|
|
// AddedIDs returns all IDs (to other nodes) that were added for the given edge
|
|
// name in this mutation.
|
|
func (m *BouncerMutation) AddedIDs(name string) []ent.Value {
|
|
return nil
|
|
}
|
|
|
|
// RemovedEdges returns all edge names that were removed in this mutation.
|
|
func (m *BouncerMutation) RemovedEdges() []string {
|
|
edges := make([]string, 0, 0)
|
|
return edges
|
|
}
|
|
|
|
// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
|
|
// the given name in this mutation.
|
|
func (m *BouncerMutation) RemovedIDs(name string) []ent.Value {
|
|
return nil
|
|
}
|
|
|
|
// ClearedEdges returns all edge names that were cleared in this mutation.
|
|
func (m *BouncerMutation) ClearedEdges() []string {
|
|
edges := make([]string, 0, 0)
|
|
return edges
|
|
}
|
|
|
|
// EdgeCleared returns a boolean which indicates if the edge with the given name
|
|
// was cleared in this mutation.
|
|
func (m *BouncerMutation) EdgeCleared(name string) bool {
|
|
return false
|
|
}
|
|
|
|
// ClearEdge clears the value of the edge with the given name. It returns an error
|
|
// if that edge is not defined in the schema.
|
|
func (m *BouncerMutation) ClearEdge(name string) error {
|
|
return fmt.Errorf("unknown Bouncer 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 *BouncerMutation) ResetEdge(name string) error {
|
|
return fmt.Errorf("unknown Bouncer edge %s", name)
|
|
}
|
|
|
|
// ConfigItemMutation represents an operation that mutates the ConfigItem nodes in the graph.
|
|
type ConfigItemMutation struct {
|
|
config
|
|
op Op
|
|
typ string
|
|
id *int
|
|
created_at *time.Time
|
|
updated_at *time.Time
|
|
name *string
|
|
value *string
|
|
clearedFields map[string]struct{}
|
|
done bool
|
|
oldValue func(context.Context) (*ConfigItem, error)
|
|
predicates []predicate.ConfigItem
|
|
}
|
|
|
|
var _ ent.Mutation = (*ConfigItemMutation)(nil)
|
|
|
|
// configitemOption allows management of the mutation configuration using functional options.
|
|
type configitemOption func(*ConfigItemMutation)
|
|
|
|
// newConfigItemMutation creates new mutation for the ConfigItem entity.
|
|
func newConfigItemMutation(c config, op Op, opts ...configitemOption) *ConfigItemMutation {
|
|
m := &ConfigItemMutation{
|
|
config: c,
|
|
op: op,
|
|
typ: TypeConfigItem,
|
|
clearedFields: make(map[string]struct{}),
|
|
}
|
|
for _, opt := range opts {
|
|
opt(m)
|
|
}
|
|
return m
|
|
}
|
|
|
|
// withConfigItemID sets the ID field of the mutation.
|
|
func withConfigItemID(id int) configitemOption {
|
|
return func(m *ConfigItemMutation) {
|
|
var (
|
|
err error
|
|
once sync.Once
|
|
value *ConfigItem
|
|
)
|
|
m.oldValue = func(ctx context.Context) (*ConfigItem, error) {
|
|
once.Do(func() {
|
|
if m.done {
|
|
err = errors.New("querying old values post mutation is not allowed")
|
|
} else {
|
|
value, err = m.Client().ConfigItem.Get(ctx, id)
|
|
}
|
|
})
|
|
return value, err
|
|
}
|
|
m.id = &id
|
|
}
|
|
}
|
|
|
|
// withConfigItem sets the old ConfigItem of the mutation.
|
|
func withConfigItem(node *ConfigItem) configitemOption {
|
|
return func(m *ConfigItemMutation) {
|
|
m.oldValue = func(context.Context) (*ConfigItem, error) {
|
|
return node, nil
|
|
}
|
|
m.id = &node.ID
|
|
}
|
|
}
|
|
|
|
// Client returns a new `ent.Client` from the mutation. If the mutation was
|
|
// executed in a transaction (ent.Tx), a transactional client is returned.
|
|
func (m ConfigItemMutation) Client() *Client {
|
|
client := &Client{config: m.config}
|
|
client.init()
|
|
return client
|
|
}
|
|
|
|
// Tx returns an `ent.Tx` for mutations that were executed in transactions;
|
|
// it returns an error otherwise.
|
|
func (m ConfigItemMutation) Tx() (*Tx, error) {
|
|
if _, ok := m.driver.(*txDriver); !ok {
|
|
return nil, errors.New("ent: mutation is not running in a transaction")
|
|
}
|
|
tx := &Tx{config: m.config}
|
|
tx.init()
|
|
return tx, nil
|
|
}
|
|
|
|
// ID returns the ID value in the mutation. Note that the ID is only available
|
|
// if it was provided to the builder or after it was returned from the database.
|
|
func (m *ConfigItemMutation) ID() (id int, exists bool) {
|
|
if m.id == nil {
|
|
return
|
|
}
|
|
return *m.id, true
|
|
}
|
|
|
|
// IDs queries the database and returns the entity ids that match the mutation's predicate.
|
|
// That means, if the mutation is applied within a transaction with an isolation level such
|
|
// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
|
|
// or updated by the mutation.
|
|
func (m *ConfigItemMutation) IDs(ctx context.Context) ([]int, error) {
|
|
switch {
|
|
case m.op.Is(OpUpdateOne | OpDeleteOne):
|
|
id, exists := m.ID()
|
|
if exists {
|
|
return []int{id}, nil
|
|
}
|
|
fallthrough
|
|
case m.op.Is(OpUpdate | OpDelete):
|
|
return m.Client().ConfigItem.Query().Where(m.predicates...).IDs(ctx)
|
|
default:
|
|
return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
|
|
}
|
|
}
|
|
|
|
// SetCreatedAt sets the "created_at" field.
|
|
func (m *ConfigItemMutation) SetCreatedAt(t time.Time) {
|
|
m.created_at = &t
|
|
}
|
|
|
|
// CreatedAt returns the value of the "created_at" field in the mutation.
|
|
func (m *ConfigItemMutation) CreatedAt() (r time.Time, exists bool) {
|
|
v := m.created_at
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldCreatedAt returns the old "created_at" field's value of the ConfigItem entity.
|
|
// If the ConfigItem object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *ConfigItemMutation) OldCreatedAt(ctx context.Context) (v *time.Time, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldCreatedAt requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldCreatedAt: %w", err)
|
|
}
|
|
return oldValue.CreatedAt, nil
|
|
}
|
|
|
|
// ClearCreatedAt clears the value of the "created_at" field.
|
|
func (m *ConfigItemMutation) ClearCreatedAt() {
|
|
m.created_at = nil
|
|
m.clearedFields[configitem.FieldCreatedAt] = struct{}{}
|
|
}
|
|
|
|
// CreatedAtCleared returns if the "created_at" field was cleared in this mutation.
|
|
func (m *ConfigItemMutation) CreatedAtCleared() bool {
|
|
_, ok := m.clearedFields[configitem.FieldCreatedAt]
|
|
return ok
|
|
}
|
|
|
|
// ResetCreatedAt resets all changes to the "created_at" field.
|
|
func (m *ConfigItemMutation) ResetCreatedAt() {
|
|
m.created_at = nil
|
|
delete(m.clearedFields, configitem.FieldCreatedAt)
|
|
}
|
|
|
|
// SetUpdatedAt sets the "updated_at" field.
|
|
func (m *ConfigItemMutation) SetUpdatedAt(t time.Time) {
|
|
m.updated_at = &t
|
|
}
|
|
|
|
// UpdatedAt returns the value of the "updated_at" field in the mutation.
|
|
func (m *ConfigItemMutation) UpdatedAt() (r time.Time, exists bool) {
|
|
v := m.updated_at
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldUpdatedAt returns the old "updated_at" field's value of the ConfigItem entity.
|
|
// If the ConfigItem object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *ConfigItemMutation) OldUpdatedAt(ctx context.Context) (v *time.Time, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldUpdatedAt requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldUpdatedAt: %w", err)
|
|
}
|
|
return oldValue.UpdatedAt, nil
|
|
}
|
|
|
|
// ClearUpdatedAt clears the value of the "updated_at" field.
|
|
func (m *ConfigItemMutation) ClearUpdatedAt() {
|
|
m.updated_at = nil
|
|
m.clearedFields[configitem.FieldUpdatedAt] = struct{}{}
|
|
}
|
|
|
|
// UpdatedAtCleared returns if the "updated_at" field was cleared in this mutation.
|
|
func (m *ConfigItemMutation) UpdatedAtCleared() bool {
|
|
_, ok := m.clearedFields[configitem.FieldUpdatedAt]
|
|
return ok
|
|
}
|
|
|
|
// ResetUpdatedAt resets all changes to the "updated_at" field.
|
|
func (m *ConfigItemMutation) ResetUpdatedAt() {
|
|
m.updated_at = nil
|
|
delete(m.clearedFields, configitem.FieldUpdatedAt)
|
|
}
|
|
|
|
// SetName sets the "name" field.
|
|
func (m *ConfigItemMutation) SetName(s string) {
|
|
m.name = &s
|
|
}
|
|
|
|
// Name returns the value of the "name" field in the mutation.
|
|
func (m *ConfigItemMutation) Name() (r string, exists bool) {
|
|
v := m.name
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldName returns the old "name" field's value of the ConfigItem entity.
|
|
// If the ConfigItem object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *ConfigItemMutation) OldName(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldName is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldName requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldName: %w", err)
|
|
}
|
|
return oldValue.Name, nil
|
|
}
|
|
|
|
// ResetName resets all changes to the "name" field.
|
|
func (m *ConfigItemMutation) ResetName() {
|
|
m.name = nil
|
|
}
|
|
|
|
// SetValue sets the "value" field.
|
|
func (m *ConfigItemMutation) SetValue(s string) {
|
|
m.value = &s
|
|
}
|
|
|
|
// Value returns the value of the "value" field in the mutation.
|
|
func (m *ConfigItemMutation) Value() (r string, exists bool) {
|
|
v := m.value
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldValue returns the old "value" field's value of the ConfigItem entity.
|
|
// If the ConfigItem object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *ConfigItemMutation) OldValue(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldValue is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldValue requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldValue: %w", err)
|
|
}
|
|
return oldValue.Value, nil
|
|
}
|
|
|
|
// ResetValue resets all changes to the "value" field.
|
|
func (m *ConfigItemMutation) ResetValue() {
|
|
m.value = nil
|
|
}
|
|
|
|
// Where appends a list predicates to the ConfigItemMutation builder.
|
|
func (m *ConfigItemMutation) Where(ps ...predicate.ConfigItem) {
|
|
m.predicates = append(m.predicates, ps...)
|
|
}
|
|
|
|
// WhereP appends storage-level predicates to the ConfigItemMutation builder. Using this method,
|
|
// users can use type-assertion to append predicates that do not depend on any generated package.
|
|
func (m *ConfigItemMutation) WhereP(ps ...func(*sql.Selector)) {
|
|
p := make([]predicate.ConfigItem, len(ps))
|
|
for i := range ps {
|
|
p[i] = ps[i]
|
|
}
|
|
m.Where(p...)
|
|
}
|
|
|
|
// Op returns the operation name.
|
|
func (m *ConfigItemMutation) Op() Op {
|
|
return m.op
|
|
}
|
|
|
|
// SetOp allows setting the mutation operation.
|
|
func (m *ConfigItemMutation) SetOp(op Op) {
|
|
m.op = op
|
|
}
|
|
|
|
// Type returns the node type of this mutation (ConfigItem).
|
|
func (m *ConfigItemMutation) Type() string {
|
|
return m.typ
|
|
}
|
|
|
|
// Fields returns all fields that were changed during this mutation. Note that in
|
|
// order to get all numeric fields that were incremented/decremented, call
|
|
// AddedFields().
|
|
func (m *ConfigItemMutation) Fields() []string {
|
|
fields := make([]string, 0, 4)
|
|
if m.created_at != nil {
|
|
fields = append(fields, configitem.FieldCreatedAt)
|
|
}
|
|
if m.updated_at != nil {
|
|
fields = append(fields, configitem.FieldUpdatedAt)
|
|
}
|
|
if m.name != nil {
|
|
fields = append(fields, configitem.FieldName)
|
|
}
|
|
if m.value != nil {
|
|
fields = append(fields, configitem.FieldValue)
|
|
}
|
|
return fields
|
|
}
|
|
|
|
// Field returns the value of a field with the given name. The second boolean
|
|
// return value indicates that this field was not set, or was not defined in the
|
|
// schema.
|
|
func (m *ConfigItemMutation) Field(name string) (ent.Value, bool) {
|
|
switch name {
|
|
case configitem.FieldCreatedAt:
|
|
return m.CreatedAt()
|
|
case configitem.FieldUpdatedAt:
|
|
return m.UpdatedAt()
|
|
case configitem.FieldName:
|
|
return m.Name()
|
|
case configitem.FieldValue:
|
|
return m.Value()
|
|
}
|
|
return nil, false
|
|
}
|
|
|
|
// OldField returns the old value of the field from the database. An error is
|
|
// returned if the mutation operation is not UpdateOne, or the query to the
|
|
// database failed.
|
|
func (m *ConfigItemMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
|
|
switch name {
|
|
case configitem.FieldCreatedAt:
|
|
return m.OldCreatedAt(ctx)
|
|
case configitem.FieldUpdatedAt:
|
|
return m.OldUpdatedAt(ctx)
|
|
case configitem.FieldName:
|
|
return m.OldName(ctx)
|
|
case configitem.FieldValue:
|
|
return m.OldValue(ctx)
|
|
}
|
|
return nil, fmt.Errorf("unknown ConfigItem field %s", name)
|
|
}
|
|
|
|
// SetField sets the value of a field with the given name. It returns an error if
|
|
// the field is not defined in the schema, or if the type mismatched the field
|
|
// type.
|
|
func (m *ConfigItemMutation) SetField(name string, value ent.Value) error {
|
|
switch name {
|
|
case configitem.FieldCreatedAt:
|
|
v, ok := value.(time.Time)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetCreatedAt(v)
|
|
return nil
|
|
case configitem.FieldUpdatedAt:
|
|
v, ok := value.(time.Time)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetUpdatedAt(v)
|
|
return nil
|
|
case configitem.FieldName:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetName(v)
|
|
return nil
|
|
case configitem.FieldValue:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetValue(v)
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown ConfigItem field %s", name)
|
|
}
|
|
|
|
// AddedFields returns all numeric fields that were incremented/decremented during
|
|
// this mutation.
|
|
func (m *ConfigItemMutation) AddedFields() []string {
|
|
return nil
|
|
}
|
|
|
|
// AddedField returns the numeric value that was incremented/decremented on a field
|
|
// with the given name. The second boolean return value indicates that this field
|
|
// was not set, or was not defined in the schema.
|
|
func (m *ConfigItemMutation) AddedField(name string) (ent.Value, bool) {
|
|
return nil, false
|
|
}
|
|
|
|
// AddField adds the value to the field with the given name. It returns an error if
|
|
// the field is not defined in the schema, or if the type mismatched the field
|
|
// type.
|
|
func (m *ConfigItemMutation) AddField(name string, value ent.Value) error {
|
|
switch name {
|
|
}
|
|
return fmt.Errorf("unknown ConfigItem numeric field %s", name)
|
|
}
|
|
|
|
// ClearedFields returns all nullable fields that were cleared during this
|
|
// mutation.
|
|
func (m *ConfigItemMutation) ClearedFields() []string {
|
|
var fields []string
|
|
if m.FieldCleared(configitem.FieldCreatedAt) {
|
|
fields = append(fields, configitem.FieldCreatedAt)
|
|
}
|
|
if m.FieldCleared(configitem.FieldUpdatedAt) {
|
|
fields = append(fields, configitem.FieldUpdatedAt)
|
|
}
|
|
return fields
|
|
}
|
|
|
|
// FieldCleared returns a boolean indicating if a field with the given name was
|
|
// cleared in this mutation.
|
|
func (m *ConfigItemMutation) FieldCleared(name string) bool {
|
|
_, ok := m.clearedFields[name]
|
|
return ok
|
|
}
|
|
|
|
// ClearField clears the value of the field with the given name. It returns an
|
|
// error if the field is not defined in the schema.
|
|
func (m *ConfigItemMutation) ClearField(name string) error {
|
|
switch name {
|
|
case configitem.FieldCreatedAt:
|
|
m.ClearCreatedAt()
|
|
return nil
|
|
case configitem.FieldUpdatedAt:
|
|
m.ClearUpdatedAt()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown ConfigItem nullable field %s", name)
|
|
}
|
|
|
|
// ResetField resets all changes in the mutation for the field with the given name.
|
|
// It returns an error if the field is not defined in the schema.
|
|
func (m *ConfigItemMutation) ResetField(name string) error {
|
|
switch name {
|
|
case configitem.FieldCreatedAt:
|
|
m.ResetCreatedAt()
|
|
return nil
|
|
case configitem.FieldUpdatedAt:
|
|
m.ResetUpdatedAt()
|
|
return nil
|
|
case configitem.FieldName:
|
|
m.ResetName()
|
|
return nil
|
|
case configitem.FieldValue:
|
|
m.ResetValue()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown ConfigItem field %s", name)
|
|
}
|
|
|
|
// AddedEdges returns all edge names that were set/added in this mutation.
|
|
func (m *ConfigItemMutation) AddedEdges() []string {
|
|
edges := make([]string, 0, 0)
|
|
return edges
|
|
}
|
|
|
|
// AddedIDs returns all IDs (to other nodes) that were added for the given edge
|
|
// name in this mutation.
|
|
func (m *ConfigItemMutation) AddedIDs(name string) []ent.Value {
|
|
return nil
|
|
}
|
|
|
|
// RemovedEdges returns all edge names that were removed in this mutation.
|
|
func (m *ConfigItemMutation) RemovedEdges() []string {
|
|
edges := make([]string, 0, 0)
|
|
return edges
|
|
}
|
|
|
|
// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
|
|
// the given name in this mutation.
|
|
func (m *ConfigItemMutation) RemovedIDs(name string) []ent.Value {
|
|
return nil
|
|
}
|
|
|
|
// ClearedEdges returns all edge names that were cleared in this mutation.
|
|
func (m *ConfigItemMutation) ClearedEdges() []string {
|
|
edges := make([]string, 0, 0)
|
|
return edges
|
|
}
|
|
|
|
// EdgeCleared returns a boolean which indicates if the edge with the given name
|
|
// was cleared in this mutation.
|
|
func (m *ConfigItemMutation) EdgeCleared(name string) bool {
|
|
return false
|
|
}
|
|
|
|
// ClearEdge clears the value of the edge with the given name. It returns an error
|
|
// if that edge is not defined in the schema.
|
|
func (m *ConfigItemMutation) ClearEdge(name string) error {
|
|
return fmt.Errorf("unknown ConfigItem 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 *ConfigItemMutation) ResetEdge(name string) error {
|
|
return fmt.Errorf("unknown ConfigItem edge %s", name)
|
|
}
|
|
|
|
// DecisionMutation represents an operation that mutates the Decision nodes in the graph.
|
|
type DecisionMutation struct {
|
|
config
|
|
op Op
|
|
typ string
|
|
id *int
|
|
created_at *time.Time
|
|
updated_at *time.Time
|
|
until *time.Time
|
|
scenario *string
|
|
_type *string
|
|
start_ip *int64
|
|
addstart_ip *int64
|
|
end_ip *int64
|
|
addend_ip *int64
|
|
start_suffix *int64
|
|
addstart_suffix *int64
|
|
end_suffix *int64
|
|
addend_suffix *int64
|
|
ip_size *int64
|
|
addip_size *int64
|
|
scope *string
|
|
value *string
|
|
origin *string
|
|
simulated *bool
|
|
uuid *string
|
|
clearedFields map[string]struct{}
|
|
owner *int
|
|
clearedowner bool
|
|
done bool
|
|
oldValue func(context.Context) (*Decision, error)
|
|
predicates []predicate.Decision
|
|
}
|
|
|
|
var _ ent.Mutation = (*DecisionMutation)(nil)
|
|
|
|
// decisionOption allows management of the mutation configuration using functional options.
|
|
type decisionOption func(*DecisionMutation)
|
|
|
|
// newDecisionMutation creates new mutation for the Decision entity.
|
|
func newDecisionMutation(c config, op Op, opts ...decisionOption) *DecisionMutation {
|
|
m := &DecisionMutation{
|
|
config: c,
|
|
op: op,
|
|
typ: TypeDecision,
|
|
clearedFields: make(map[string]struct{}),
|
|
}
|
|
for _, opt := range opts {
|
|
opt(m)
|
|
}
|
|
return m
|
|
}
|
|
|
|
// withDecisionID sets the ID field of the mutation.
|
|
func withDecisionID(id int) decisionOption {
|
|
return func(m *DecisionMutation) {
|
|
var (
|
|
err error
|
|
once sync.Once
|
|
value *Decision
|
|
)
|
|
m.oldValue = func(ctx context.Context) (*Decision, error) {
|
|
once.Do(func() {
|
|
if m.done {
|
|
err = errors.New("querying old values post mutation is not allowed")
|
|
} else {
|
|
value, err = m.Client().Decision.Get(ctx, id)
|
|
}
|
|
})
|
|
return value, err
|
|
}
|
|
m.id = &id
|
|
}
|
|
}
|
|
|
|
// withDecision sets the old Decision of the mutation.
|
|
func withDecision(node *Decision) decisionOption {
|
|
return func(m *DecisionMutation) {
|
|
m.oldValue = func(context.Context) (*Decision, error) {
|
|
return node, nil
|
|
}
|
|
m.id = &node.ID
|
|
}
|
|
}
|
|
|
|
// Client returns a new `ent.Client` from the mutation. If the mutation was
|
|
// executed in a transaction (ent.Tx), a transactional client is returned.
|
|
func (m DecisionMutation) Client() *Client {
|
|
client := &Client{config: m.config}
|
|
client.init()
|
|
return client
|
|
}
|
|
|
|
// Tx returns an `ent.Tx` for mutations that were executed in transactions;
|
|
// it returns an error otherwise.
|
|
func (m DecisionMutation) Tx() (*Tx, error) {
|
|
if _, ok := m.driver.(*txDriver); !ok {
|
|
return nil, errors.New("ent: mutation is not running in a transaction")
|
|
}
|
|
tx := &Tx{config: m.config}
|
|
tx.init()
|
|
return tx, nil
|
|
}
|
|
|
|
// ID returns the ID value in the mutation. Note that the ID is only available
|
|
// if it was provided to the builder or after it was returned from the database.
|
|
func (m *DecisionMutation) ID() (id int, exists bool) {
|
|
if m.id == nil {
|
|
return
|
|
}
|
|
return *m.id, true
|
|
}
|
|
|
|
// IDs queries the database and returns the entity ids that match the mutation's predicate.
|
|
// That means, if the mutation is applied within a transaction with an isolation level such
|
|
// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
|
|
// or updated by the mutation.
|
|
func (m *DecisionMutation) IDs(ctx context.Context) ([]int, error) {
|
|
switch {
|
|
case m.op.Is(OpUpdateOne | OpDeleteOne):
|
|
id, exists := m.ID()
|
|
if exists {
|
|
return []int{id}, nil
|
|
}
|
|
fallthrough
|
|
case m.op.Is(OpUpdate | OpDelete):
|
|
return m.Client().Decision.Query().Where(m.predicates...).IDs(ctx)
|
|
default:
|
|
return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
|
|
}
|
|
}
|
|
|
|
// SetCreatedAt sets the "created_at" field.
|
|
func (m *DecisionMutation) SetCreatedAt(t time.Time) {
|
|
m.created_at = &t
|
|
}
|
|
|
|
// CreatedAt returns the value of the "created_at" field in the mutation.
|
|
func (m *DecisionMutation) CreatedAt() (r time.Time, exists bool) {
|
|
v := m.created_at
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldCreatedAt returns the old "created_at" field's value of the Decision entity.
|
|
// If the Decision object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *DecisionMutation) OldCreatedAt(ctx context.Context) (v *time.Time, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldCreatedAt requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldCreatedAt: %w", err)
|
|
}
|
|
return oldValue.CreatedAt, nil
|
|
}
|
|
|
|
// ClearCreatedAt clears the value of the "created_at" field.
|
|
func (m *DecisionMutation) ClearCreatedAt() {
|
|
m.created_at = nil
|
|
m.clearedFields[decision.FieldCreatedAt] = struct{}{}
|
|
}
|
|
|
|
// CreatedAtCleared returns if the "created_at" field was cleared in this mutation.
|
|
func (m *DecisionMutation) CreatedAtCleared() bool {
|
|
_, ok := m.clearedFields[decision.FieldCreatedAt]
|
|
return ok
|
|
}
|
|
|
|
// ResetCreatedAt resets all changes to the "created_at" field.
|
|
func (m *DecisionMutation) ResetCreatedAt() {
|
|
m.created_at = nil
|
|
delete(m.clearedFields, decision.FieldCreatedAt)
|
|
}
|
|
|
|
// SetUpdatedAt sets the "updated_at" field.
|
|
func (m *DecisionMutation) SetUpdatedAt(t time.Time) {
|
|
m.updated_at = &t
|
|
}
|
|
|
|
// UpdatedAt returns the value of the "updated_at" field in the mutation.
|
|
func (m *DecisionMutation) UpdatedAt() (r time.Time, exists bool) {
|
|
v := m.updated_at
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldUpdatedAt returns the old "updated_at" field's value of the Decision entity.
|
|
// If the Decision object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *DecisionMutation) OldUpdatedAt(ctx context.Context) (v *time.Time, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldUpdatedAt requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldUpdatedAt: %w", err)
|
|
}
|
|
return oldValue.UpdatedAt, nil
|
|
}
|
|
|
|
// ClearUpdatedAt clears the value of the "updated_at" field.
|
|
func (m *DecisionMutation) ClearUpdatedAt() {
|
|
m.updated_at = nil
|
|
m.clearedFields[decision.FieldUpdatedAt] = struct{}{}
|
|
}
|
|
|
|
// UpdatedAtCleared returns if the "updated_at" field was cleared in this mutation.
|
|
func (m *DecisionMutation) UpdatedAtCleared() bool {
|
|
_, ok := m.clearedFields[decision.FieldUpdatedAt]
|
|
return ok
|
|
}
|
|
|
|
// ResetUpdatedAt resets all changes to the "updated_at" field.
|
|
func (m *DecisionMutation) ResetUpdatedAt() {
|
|
m.updated_at = nil
|
|
delete(m.clearedFields, decision.FieldUpdatedAt)
|
|
}
|
|
|
|
// SetUntil sets the "until" field.
|
|
func (m *DecisionMutation) SetUntil(t time.Time) {
|
|
m.until = &t
|
|
}
|
|
|
|
// Until returns the value of the "until" field in the mutation.
|
|
func (m *DecisionMutation) Until() (r time.Time, exists bool) {
|
|
v := m.until
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldUntil returns the old "until" field's value of the Decision entity.
|
|
// If the Decision object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *DecisionMutation) OldUntil(ctx context.Context) (v *time.Time, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldUntil is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldUntil requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldUntil: %w", err)
|
|
}
|
|
return oldValue.Until, nil
|
|
}
|
|
|
|
// ClearUntil clears the value of the "until" field.
|
|
func (m *DecisionMutation) ClearUntil() {
|
|
m.until = nil
|
|
m.clearedFields[decision.FieldUntil] = struct{}{}
|
|
}
|
|
|
|
// UntilCleared returns if the "until" field was cleared in this mutation.
|
|
func (m *DecisionMutation) UntilCleared() bool {
|
|
_, ok := m.clearedFields[decision.FieldUntil]
|
|
return ok
|
|
}
|
|
|
|
// ResetUntil resets all changes to the "until" field.
|
|
func (m *DecisionMutation) ResetUntil() {
|
|
m.until = nil
|
|
delete(m.clearedFields, decision.FieldUntil)
|
|
}
|
|
|
|
// SetScenario sets the "scenario" field.
|
|
func (m *DecisionMutation) SetScenario(s string) {
|
|
m.scenario = &s
|
|
}
|
|
|
|
// Scenario returns the value of the "scenario" field in the mutation.
|
|
func (m *DecisionMutation) Scenario() (r string, exists bool) {
|
|
v := m.scenario
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldScenario returns the old "scenario" field's value of the Decision entity.
|
|
// If the Decision object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *DecisionMutation) OldScenario(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldScenario is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldScenario requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldScenario: %w", err)
|
|
}
|
|
return oldValue.Scenario, nil
|
|
}
|
|
|
|
// ResetScenario resets all changes to the "scenario" field.
|
|
func (m *DecisionMutation) ResetScenario() {
|
|
m.scenario = nil
|
|
}
|
|
|
|
// SetType sets the "type" field.
|
|
func (m *DecisionMutation) SetType(s string) {
|
|
m._type = &s
|
|
}
|
|
|
|
// GetType returns the value of the "type" field in the mutation.
|
|
func (m *DecisionMutation) GetType() (r string, exists bool) {
|
|
v := m._type
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldType returns the old "type" field's value of the Decision entity.
|
|
// If the Decision object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *DecisionMutation) OldType(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldType is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldType requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldType: %w", err)
|
|
}
|
|
return oldValue.Type, nil
|
|
}
|
|
|
|
// ResetType resets all changes to the "type" field.
|
|
func (m *DecisionMutation) ResetType() {
|
|
m._type = nil
|
|
}
|
|
|
|
// SetStartIP sets the "start_ip" field.
|
|
func (m *DecisionMutation) SetStartIP(i int64) {
|
|
m.start_ip = &i
|
|
m.addstart_ip = nil
|
|
}
|
|
|
|
// StartIP returns the value of the "start_ip" field in the mutation.
|
|
func (m *DecisionMutation) StartIP() (r int64, exists bool) {
|
|
v := m.start_ip
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldStartIP returns the old "start_ip" field's value of the Decision entity.
|
|
// If the Decision object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *DecisionMutation) OldStartIP(ctx context.Context) (v int64, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldStartIP is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldStartIP requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldStartIP: %w", err)
|
|
}
|
|
return oldValue.StartIP, nil
|
|
}
|
|
|
|
// AddStartIP adds i to the "start_ip" field.
|
|
func (m *DecisionMutation) AddStartIP(i int64) {
|
|
if m.addstart_ip != nil {
|
|
*m.addstart_ip += i
|
|
} else {
|
|
m.addstart_ip = &i
|
|
}
|
|
}
|
|
|
|
// AddedStartIP returns the value that was added to the "start_ip" field in this mutation.
|
|
func (m *DecisionMutation) AddedStartIP() (r int64, exists bool) {
|
|
v := m.addstart_ip
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// ClearStartIP clears the value of the "start_ip" field.
|
|
func (m *DecisionMutation) ClearStartIP() {
|
|
m.start_ip = nil
|
|
m.addstart_ip = nil
|
|
m.clearedFields[decision.FieldStartIP] = struct{}{}
|
|
}
|
|
|
|
// StartIPCleared returns if the "start_ip" field was cleared in this mutation.
|
|
func (m *DecisionMutation) StartIPCleared() bool {
|
|
_, ok := m.clearedFields[decision.FieldStartIP]
|
|
return ok
|
|
}
|
|
|
|
// ResetStartIP resets all changes to the "start_ip" field.
|
|
func (m *DecisionMutation) ResetStartIP() {
|
|
m.start_ip = nil
|
|
m.addstart_ip = nil
|
|
delete(m.clearedFields, decision.FieldStartIP)
|
|
}
|
|
|
|
// SetEndIP sets the "end_ip" field.
|
|
func (m *DecisionMutation) SetEndIP(i int64) {
|
|
m.end_ip = &i
|
|
m.addend_ip = nil
|
|
}
|
|
|
|
// EndIP returns the value of the "end_ip" field in the mutation.
|
|
func (m *DecisionMutation) EndIP() (r int64, exists bool) {
|
|
v := m.end_ip
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldEndIP returns the old "end_ip" field's value of the Decision entity.
|
|
// If the Decision object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *DecisionMutation) OldEndIP(ctx context.Context) (v int64, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldEndIP is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldEndIP requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldEndIP: %w", err)
|
|
}
|
|
return oldValue.EndIP, nil
|
|
}
|
|
|
|
// AddEndIP adds i to the "end_ip" field.
|
|
func (m *DecisionMutation) AddEndIP(i int64) {
|
|
if m.addend_ip != nil {
|
|
*m.addend_ip += i
|
|
} else {
|
|
m.addend_ip = &i
|
|
}
|
|
}
|
|
|
|
// AddedEndIP returns the value that was added to the "end_ip" field in this mutation.
|
|
func (m *DecisionMutation) AddedEndIP() (r int64, exists bool) {
|
|
v := m.addend_ip
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// ClearEndIP clears the value of the "end_ip" field.
|
|
func (m *DecisionMutation) ClearEndIP() {
|
|
m.end_ip = nil
|
|
m.addend_ip = nil
|
|
m.clearedFields[decision.FieldEndIP] = struct{}{}
|
|
}
|
|
|
|
// EndIPCleared returns if the "end_ip" field was cleared in this mutation.
|
|
func (m *DecisionMutation) EndIPCleared() bool {
|
|
_, ok := m.clearedFields[decision.FieldEndIP]
|
|
return ok
|
|
}
|
|
|
|
// ResetEndIP resets all changes to the "end_ip" field.
|
|
func (m *DecisionMutation) ResetEndIP() {
|
|
m.end_ip = nil
|
|
m.addend_ip = nil
|
|
delete(m.clearedFields, decision.FieldEndIP)
|
|
}
|
|
|
|
// SetStartSuffix sets the "start_suffix" field.
|
|
func (m *DecisionMutation) SetStartSuffix(i int64) {
|
|
m.start_suffix = &i
|
|
m.addstart_suffix = nil
|
|
}
|
|
|
|
// StartSuffix returns the value of the "start_suffix" field in the mutation.
|
|
func (m *DecisionMutation) StartSuffix() (r int64, exists bool) {
|
|
v := m.start_suffix
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldStartSuffix returns the old "start_suffix" field's value of the Decision entity.
|
|
// If the Decision object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *DecisionMutation) OldStartSuffix(ctx context.Context) (v int64, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldStartSuffix is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldStartSuffix requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldStartSuffix: %w", err)
|
|
}
|
|
return oldValue.StartSuffix, nil
|
|
}
|
|
|
|
// AddStartSuffix adds i to the "start_suffix" field.
|
|
func (m *DecisionMutation) AddStartSuffix(i int64) {
|
|
if m.addstart_suffix != nil {
|
|
*m.addstart_suffix += i
|
|
} else {
|
|
m.addstart_suffix = &i
|
|
}
|
|
}
|
|
|
|
// AddedStartSuffix returns the value that was added to the "start_suffix" field in this mutation.
|
|
func (m *DecisionMutation) AddedStartSuffix() (r int64, exists bool) {
|
|
v := m.addstart_suffix
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// ClearStartSuffix clears the value of the "start_suffix" field.
|
|
func (m *DecisionMutation) ClearStartSuffix() {
|
|
m.start_suffix = nil
|
|
m.addstart_suffix = nil
|
|
m.clearedFields[decision.FieldStartSuffix] = struct{}{}
|
|
}
|
|
|
|
// StartSuffixCleared returns if the "start_suffix" field was cleared in this mutation.
|
|
func (m *DecisionMutation) StartSuffixCleared() bool {
|
|
_, ok := m.clearedFields[decision.FieldStartSuffix]
|
|
return ok
|
|
}
|
|
|
|
// ResetStartSuffix resets all changes to the "start_suffix" field.
|
|
func (m *DecisionMutation) ResetStartSuffix() {
|
|
m.start_suffix = nil
|
|
m.addstart_suffix = nil
|
|
delete(m.clearedFields, decision.FieldStartSuffix)
|
|
}
|
|
|
|
// SetEndSuffix sets the "end_suffix" field.
|
|
func (m *DecisionMutation) SetEndSuffix(i int64) {
|
|
m.end_suffix = &i
|
|
m.addend_suffix = nil
|
|
}
|
|
|
|
// EndSuffix returns the value of the "end_suffix" field in the mutation.
|
|
func (m *DecisionMutation) EndSuffix() (r int64, exists bool) {
|
|
v := m.end_suffix
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldEndSuffix returns the old "end_suffix" field's value of the Decision entity.
|
|
// If the Decision object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *DecisionMutation) OldEndSuffix(ctx context.Context) (v int64, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldEndSuffix is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldEndSuffix requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldEndSuffix: %w", err)
|
|
}
|
|
return oldValue.EndSuffix, nil
|
|
}
|
|
|
|
// AddEndSuffix adds i to the "end_suffix" field.
|
|
func (m *DecisionMutation) AddEndSuffix(i int64) {
|
|
if m.addend_suffix != nil {
|
|
*m.addend_suffix += i
|
|
} else {
|
|
m.addend_suffix = &i
|
|
}
|
|
}
|
|
|
|
// AddedEndSuffix returns the value that was added to the "end_suffix" field in this mutation.
|
|
func (m *DecisionMutation) AddedEndSuffix() (r int64, exists bool) {
|
|
v := m.addend_suffix
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// ClearEndSuffix clears the value of the "end_suffix" field.
|
|
func (m *DecisionMutation) ClearEndSuffix() {
|
|
m.end_suffix = nil
|
|
m.addend_suffix = nil
|
|
m.clearedFields[decision.FieldEndSuffix] = struct{}{}
|
|
}
|
|
|
|
// EndSuffixCleared returns if the "end_suffix" field was cleared in this mutation.
|
|
func (m *DecisionMutation) EndSuffixCleared() bool {
|
|
_, ok := m.clearedFields[decision.FieldEndSuffix]
|
|
return ok
|
|
}
|
|
|
|
// ResetEndSuffix resets all changes to the "end_suffix" field.
|
|
func (m *DecisionMutation) ResetEndSuffix() {
|
|
m.end_suffix = nil
|
|
m.addend_suffix = nil
|
|
delete(m.clearedFields, decision.FieldEndSuffix)
|
|
}
|
|
|
|
// SetIPSize sets the "ip_size" field.
|
|
func (m *DecisionMutation) SetIPSize(i int64) {
|
|
m.ip_size = &i
|
|
m.addip_size = nil
|
|
}
|
|
|
|
// IPSize returns the value of the "ip_size" field in the mutation.
|
|
func (m *DecisionMutation) IPSize() (r int64, exists bool) {
|
|
v := m.ip_size
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldIPSize returns the old "ip_size" field's value of the Decision entity.
|
|
// If the Decision object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *DecisionMutation) OldIPSize(ctx context.Context) (v int64, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldIPSize is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldIPSize requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldIPSize: %w", err)
|
|
}
|
|
return oldValue.IPSize, nil
|
|
}
|
|
|
|
// AddIPSize adds i to the "ip_size" field.
|
|
func (m *DecisionMutation) AddIPSize(i int64) {
|
|
if m.addip_size != nil {
|
|
*m.addip_size += i
|
|
} else {
|
|
m.addip_size = &i
|
|
}
|
|
}
|
|
|
|
// AddedIPSize returns the value that was added to the "ip_size" field in this mutation.
|
|
func (m *DecisionMutation) AddedIPSize() (r int64, exists bool) {
|
|
v := m.addip_size
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// ClearIPSize clears the value of the "ip_size" field.
|
|
func (m *DecisionMutation) ClearIPSize() {
|
|
m.ip_size = nil
|
|
m.addip_size = nil
|
|
m.clearedFields[decision.FieldIPSize] = struct{}{}
|
|
}
|
|
|
|
// IPSizeCleared returns if the "ip_size" field was cleared in this mutation.
|
|
func (m *DecisionMutation) IPSizeCleared() bool {
|
|
_, ok := m.clearedFields[decision.FieldIPSize]
|
|
return ok
|
|
}
|
|
|
|
// ResetIPSize resets all changes to the "ip_size" field.
|
|
func (m *DecisionMutation) ResetIPSize() {
|
|
m.ip_size = nil
|
|
m.addip_size = nil
|
|
delete(m.clearedFields, decision.FieldIPSize)
|
|
}
|
|
|
|
// SetScope sets the "scope" field.
|
|
func (m *DecisionMutation) SetScope(s string) {
|
|
m.scope = &s
|
|
}
|
|
|
|
// Scope returns the value of the "scope" field in the mutation.
|
|
func (m *DecisionMutation) Scope() (r string, exists bool) {
|
|
v := m.scope
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldScope returns the old "scope" field's value of the Decision entity.
|
|
// If the Decision object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *DecisionMutation) OldScope(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldScope is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldScope requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldScope: %w", err)
|
|
}
|
|
return oldValue.Scope, nil
|
|
}
|
|
|
|
// ResetScope resets all changes to the "scope" field.
|
|
func (m *DecisionMutation) ResetScope() {
|
|
m.scope = nil
|
|
}
|
|
|
|
// SetValue sets the "value" field.
|
|
func (m *DecisionMutation) SetValue(s string) {
|
|
m.value = &s
|
|
}
|
|
|
|
// Value returns the value of the "value" field in the mutation.
|
|
func (m *DecisionMutation) Value() (r string, exists bool) {
|
|
v := m.value
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldValue returns the old "value" field's value of the Decision entity.
|
|
// If the Decision object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *DecisionMutation) OldValue(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldValue is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldValue requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldValue: %w", err)
|
|
}
|
|
return oldValue.Value, nil
|
|
}
|
|
|
|
// ResetValue resets all changes to the "value" field.
|
|
func (m *DecisionMutation) ResetValue() {
|
|
m.value = nil
|
|
}
|
|
|
|
// SetOrigin sets the "origin" field.
|
|
func (m *DecisionMutation) SetOrigin(s string) {
|
|
m.origin = &s
|
|
}
|
|
|
|
// Origin returns the value of the "origin" field in the mutation.
|
|
func (m *DecisionMutation) Origin() (r string, exists bool) {
|
|
v := m.origin
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldOrigin returns the old "origin" field's value of the Decision entity.
|
|
// If the Decision object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *DecisionMutation) OldOrigin(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldOrigin is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldOrigin requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldOrigin: %w", err)
|
|
}
|
|
return oldValue.Origin, nil
|
|
}
|
|
|
|
// ResetOrigin resets all changes to the "origin" field.
|
|
func (m *DecisionMutation) ResetOrigin() {
|
|
m.origin = nil
|
|
}
|
|
|
|
// SetSimulated sets the "simulated" field.
|
|
func (m *DecisionMutation) SetSimulated(b bool) {
|
|
m.simulated = &b
|
|
}
|
|
|
|
// Simulated returns the value of the "simulated" field in the mutation.
|
|
func (m *DecisionMutation) Simulated() (r bool, exists bool) {
|
|
v := m.simulated
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldSimulated returns the old "simulated" field's value of the Decision entity.
|
|
// If the Decision object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *DecisionMutation) OldSimulated(ctx context.Context) (v bool, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldSimulated is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldSimulated requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldSimulated: %w", err)
|
|
}
|
|
return oldValue.Simulated, nil
|
|
}
|
|
|
|
// ResetSimulated resets all changes to the "simulated" field.
|
|
func (m *DecisionMutation) ResetSimulated() {
|
|
m.simulated = nil
|
|
}
|
|
|
|
// SetUUID sets the "uuid" field.
|
|
func (m *DecisionMutation) SetUUID(s string) {
|
|
m.uuid = &s
|
|
}
|
|
|
|
// UUID returns the value of the "uuid" field in the mutation.
|
|
func (m *DecisionMutation) UUID() (r string, exists bool) {
|
|
v := m.uuid
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldUUID returns the old "uuid" field's value of the Decision entity.
|
|
// If the Decision object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *DecisionMutation) OldUUID(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldUUID is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldUUID requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldUUID: %w", err)
|
|
}
|
|
return oldValue.UUID, nil
|
|
}
|
|
|
|
// ClearUUID clears the value of the "uuid" field.
|
|
func (m *DecisionMutation) ClearUUID() {
|
|
m.uuid = nil
|
|
m.clearedFields[decision.FieldUUID] = struct{}{}
|
|
}
|
|
|
|
// UUIDCleared returns if the "uuid" field was cleared in this mutation.
|
|
func (m *DecisionMutation) UUIDCleared() bool {
|
|
_, ok := m.clearedFields[decision.FieldUUID]
|
|
return ok
|
|
}
|
|
|
|
// ResetUUID resets all changes to the "uuid" field.
|
|
func (m *DecisionMutation) ResetUUID() {
|
|
m.uuid = nil
|
|
delete(m.clearedFields, decision.FieldUUID)
|
|
}
|
|
|
|
// SetAlertDecisions sets the "alert_decisions" field.
|
|
func (m *DecisionMutation) SetAlertDecisions(i int) {
|
|
m.owner = &i
|
|
}
|
|
|
|
// AlertDecisions returns the value of the "alert_decisions" field in the mutation.
|
|
func (m *DecisionMutation) AlertDecisions() (r int, exists bool) {
|
|
v := m.owner
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldAlertDecisions returns the old "alert_decisions" field's value of the Decision entity.
|
|
// If the Decision object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *DecisionMutation) OldAlertDecisions(ctx context.Context) (v int, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldAlertDecisions is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldAlertDecisions requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldAlertDecisions: %w", err)
|
|
}
|
|
return oldValue.AlertDecisions, nil
|
|
}
|
|
|
|
// ClearAlertDecisions clears the value of the "alert_decisions" field.
|
|
func (m *DecisionMutation) ClearAlertDecisions() {
|
|
m.owner = nil
|
|
m.clearedFields[decision.FieldAlertDecisions] = struct{}{}
|
|
}
|
|
|
|
// AlertDecisionsCleared returns if the "alert_decisions" field was cleared in this mutation.
|
|
func (m *DecisionMutation) AlertDecisionsCleared() bool {
|
|
_, ok := m.clearedFields[decision.FieldAlertDecisions]
|
|
return ok
|
|
}
|
|
|
|
// ResetAlertDecisions resets all changes to the "alert_decisions" field.
|
|
func (m *DecisionMutation) ResetAlertDecisions() {
|
|
m.owner = nil
|
|
delete(m.clearedFields, decision.FieldAlertDecisions)
|
|
}
|
|
|
|
// SetOwnerID sets the "owner" edge to the Alert entity by id.
|
|
func (m *DecisionMutation) SetOwnerID(id int) {
|
|
m.owner = &id
|
|
}
|
|
|
|
// ClearOwner clears the "owner" edge to the Alert entity.
|
|
func (m *DecisionMutation) ClearOwner() {
|
|
m.clearedowner = true
|
|
m.clearedFields[decision.FieldAlertDecisions] = struct{}{}
|
|
}
|
|
|
|
// OwnerCleared reports if the "owner" edge to the Alert entity was cleared.
|
|
func (m *DecisionMutation) OwnerCleared() bool {
|
|
return m.AlertDecisionsCleared() || m.clearedowner
|
|
}
|
|
|
|
// OwnerID returns the "owner" edge ID in the mutation.
|
|
func (m *DecisionMutation) OwnerID() (id int, exists bool) {
|
|
if m.owner != nil {
|
|
return *m.owner, true
|
|
}
|
|
return
|
|
}
|
|
|
|
// OwnerIDs returns the "owner" edge IDs in the mutation.
|
|
// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use
|
|
// OwnerID instead. It exists only for internal usage by the builders.
|
|
func (m *DecisionMutation) OwnerIDs() (ids []int) {
|
|
if id := m.owner; id != nil {
|
|
ids = append(ids, *id)
|
|
}
|
|
return
|
|
}
|
|
|
|
// ResetOwner resets all changes to the "owner" edge.
|
|
func (m *DecisionMutation) ResetOwner() {
|
|
m.owner = nil
|
|
m.clearedowner = false
|
|
}
|
|
|
|
// Where appends a list predicates to the DecisionMutation builder.
|
|
func (m *DecisionMutation) Where(ps ...predicate.Decision) {
|
|
m.predicates = append(m.predicates, ps...)
|
|
}
|
|
|
|
// WhereP appends storage-level predicates to the DecisionMutation builder. Using this method,
|
|
// users can use type-assertion to append predicates that do not depend on any generated package.
|
|
func (m *DecisionMutation) WhereP(ps ...func(*sql.Selector)) {
|
|
p := make([]predicate.Decision, len(ps))
|
|
for i := range ps {
|
|
p[i] = ps[i]
|
|
}
|
|
m.Where(p...)
|
|
}
|
|
|
|
// Op returns the operation name.
|
|
func (m *DecisionMutation) Op() Op {
|
|
return m.op
|
|
}
|
|
|
|
// SetOp allows setting the mutation operation.
|
|
func (m *DecisionMutation) SetOp(op Op) {
|
|
m.op = op
|
|
}
|
|
|
|
// Type returns the node type of this mutation (Decision).
|
|
func (m *DecisionMutation) Type() string {
|
|
return m.typ
|
|
}
|
|
|
|
// Fields returns all fields that were changed during this mutation. Note that in
|
|
// order to get all numeric fields that were incremented/decremented, call
|
|
// AddedFields().
|
|
func (m *DecisionMutation) Fields() []string {
|
|
fields := make([]string, 0, 16)
|
|
if m.created_at != nil {
|
|
fields = append(fields, decision.FieldCreatedAt)
|
|
}
|
|
if m.updated_at != nil {
|
|
fields = append(fields, decision.FieldUpdatedAt)
|
|
}
|
|
if m.until != nil {
|
|
fields = append(fields, decision.FieldUntil)
|
|
}
|
|
if m.scenario != nil {
|
|
fields = append(fields, decision.FieldScenario)
|
|
}
|
|
if m._type != nil {
|
|
fields = append(fields, decision.FieldType)
|
|
}
|
|
if m.start_ip != nil {
|
|
fields = append(fields, decision.FieldStartIP)
|
|
}
|
|
if m.end_ip != nil {
|
|
fields = append(fields, decision.FieldEndIP)
|
|
}
|
|
if m.start_suffix != nil {
|
|
fields = append(fields, decision.FieldStartSuffix)
|
|
}
|
|
if m.end_suffix != nil {
|
|
fields = append(fields, decision.FieldEndSuffix)
|
|
}
|
|
if m.ip_size != nil {
|
|
fields = append(fields, decision.FieldIPSize)
|
|
}
|
|
if m.scope != nil {
|
|
fields = append(fields, decision.FieldScope)
|
|
}
|
|
if m.value != nil {
|
|
fields = append(fields, decision.FieldValue)
|
|
}
|
|
if m.origin != nil {
|
|
fields = append(fields, decision.FieldOrigin)
|
|
}
|
|
if m.simulated != nil {
|
|
fields = append(fields, decision.FieldSimulated)
|
|
}
|
|
if m.uuid != nil {
|
|
fields = append(fields, decision.FieldUUID)
|
|
}
|
|
if m.owner != nil {
|
|
fields = append(fields, decision.FieldAlertDecisions)
|
|
}
|
|
return fields
|
|
}
|
|
|
|
// Field returns the value of a field with the given name. The second boolean
|
|
// return value indicates that this field was not set, or was not defined in the
|
|
// schema.
|
|
func (m *DecisionMutation) Field(name string) (ent.Value, bool) {
|
|
switch name {
|
|
case decision.FieldCreatedAt:
|
|
return m.CreatedAt()
|
|
case decision.FieldUpdatedAt:
|
|
return m.UpdatedAt()
|
|
case decision.FieldUntil:
|
|
return m.Until()
|
|
case decision.FieldScenario:
|
|
return m.Scenario()
|
|
case decision.FieldType:
|
|
return m.GetType()
|
|
case decision.FieldStartIP:
|
|
return m.StartIP()
|
|
case decision.FieldEndIP:
|
|
return m.EndIP()
|
|
case decision.FieldStartSuffix:
|
|
return m.StartSuffix()
|
|
case decision.FieldEndSuffix:
|
|
return m.EndSuffix()
|
|
case decision.FieldIPSize:
|
|
return m.IPSize()
|
|
case decision.FieldScope:
|
|
return m.Scope()
|
|
case decision.FieldValue:
|
|
return m.Value()
|
|
case decision.FieldOrigin:
|
|
return m.Origin()
|
|
case decision.FieldSimulated:
|
|
return m.Simulated()
|
|
case decision.FieldUUID:
|
|
return m.UUID()
|
|
case decision.FieldAlertDecisions:
|
|
return m.AlertDecisions()
|
|
}
|
|
return nil, false
|
|
}
|
|
|
|
// OldField returns the old value of the field from the database. An error is
|
|
// returned if the mutation operation is not UpdateOne, or the query to the
|
|
// database failed.
|
|
func (m *DecisionMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
|
|
switch name {
|
|
case decision.FieldCreatedAt:
|
|
return m.OldCreatedAt(ctx)
|
|
case decision.FieldUpdatedAt:
|
|
return m.OldUpdatedAt(ctx)
|
|
case decision.FieldUntil:
|
|
return m.OldUntil(ctx)
|
|
case decision.FieldScenario:
|
|
return m.OldScenario(ctx)
|
|
case decision.FieldType:
|
|
return m.OldType(ctx)
|
|
case decision.FieldStartIP:
|
|
return m.OldStartIP(ctx)
|
|
case decision.FieldEndIP:
|
|
return m.OldEndIP(ctx)
|
|
case decision.FieldStartSuffix:
|
|
return m.OldStartSuffix(ctx)
|
|
case decision.FieldEndSuffix:
|
|
return m.OldEndSuffix(ctx)
|
|
case decision.FieldIPSize:
|
|
return m.OldIPSize(ctx)
|
|
case decision.FieldScope:
|
|
return m.OldScope(ctx)
|
|
case decision.FieldValue:
|
|
return m.OldValue(ctx)
|
|
case decision.FieldOrigin:
|
|
return m.OldOrigin(ctx)
|
|
case decision.FieldSimulated:
|
|
return m.OldSimulated(ctx)
|
|
case decision.FieldUUID:
|
|
return m.OldUUID(ctx)
|
|
case decision.FieldAlertDecisions:
|
|
return m.OldAlertDecisions(ctx)
|
|
}
|
|
return nil, fmt.Errorf("unknown Decision field %s", name)
|
|
}
|
|
|
|
// SetField sets the value of a field with the given name. It returns an error if
|
|
// the field is not defined in the schema, or if the type mismatched the field
|
|
// type.
|
|
func (m *DecisionMutation) SetField(name string, value ent.Value) error {
|
|
switch name {
|
|
case decision.FieldCreatedAt:
|
|
v, ok := value.(time.Time)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetCreatedAt(v)
|
|
return nil
|
|
case decision.FieldUpdatedAt:
|
|
v, ok := value.(time.Time)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetUpdatedAt(v)
|
|
return nil
|
|
case decision.FieldUntil:
|
|
v, ok := value.(time.Time)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetUntil(v)
|
|
return nil
|
|
case decision.FieldScenario:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetScenario(v)
|
|
return nil
|
|
case decision.FieldType:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetType(v)
|
|
return nil
|
|
case decision.FieldStartIP:
|
|
v, ok := value.(int64)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetStartIP(v)
|
|
return nil
|
|
case decision.FieldEndIP:
|
|
v, ok := value.(int64)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetEndIP(v)
|
|
return nil
|
|
case decision.FieldStartSuffix:
|
|
v, ok := value.(int64)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetStartSuffix(v)
|
|
return nil
|
|
case decision.FieldEndSuffix:
|
|
v, ok := value.(int64)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetEndSuffix(v)
|
|
return nil
|
|
case decision.FieldIPSize:
|
|
v, ok := value.(int64)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetIPSize(v)
|
|
return nil
|
|
case decision.FieldScope:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetScope(v)
|
|
return nil
|
|
case decision.FieldValue:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetValue(v)
|
|
return nil
|
|
case decision.FieldOrigin:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetOrigin(v)
|
|
return nil
|
|
case decision.FieldSimulated:
|
|
v, ok := value.(bool)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetSimulated(v)
|
|
return nil
|
|
case decision.FieldUUID:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetUUID(v)
|
|
return nil
|
|
case decision.FieldAlertDecisions:
|
|
v, ok := value.(int)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetAlertDecisions(v)
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Decision field %s", name)
|
|
}
|
|
|
|
// AddedFields returns all numeric fields that were incremented/decremented during
|
|
// this mutation.
|
|
func (m *DecisionMutation) AddedFields() []string {
|
|
var fields []string
|
|
if m.addstart_ip != nil {
|
|
fields = append(fields, decision.FieldStartIP)
|
|
}
|
|
if m.addend_ip != nil {
|
|
fields = append(fields, decision.FieldEndIP)
|
|
}
|
|
if m.addstart_suffix != nil {
|
|
fields = append(fields, decision.FieldStartSuffix)
|
|
}
|
|
if m.addend_suffix != nil {
|
|
fields = append(fields, decision.FieldEndSuffix)
|
|
}
|
|
if m.addip_size != nil {
|
|
fields = append(fields, decision.FieldIPSize)
|
|
}
|
|
return fields
|
|
}
|
|
|
|
// AddedField returns the numeric value that was incremented/decremented on a field
|
|
// with the given name. The second boolean return value indicates that this field
|
|
// was not set, or was not defined in the schema.
|
|
func (m *DecisionMutation) AddedField(name string) (ent.Value, bool) {
|
|
switch name {
|
|
case decision.FieldStartIP:
|
|
return m.AddedStartIP()
|
|
case decision.FieldEndIP:
|
|
return m.AddedEndIP()
|
|
case decision.FieldStartSuffix:
|
|
return m.AddedStartSuffix()
|
|
case decision.FieldEndSuffix:
|
|
return m.AddedEndSuffix()
|
|
case decision.FieldIPSize:
|
|
return m.AddedIPSize()
|
|
}
|
|
return nil, false
|
|
}
|
|
|
|
// AddField adds the value to the field with the given name. It returns an error if
|
|
// the field is not defined in the schema, or if the type mismatched the field
|
|
// type.
|
|
func (m *DecisionMutation) AddField(name string, value ent.Value) error {
|
|
switch name {
|
|
case decision.FieldStartIP:
|
|
v, ok := value.(int64)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.AddStartIP(v)
|
|
return nil
|
|
case decision.FieldEndIP:
|
|
v, ok := value.(int64)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.AddEndIP(v)
|
|
return nil
|
|
case decision.FieldStartSuffix:
|
|
v, ok := value.(int64)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.AddStartSuffix(v)
|
|
return nil
|
|
case decision.FieldEndSuffix:
|
|
v, ok := value.(int64)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.AddEndSuffix(v)
|
|
return nil
|
|
case decision.FieldIPSize:
|
|
v, ok := value.(int64)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.AddIPSize(v)
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Decision numeric field %s", name)
|
|
}
|
|
|
|
// ClearedFields returns all nullable fields that were cleared during this
|
|
// mutation.
|
|
func (m *DecisionMutation) ClearedFields() []string {
|
|
var fields []string
|
|
if m.FieldCleared(decision.FieldCreatedAt) {
|
|
fields = append(fields, decision.FieldCreatedAt)
|
|
}
|
|
if m.FieldCleared(decision.FieldUpdatedAt) {
|
|
fields = append(fields, decision.FieldUpdatedAt)
|
|
}
|
|
if m.FieldCleared(decision.FieldUntil) {
|
|
fields = append(fields, decision.FieldUntil)
|
|
}
|
|
if m.FieldCleared(decision.FieldStartIP) {
|
|
fields = append(fields, decision.FieldStartIP)
|
|
}
|
|
if m.FieldCleared(decision.FieldEndIP) {
|
|
fields = append(fields, decision.FieldEndIP)
|
|
}
|
|
if m.FieldCleared(decision.FieldStartSuffix) {
|
|
fields = append(fields, decision.FieldStartSuffix)
|
|
}
|
|
if m.FieldCleared(decision.FieldEndSuffix) {
|
|
fields = append(fields, decision.FieldEndSuffix)
|
|
}
|
|
if m.FieldCleared(decision.FieldIPSize) {
|
|
fields = append(fields, decision.FieldIPSize)
|
|
}
|
|
if m.FieldCleared(decision.FieldUUID) {
|
|
fields = append(fields, decision.FieldUUID)
|
|
}
|
|
if m.FieldCleared(decision.FieldAlertDecisions) {
|
|
fields = append(fields, decision.FieldAlertDecisions)
|
|
}
|
|
return fields
|
|
}
|
|
|
|
// FieldCleared returns a boolean indicating if a field with the given name was
|
|
// cleared in this mutation.
|
|
func (m *DecisionMutation) FieldCleared(name string) bool {
|
|
_, ok := m.clearedFields[name]
|
|
return ok
|
|
}
|
|
|
|
// ClearField clears the value of the field with the given name. It returns an
|
|
// error if the field is not defined in the schema.
|
|
func (m *DecisionMutation) ClearField(name string) error {
|
|
switch name {
|
|
case decision.FieldCreatedAt:
|
|
m.ClearCreatedAt()
|
|
return nil
|
|
case decision.FieldUpdatedAt:
|
|
m.ClearUpdatedAt()
|
|
return nil
|
|
case decision.FieldUntil:
|
|
m.ClearUntil()
|
|
return nil
|
|
case decision.FieldStartIP:
|
|
m.ClearStartIP()
|
|
return nil
|
|
case decision.FieldEndIP:
|
|
m.ClearEndIP()
|
|
return nil
|
|
case decision.FieldStartSuffix:
|
|
m.ClearStartSuffix()
|
|
return nil
|
|
case decision.FieldEndSuffix:
|
|
m.ClearEndSuffix()
|
|
return nil
|
|
case decision.FieldIPSize:
|
|
m.ClearIPSize()
|
|
return nil
|
|
case decision.FieldUUID:
|
|
m.ClearUUID()
|
|
return nil
|
|
case decision.FieldAlertDecisions:
|
|
m.ClearAlertDecisions()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Decision nullable field %s", name)
|
|
}
|
|
|
|
// ResetField resets all changes in the mutation for the field with the given name.
|
|
// It returns an error if the field is not defined in the schema.
|
|
func (m *DecisionMutation) ResetField(name string) error {
|
|
switch name {
|
|
case decision.FieldCreatedAt:
|
|
m.ResetCreatedAt()
|
|
return nil
|
|
case decision.FieldUpdatedAt:
|
|
m.ResetUpdatedAt()
|
|
return nil
|
|
case decision.FieldUntil:
|
|
m.ResetUntil()
|
|
return nil
|
|
case decision.FieldScenario:
|
|
m.ResetScenario()
|
|
return nil
|
|
case decision.FieldType:
|
|
m.ResetType()
|
|
return nil
|
|
case decision.FieldStartIP:
|
|
m.ResetStartIP()
|
|
return nil
|
|
case decision.FieldEndIP:
|
|
m.ResetEndIP()
|
|
return nil
|
|
case decision.FieldStartSuffix:
|
|
m.ResetStartSuffix()
|
|
return nil
|
|
case decision.FieldEndSuffix:
|
|
m.ResetEndSuffix()
|
|
return nil
|
|
case decision.FieldIPSize:
|
|
m.ResetIPSize()
|
|
return nil
|
|
case decision.FieldScope:
|
|
m.ResetScope()
|
|
return nil
|
|
case decision.FieldValue:
|
|
m.ResetValue()
|
|
return nil
|
|
case decision.FieldOrigin:
|
|
m.ResetOrigin()
|
|
return nil
|
|
case decision.FieldSimulated:
|
|
m.ResetSimulated()
|
|
return nil
|
|
case decision.FieldUUID:
|
|
m.ResetUUID()
|
|
return nil
|
|
case decision.FieldAlertDecisions:
|
|
m.ResetAlertDecisions()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Decision field %s", name)
|
|
}
|
|
|
|
// AddedEdges returns all edge names that were set/added in this mutation.
|
|
func (m *DecisionMutation) AddedEdges() []string {
|
|
edges := make([]string, 0, 1)
|
|
if m.owner != nil {
|
|
edges = append(edges, decision.EdgeOwner)
|
|
}
|
|
return edges
|
|
}
|
|
|
|
// AddedIDs returns all IDs (to other nodes) that were added for the given edge
|
|
// name in this mutation.
|
|
func (m *DecisionMutation) AddedIDs(name string) []ent.Value {
|
|
switch name {
|
|
case decision.EdgeOwner:
|
|
if id := m.owner; id != nil {
|
|
return []ent.Value{*id}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// RemovedEdges returns all edge names that were removed in this mutation.
|
|
func (m *DecisionMutation) RemovedEdges() []string {
|
|
edges := make([]string, 0, 1)
|
|
return edges
|
|
}
|
|
|
|
// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
|
|
// the given name in this mutation.
|
|
func (m *DecisionMutation) RemovedIDs(name string) []ent.Value {
|
|
return nil
|
|
}
|
|
|
|
// ClearedEdges returns all edge names that were cleared in this mutation.
|
|
func (m *DecisionMutation) ClearedEdges() []string {
|
|
edges := make([]string, 0, 1)
|
|
if m.clearedowner {
|
|
edges = append(edges, decision.EdgeOwner)
|
|
}
|
|
return edges
|
|
}
|
|
|
|
// EdgeCleared returns a boolean which indicates if the edge with the given name
|
|
// was cleared in this mutation.
|
|
func (m *DecisionMutation) EdgeCleared(name string) bool {
|
|
switch name {
|
|
case decision.EdgeOwner:
|
|
return m.clearedowner
|
|
}
|
|
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 *DecisionMutation) ClearEdge(name string) error {
|
|
switch name {
|
|
case decision.EdgeOwner:
|
|
m.ClearOwner()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Decision 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 *DecisionMutation) ResetEdge(name string) error {
|
|
switch name {
|
|
case decision.EdgeOwner:
|
|
m.ResetOwner()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Decision edge %s", name)
|
|
}
|
|
|
|
// EventMutation represents an operation that mutates the Event nodes in the graph.
|
|
type EventMutation struct {
|
|
config
|
|
op Op
|
|
typ string
|
|
id *int
|
|
created_at *time.Time
|
|
updated_at *time.Time
|
|
time *time.Time
|
|
serialized *string
|
|
clearedFields map[string]struct{}
|
|
owner *int
|
|
clearedowner bool
|
|
done bool
|
|
oldValue func(context.Context) (*Event, error)
|
|
predicates []predicate.Event
|
|
}
|
|
|
|
var _ ent.Mutation = (*EventMutation)(nil)
|
|
|
|
// eventOption allows management of the mutation configuration using functional options.
|
|
type eventOption func(*EventMutation)
|
|
|
|
// newEventMutation creates new mutation for the Event entity.
|
|
func newEventMutation(c config, op Op, opts ...eventOption) *EventMutation {
|
|
m := &EventMutation{
|
|
config: c,
|
|
op: op,
|
|
typ: TypeEvent,
|
|
clearedFields: make(map[string]struct{}),
|
|
}
|
|
for _, opt := range opts {
|
|
opt(m)
|
|
}
|
|
return m
|
|
}
|
|
|
|
// withEventID sets the ID field of the mutation.
|
|
func withEventID(id int) eventOption {
|
|
return func(m *EventMutation) {
|
|
var (
|
|
err error
|
|
once sync.Once
|
|
value *Event
|
|
)
|
|
m.oldValue = func(ctx context.Context) (*Event, error) {
|
|
once.Do(func() {
|
|
if m.done {
|
|
err = errors.New("querying old values post mutation is not allowed")
|
|
} else {
|
|
value, err = m.Client().Event.Get(ctx, id)
|
|
}
|
|
})
|
|
return value, err
|
|
}
|
|
m.id = &id
|
|
}
|
|
}
|
|
|
|
// withEvent sets the old Event of the mutation.
|
|
func withEvent(node *Event) eventOption {
|
|
return func(m *EventMutation) {
|
|
m.oldValue = func(context.Context) (*Event, error) {
|
|
return node, nil
|
|
}
|
|
m.id = &node.ID
|
|
}
|
|
}
|
|
|
|
// Client returns a new `ent.Client` from the mutation. If the mutation was
|
|
// executed in a transaction (ent.Tx), a transactional client is returned.
|
|
func (m EventMutation) Client() *Client {
|
|
client := &Client{config: m.config}
|
|
client.init()
|
|
return client
|
|
}
|
|
|
|
// Tx returns an `ent.Tx` for mutations that were executed in transactions;
|
|
// it returns an error otherwise.
|
|
func (m EventMutation) Tx() (*Tx, error) {
|
|
if _, ok := m.driver.(*txDriver); !ok {
|
|
return nil, errors.New("ent: mutation is not running in a transaction")
|
|
}
|
|
tx := &Tx{config: m.config}
|
|
tx.init()
|
|
return tx, nil
|
|
}
|
|
|
|
// ID returns the ID value in the mutation. Note that the ID is only available
|
|
// if it was provided to the builder or after it was returned from the database.
|
|
func (m *EventMutation) ID() (id int, exists bool) {
|
|
if m.id == nil {
|
|
return
|
|
}
|
|
return *m.id, true
|
|
}
|
|
|
|
// IDs queries the database and returns the entity ids that match the mutation's predicate.
|
|
// That means, if the mutation is applied within a transaction with an isolation level such
|
|
// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
|
|
// or updated by the mutation.
|
|
func (m *EventMutation) IDs(ctx context.Context) ([]int, error) {
|
|
switch {
|
|
case m.op.Is(OpUpdateOne | OpDeleteOne):
|
|
id, exists := m.ID()
|
|
if exists {
|
|
return []int{id}, nil
|
|
}
|
|
fallthrough
|
|
case m.op.Is(OpUpdate | OpDelete):
|
|
return m.Client().Event.Query().Where(m.predicates...).IDs(ctx)
|
|
default:
|
|
return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
|
|
}
|
|
}
|
|
|
|
// SetCreatedAt sets the "created_at" field.
|
|
func (m *EventMutation) SetCreatedAt(t time.Time) {
|
|
m.created_at = &t
|
|
}
|
|
|
|
// CreatedAt returns the value of the "created_at" field in the mutation.
|
|
func (m *EventMutation) CreatedAt() (r time.Time, exists bool) {
|
|
v := m.created_at
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldCreatedAt returns the old "created_at" field's value of the Event entity.
|
|
// If the Event object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *EventMutation) OldCreatedAt(ctx context.Context) (v *time.Time, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldCreatedAt requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldCreatedAt: %w", err)
|
|
}
|
|
return oldValue.CreatedAt, nil
|
|
}
|
|
|
|
// ClearCreatedAt clears the value of the "created_at" field.
|
|
func (m *EventMutation) ClearCreatedAt() {
|
|
m.created_at = nil
|
|
m.clearedFields[event.FieldCreatedAt] = struct{}{}
|
|
}
|
|
|
|
// CreatedAtCleared returns if the "created_at" field was cleared in this mutation.
|
|
func (m *EventMutation) CreatedAtCleared() bool {
|
|
_, ok := m.clearedFields[event.FieldCreatedAt]
|
|
return ok
|
|
}
|
|
|
|
// ResetCreatedAt resets all changes to the "created_at" field.
|
|
func (m *EventMutation) ResetCreatedAt() {
|
|
m.created_at = nil
|
|
delete(m.clearedFields, event.FieldCreatedAt)
|
|
}
|
|
|
|
// SetUpdatedAt sets the "updated_at" field.
|
|
func (m *EventMutation) SetUpdatedAt(t time.Time) {
|
|
m.updated_at = &t
|
|
}
|
|
|
|
// UpdatedAt returns the value of the "updated_at" field in the mutation.
|
|
func (m *EventMutation) UpdatedAt() (r time.Time, exists bool) {
|
|
v := m.updated_at
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldUpdatedAt returns the old "updated_at" field's value of the Event entity.
|
|
// If the Event object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *EventMutation) OldUpdatedAt(ctx context.Context) (v *time.Time, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldUpdatedAt requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldUpdatedAt: %w", err)
|
|
}
|
|
return oldValue.UpdatedAt, nil
|
|
}
|
|
|
|
// ClearUpdatedAt clears the value of the "updated_at" field.
|
|
func (m *EventMutation) ClearUpdatedAt() {
|
|
m.updated_at = nil
|
|
m.clearedFields[event.FieldUpdatedAt] = struct{}{}
|
|
}
|
|
|
|
// UpdatedAtCleared returns if the "updated_at" field was cleared in this mutation.
|
|
func (m *EventMutation) UpdatedAtCleared() bool {
|
|
_, ok := m.clearedFields[event.FieldUpdatedAt]
|
|
return ok
|
|
}
|
|
|
|
// ResetUpdatedAt resets all changes to the "updated_at" field.
|
|
func (m *EventMutation) ResetUpdatedAt() {
|
|
m.updated_at = nil
|
|
delete(m.clearedFields, event.FieldUpdatedAt)
|
|
}
|
|
|
|
// SetTime sets the "time" field.
|
|
func (m *EventMutation) SetTime(t time.Time) {
|
|
m.time = &t
|
|
}
|
|
|
|
// Time returns the value of the "time" field in the mutation.
|
|
func (m *EventMutation) Time() (r time.Time, exists bool) {
|
|
v := m.time
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldTime returns the old "time" field's value of the Event entity.
|
|
// If the Event object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *EventMutation) OldTime(ctx context.Context) (v time.Time, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldTime is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldTime requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldTime: %w", err)
|
|
}
|
|
return oldValue.Time, nil
|
|
}
|
|
|
|
// ResetTime resets all changes to the "time" field.
|
|
func (m *EventMutation) ResetTime() {
|
|
m.time = nil
|
|
}
|
|
|
|
// SetSerialized sets the "serialized" field.
|
|
func (m *EventMutation) SetSerialized(s string) {
|
|
m.serialized = &s
|
|
}
|
|
|
|
// Serialized returns the value of the "serialized" field in the mutation.
|
|
func (m *EventMutation) Serialized() (r string, exists bool) {
|
|
v := m.serialized
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldSerialized returns the old "serialized" field's value of the Event entity.
|
|
// If the Event object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *EventMutation) OldSerialized(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldSerialized is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldSerialized requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldSerialized: %w", err)
|
|
}
|
|
return oldValue.Serialized, nil
|
|
}
|
|
|
|
// ResetSerialized resets all changes to the "serialized" field.
|
|
func (m *EventMutation) ResetSerialized() {
|
|
m.serialized = nil
|
|
}
|
|
|
|
// SetAlertEvents sets the "alert_events" field.
|
|
func (m *EventMutation) SetAlertEvents(i int) {
|
|
m.owner = &i
|
|
}
|
|
|
|
// AlertEvents returns the value of the "alert_events" field in the mutation.
|
|
func (m *EventMutation) AlertEvents() (r int, exists bool) {
|
|
v := m.owner
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldAlertEvents returns the old "alert_events" field's value of the Event entity.
|
|
// If the Event object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *EventMutation) OldAlertEvents(ctx context.Context) (v int, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldAlertEvents is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldAlertEvents requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldAlertEvents: %w", err)
|
|
}
|
|
return oldValue.AlertEvents, nil
|
|
}
|
|
|
|
// ClearAlertEvents clears the value of the "alert_events" field.
|
|
func (m *EventMutation) ClearAlertEvents() {
|
|
m.owner = nil
|
|
m.clearedFields[event.FieldAlertEvents] = struct{}{}
|
|
}
|
|
|
|
// AlertEventsCleared returns if the "alert_events" field was cleared in this mutation.
|
|
func (m *EventMutation) AlertEventsCleared() bool {
|
|
_, ok := m.clearedFields[event.FieldAlertEvents]
|
|
return ok
|
|
}
|
|
|
|
// ResetAlertEvents resets all changes to the "alert_events" field.
|
|
func (m *EventMutation) ResetAlertEvents() {
|
|
m.owner = nil
|
|
delete(m.clearedFields, event.FieldAlertEvents)
|
|
}
|
|
|
|
// SetOwnerID sets the "owner" edge to the Alert entity by id.
|
|
func (m *EventMutation) SetOwnerID(id int) {
|
|
m.owner = &id
|
|
}
|
|
|
|
// ClearOwner clears the "owner" edge to the Alert entity.
|
|
func (m *EventMutation) ClearOwner() {
|
|
m.clearedowner = true
|
|
m.clearedFields[event.FieldAlertEvents] = struct{}{}
|
|
}
|
|
|
|
// OwnerCleared reports if the "owner" edge to the Alert entity was cleared.
|
|
func (m *EventMutation) OwnerCleared() bool {
|
|
return m.AlertEventsCleared() || m.clearedowner
|
|
}
|
|
|
|
// OwnerID returns the "owner" edge ID in the mutation.
|
|
func (m *EventMutation) OwnerID() (id int, exists bool) {
|
|
if m.owner != nil {
|
|
return *m.owner, true
|
|
}
|
|
return
|
|
}
|
|
|
|
// OwnerIDs returns the "owner" edge IDs in the mutation.
|
|
// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use
|
|
// OwnerID instead. It exists only for internal usage by the builders.
|
|
func (m *EventMutation) OwnerIDs() (ids []int) {
|
|
if id := m.owner; id != nil {
|
|
ids = append(ids, *id)
|
|
}
|
|
return
|
|
}
|
|
|
|
// ResetOwner resets all changes to the "owner" edge.
|
|
func (m *EventMutation) ResetOwner() {
|
|
m.owner = nil
|
|
m.clearedowner = false
|
|
}
|
|
|
|
// Where appends a list predicates to the EventMutation builder.
|
|
func (m *EventMutation) Where(ps ...predicate.Event) {
|
|
m.predicates = append(m.predicates, ps...)
|
|
}
|
|
|
|
// WhereP appends storage-level predicates to the EventMutation builder. Using this method,
|
|
// users can use type-assertion to append predicates that do not depend on any generated package.
|
|
func (m *EventMutation) WhereP(ps ...func(*sql.Selector)) {
|
|
p := make([]predicate.Event, len(ps))
|
|
for i := range ps {
|
|
p[i] = ps[i]
|
|
}
|
|
m.Where(p...)
|
|
}
|
|
|
|
// Op returns the operation name.
|
|
func (m *EventMutation) Op() Op {
|
|
return m.op
|
|
}
|
|
|
|
// SetOp allows setting the mutation operation.
|
|
func (m *EventMutation) SetOp(op Op) {
|
|
m.op = op
|
|
}
|
|
|
|
// Type returns the node type of this mutation (Event).
|
|
func (m *EventMutation) Type() string {
|
|
return m.typ
|
|
}
|
|
|
|
// Fields returns all fields that were changed during this mutation. Note that in
|
|
// order to get all numeric fields that were incremented/decremented, call
|
|
// AddedFields().
|
|
func (m *EventMutation) Fields() []string {
|
|
fields := make([]string, 0, 5)
|
|
if m.created_at != nil {
|
|
fields = append(fields, event.FieldCreatedAt)
|
|
}
|
|
if m.updated_at != nil {
|
|
fields = append(fields, event.FieldUpdatedAt)
|
|
}
|
|
if m.time != nil {
|
|
fields = append(fields, event.FieldTime)
|
|
}
|
|
if m.serialized != nil {
|
|
fields = append(fields, event.FieldSerialized)
|
|
}
|
|
if m.owner != nil {
|
|
fields = append(fields, event.FieldAlertEvents)
|
|
}
|
|
return fields
|
|
}
|
|
|
|
// Field returns the value of a field with the given name. The second boolean
|
|
// return value indicates that this field was not set, or was not defined in the
|
|
// schema.
|
|
func (m *EventMutation) Field(name string) (ent.Value, bool) {
|
|
switch name {
|
|
case event.FieldCreatedAt:
|
|
return m.CreatedAt()
|
|
case event.FieldUpdatedAt:
|
|
return m.UpdatedAt()
|
|
case event.FieldTime:
|
|
return m.Time()
|
|
case event.FieldSerialized:
|
|
return m.Serialized()
|
|
case event.FieldAlertEvents:
|
|
return m.AlertEvents()
|
|
}
|
|
return nil, false
|
|
}
|
|
|
|
// OldField returns the old value of the field from the database. An error is
|
|
// returned if the mutation operation is not UpdateOne, or the query to the
|
|
// database failed.
|
|
func (m *EventMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
|
|
switch name {
|
|
case event.FieldCreatedAt:
|
|
return m.OldCreatedAt(ctx)
|
|
case event.FieldUpdatedAt:
|
|
return m.OldUpdatedAt(ctx)
|
|
case event.FieldTime:
|
|
return m.OldTime(ctx)
|
|
case event.FieldSerialized:
|
|
return m.OldSerialized(ctx)
|
|
case event.FieldAlertEvents:
|
|
return m.OldAlertEvents(ctx)
|
|
}
|
|
return nil, fmt.Errorf("unknown Event field %s", name)
|
|
}
|
|
|
|
// SetField sets the value of a field with the given name. It returns an error if
|
|
// the field is not defined in the schema, or if the type mismatched the field
|
|
// type.
|
|
func (m *EventMutation) SetField(name string, value ent.Value) error {
|
|
switch name {
|
|
case event.FieldCreatedAt:
|
|
v, ok := value.(time.Time)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetCreatedAt(v)
|
|
return nil
|
|
case event.FieldUpdatedAt:
|
|
v, ok := value.(time.Time)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetUpdatedAt(v)
|
|
return nil
|
|
case event.FieldTime:
|
|
v, ok := value.(time.Time)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetTime(v)
|
|
return nil
|
|
case event.FieldSerialized:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetSerialized(v)
|
|
return nil
|
|
case event.FieldAlertEvents:
|
|
v, ok := value.(int)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetAlertEvents(v)
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Event field %s", name)
|
|
}
|
|
|
|
// AddedFields returns all numeric fields that were incremented/decremented during
|
|
// this mutation.
|
|
func (m *EventMutation) AddedFields() []string {
|
|
var fields []string
|
|
return fields
|
|
}
|
|
|
|
// AddedField returns the numeric value that was incremented/decremented on a field
|
|
// with the given name. The second boolean return value indicates that this field
|
|
// was not set, or was not defined in the schema.
|
|
func (m *EventMutation) AddedField(name string) (ent.Value, bool) {
|
|
switch name {
|
|
}
|
|
return nil, false
|
|
}
|
|
|
|
// AddField adds the value to the field with the given name. It returns an error if
|
|
// the field is not defined in the schema, or if the type mismatched the field
|
|
// type.
|
|
func (m *EventMutation) AddField(name string, value ent.Value) error {
|
|
switch name {
|
|
}
|
|
return fmt.Errorf("unknown Event numeric field %s", name)
|
|
}
|
|
|
|
// ClearedFields returns all nullable fields that were cleared during this
|
|
// mutation.
|
|
func (m *EventMutation) ClearedFields() []string {
|
|
var fields []string
|
|
if m.FieldCleared(event.FieldCreatedAt) {
|
|
fields = append(fields, event.FieldCreatedAt)
|
|
}
|
|
if m.FieldCleared(event.FieldUpdatedAt) {
|
|
fields = append(fields, event.FieldUpdatedAt)
|
|
}
|
|
if m.FieldCleared(event.FieldAlertEvents) {
|
|
fields = append(fields, event.FieldAlertEvents)
|
|
}
|
|
return fields
|
|
}
|
|
|
|
// FieldCleared returns a boolean indicating if a field with the given name was
|
|
// cleared in this mutation.
|
|
func (m *EventMutation) FieldCleared(name string) bool {
|
|
_, ok := m.clearedFields[name]
|
|
return ok
|
|
}
|
|
|
|
// ClearField clears the value of the field with the given name. It returns an
|
|
// error if the field is not defined in the schema.
|
|
func (m *EventMutation) ClearField(name string) error {
|
|
switch name {
|
|
case event.FieldCreatedAt:
|
|
m.ClearCreatedAt()
|
|
return nil
|
|
case event.FieldUpdatedAt:
|
|
m.ClearUpdatedAt()
|
|
return nil
|
|
case event.FieldAlertEvents:
|
|
m.ClearAlertEvents()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Event nullable field %s", name)
|
|
}
|
|
|
|
// ResetField resets all changes in the mutation for the field with the given name.
|
|
// It returns an error if the field is not defined in the schema.
|
|
func (m *EventMutation) ResetField(name string) error {
|
|
switch name {
|
|
case event.FieldCreatedAt:
|
|
m.ResetCreatedAt()
|
|
return nil
|
|
case event.FieldUpdatedAt:
|
|
m.ResetUpdatedAt()
|
|
return nil
|
|
case event.FieldTime:
|
|
m.ResetTime()
|
|
return nil
|
|
case event.FieldSerialized:
|
|
m.ResetSerialized()
|
|
return nil
|
|
case event.FieldAlertEvents:
|
|
m.ResetAlertEvents()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Event field %s", name)
|
|
}
|
|
|
|
// AddedEdges returns all edge names that were set/added in this mutation.
|
|
func (m *EventMutation) AddedEdges() []string {
|
|
edges := make([]string, 0, 1)
|
|
if m.owner != nil {
|
|
edges = append(edges, event.EdgeOwner)
|
|
}
|
|
return edges
|
|
}
|
|
|
|
// AddedIDs returns all IDs (to other nodes) that were added for the given edge
|
|
// name in this mutation.
|
|
func (m *EventMutation) AddedIDs(name string) []ent.Value {
|
|
switch name {
|
|
case event.EdgeOwner:
|
|
if id := m.owner; id != nil {
|
|
return []ent.Value{*id}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// RemovedEdges returns all edge names that were removed in this mutation.
|
|
func (m *EventMutation) RemovedEdges() []string {
|
|
edges := make([]string, 0, 1)
|
|
return edges
|
|
}
|
|
|
|
// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
|
|
// the given name in this mutation.
|
|
func (m *EventMutation) RemovedIDs(name string) []ent.Value {
|
|
return nil
|
|
}
|
|
|
|
// ClearedEdges returns all edge names that were cleared in this mutation.
|
|
func (m *EventMutation) ClearedEdges() []string {
|
|
edges := make([]string, 0, 1)
|
|
if m.clearedowner {
|
|
edges = append(edges, event.EdgeOwner)
|
|
}
|
|
return edges
|
|
}
|
|
|
|
// EdgeCleared returns a boolean which indicates if the edge with the given name
|
|
// was cleared in this mutation.
|
|
func (m *EventMutation) EdgeCleared(name string) bool {
|
|
switch name {
|
|
case event.EdgeOwner:
|
|
return m.clearedowner
|
|
}
|
|
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 *EventMutation) ClearEdge(name string) error {
|
|
switch name {
|
|
case event.EdgeOwner:
|
|
m.ClearOwner()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Event 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 *EventMutation) ResetEdge(name string) error {
|
|
switch name {
|
|
case event.EdgeOwner:
|
|
m.ResetOwner()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Event edge %s", name)
|
|
}
|
|
|
|
// LockMutation represents an operation that mutates the Lock nodes in the graph.
|
|
type LockMutation struct {
|
|
config
|
|
op Op
|
|
typ string
|
|
id *int
|
|
name *string
|
|
created_at *time.Time
|
|
clearedFields map[string]struct{}
|
|
done bool
|
|
oldValue func(context.Context) (*Lock, error)
|
|
predicates []predicate.Lock
|
|
}
|
|
|
|
var _ ent.Mutation = (*LockMutation)(nil)
|
|
|
|
// lockOption allows management of the mutation configuration using functional options.
|
|
type lockOption func(*LockMutation)
|
|
|
|
// newLockMutation creates new mutation for the Lock entity.
|
|
func newLockMutation(c config, op Op, opts ...lockOption) *LockMutation {
|
|
m := &LockMutation{
|
|
config: c,
|
|
op: op,
|
|
typ: TypeLock,
|
|
clearedFields: make(map[string]struct{}),
|
|
}
|
|
for _, opt := range opts {
|
|
opt(m)
|
|
}
|
|
return m
|
|
}
|
|
|
|
// withLockID sets the ID field of the mutation.
|
|
func withLockID(id int) lockOption {
|
|
return func(m *LockMutation) {
|
|
var (
|
|
err error
|
|
once sync.Once
|
|
value *Lock
|
|
)
|
|
m.oldValue = func(ctx context.Context) (*Lock, error) {
|
|
once.Do(func() {
|
|
if m.done {
|
|
err = errors.New("querying old values post mutation is not allowed")
|
|
} else {
|
|
value, err = m.Client().Lock.Get(ctx, id)
|
|
}
|
|
})
|
|
return value, err
|
|
}
|
|
m.id = &id
|
|
}
|
|
}
|
|
|
|
// withLock sets the old Lock of the mutation.
|
|
func withLock(node *Lock) lockOption {
|
|
return func(m *LockMutation) {
|
|
m.oldValue = func(context.Context) (*Lock, error) {
|
|
return node, nil
|
|
}
|
|
m.id = &node.ID
|
|
}
|
|
}
|
|
|
|
// Client returns a new `ent.Client` from the mutation. If the mutation was
|
|
// executed in a transaction (ent.Tx), a transactional client is returned.
|
|
func (m LockMutation) Client() *Client {
|
|
client := &Client{config: m.config}
|
|
client.init()
|
|
return client
|
|
}
|
|
|
|
// Tx returns an `ent.Tx` for mutations that were executed in transactions;
|
|
// it returns an error otherwise.
|
|
func (m LockMutation) Tx() (*Tx, error) {
|
|
if _, ok := m.driver.(*txDriver); !ok {
|
|
return nil, errors.New("ent: mutation is not running in a transaction")
|
|
}
|
|
tx := &Tx{config: m.config}
|
|
tx.init()
|
|
return tx, nil
|
|
}
|
|
|
|
// ID returns the ID value in the mutation. Note that the ID is only available
|
|
// if it was provided to the builder or after it was returned from the database.
|
|
func (m *LockMutation) ID() (id int, exists bool) {
|
|
if m.id == nil {
|
|
return
|
|
}
|
|
return *m.id, true
|
|
}
|
|
|
|
// IDs queries the database and returns the entity ids that match the mutation's predicate.
|
|
// That means, if the mutation is applied within a transaction with an isolation level such
|
|
// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
|
|
// or updated by the mutation.
|
|
func (m *LockMutation) IDs(ctx context.Context) ([]int, error) {
|
|
switch {
|
|
case m.op.Is(OpUpdateOne | OpDeleteOne):
|
|
id, exists := m.ID()
|
|
if exists {
|
|
return []int{id}, nil
|
|
}
|
|
fallthrough
|
|
case m.op.Is(OpUpdate | OpDelete):
|
|
return m.Client().Lock.Query().Where(m.predicates...).IDs(ctx)
|
|
default:
|
|
return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
|
|
}
|
|
}
|
|
|
|
// SetName sets the "name" field.
|
|
func (m *LockMutation) SetName(s string) {
|
|
m.name = &s
|
|
}
|
|
|
|
// Name returns the value of the "name" field in the mutation.
|
|
func (m *LockMutation) Name() (r string, exists bool) {
|
|
v := m.name
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldName returns the old "name" field's value of the Lock entity.
|
|
// If the Lock object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *LockMutation) OldName(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldName is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldName requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldName: %w", err)
|
|
}
|
|
return oldValue.Name, nil
|
|
}
|
|
|
|
// ResetName resets all changes to the "name" field.
|
|
func (m *LockMutation) ResetName() {
|
|
m.name = nil
|
|
}
|
|
|
|
// SetCreatedAt sets the "created_at" field.
|
|
func (m *LockMutation) SetCreatedAt(t time.Time) {
|
|
m.created_at = &t
|
|
}
|
|
|
|
// CreatedAt returns the value of the "created_at" field in the mutation.
|
|
func (m *LockMutation) CreatedAt() (r time.Time, exists bool) {
|
|
v := m.created_at
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldCreatedAt returns the old "created_at" field's value of the Lock entity.
|
|
// If the Lock object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *LockMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldCreatedAt requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldCreatedAt: %w", err)
|
|
}
|
|
return oldValue.CreatedAt, nil
|
|
}
|
|
|
|
// ResetCreatedAt resets all changes to the "created_at" field.
|
|
func (m *LockMutation) ResetCreatedAt() {
|
|
m.created_at = nil
|
|
}
|
|
|
|
// Where appends a list predicates to the LockMutation builder.
|
|
func (m *LockMutation) Where(ps ...predicate.Lock) {
|
|
m.predicates = append(m.predicates, ps...)
|
|
}
|
|
|
|
// WhereP appends storage-level predicates to the LockMutation builder. Using this method,
|
|
// users can use type-assertion to append predicates that do not depend on any generated package.
|
|
func (m *LockMutation) WhereP(ps ...func(*sql.Selector)) {
|
|
p := make([]predicate.Lock, len(ps))
|
|
for i := range ps {
|
|
p[i] = ps[i]
|
|
}
|
|
m.Where(p...)
|
|
}
|
|
|
|
// Op returns the operation name.
|
|
func (m *LockMutation) Op() Op {
|
|
return m.op
|
|
}
|
|
|
|
// SetOp allows setting the mutation operation.
|
|
func (m *LockMutation) SetOp(op Op) {
|
|
m.op = op
|
|
}
|
|
|
|
// Type returns the node type of this mutation (Lock).
|
|
func (m *LockMutation) Type() string {
|
|
return m.typ
|
|
}
|
|
|
|
// Fields returns all fields that were changed during this mutation. Note that in
|
|
// order to get all numeric fields that were incremented/decremented, call
|
|
// AddedFields().
|
|
func (m *LockMutation) Fields() []string {
|
|
fields := make([]string, 0, 2)
|
|
if m.name != nil {
|
|
fields = append(fields, lock.FieldName)
|
|
}
|
|
if m.created_at != nil {
|
|
fields = append(fields, lock.FieldCreatedAt)
|
|
}
|
|
return fields
|
|
}
|
|
|
|
// Field returns the value of a field with the given name. The second boolean
|
|
// return value indicates that this field was not set, or was not defined in the
|
|
// schema.
|
|
func (m *LockMutation) Field(name string) (ent.Value, bool) {
|
|
switch name {
|
|
case lock.FieldName:
|
|
return m.Name()
|
|
case lock.FieldCreatedAt:
|
|
return m.CreatedAt()
|
|
}
|
|
return nil, false
|
|
}
|
|
|
|
// OldField returns the old value of the field from the database. An error is
|
|
// returned if the mutation operation is not UpdateOne, or the query to the
|
|
// database failed.
|
|
func (m *LockMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
|
|
switch name {
|
|
case lock.FieldName:
|
|
return m.OldName(ctx)
|
|
case lock.FieldCreatedAt:
|
|
return m.OldCreatedAt(ctx)
|
|
}
|
|
return nil, fmt.Errorf("unknown Lock field %s", name)
|
|
}
|
|
|
|
// SetField sets the value of a field with the given name. It returns an error if
|
|
// the field is not defined in the schema, or if the type mismatched the field
|
|
// type.
|
|
func (m *LockMutation) SetField(name string, value ent.Value) error {
|
|
switch name {
|
|
case lock.FieldName:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetName(v)
|
|
return nil
|
|
case lock.FieldCreatedAt:
|
|
v, ok := value.(time.Time)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetCreatedAt(v)
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Lock field %s", name)
|
|
}
|
|
|
|
// AddedFields returns all numeric fields that were incremented/decremented during
|
|
// this mutation.
|
|
func (m *LockMutation) AddedFields() []string {
|
|
return nil
|
|
}
|
|
|
|
// AddedField returns the numeric value that was incremented/decremented on a field
|
|
// with the given name. The second boolean return value indicates that this field
|
|
// was not set, or was not defined in the schema.
|
|
func (m *LockMutation) AddedField(name string) (ent.Value, bool) {
|
|
return nil, false
|
|
}
|
|
|
|
// AddField adds the value to the field with the given name. It returns an error if
|
|
// the field is not defined in the schema, or if the type mismatched the field
|
|
// type.
|
|
func (m *LockMutation) AddField(name string, value ent.Value) error {
|
|
switch name {
|
|
}
|
|
return fmt.Errorf("unknown Lock numeric field %s", name)
|
|
}
|
|
|
|
// ClearedFields returns all nullable fields that were cleared during this
|
|
// mutation.
|
|
func (m *LockMutation) ClearedFields() []string {
|
|
return nil
|
|
}
|
|
|
|
// FieldCleared returns a boolean indicating if a field with the given name was
|
|
// cleared in this mutation.
|
|
func (m *LockMutation) FieldCleared(name string) bool {
|
|
_, ok := m.clearedFields[name]
|
|
return ok
|
|
}
|
|
|
|
// ClearField clears the value of the field with the given name. It returns an
|
|
// error if the field is not defined in the schema.
|
|
func (m *LockMutation) ClearField(name string) error {
|
|
return fmt.Errorf("unknown Lock nullable field %s", name)
|
|
}
|
|
|
|
// ResetField resets all changes in the mutation for the field with the given name.
|
|
// It returns an error if the field is not defined in the schema.
|
|
func (m *LockMutation) ResetField(name string) error {
|
|
switch name {
|
|
case lock.FieldName:
|
|
m.ResetName()
|
|
return nil
|
|
case lock.FieldCreatedAt:
|
|
m.ResetCreatedAt()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Lock field %s", name)
|
|
}
|
|
|
|
// AddedEdges returns all edge names that were set/added in this mutation.
|
|
func (m *LockMutation) AddedEdges() []string {
|
|
edges := make([]string, 0, 0)
|
|
return edges
|
|
}
|
|
|
|
// AddedIDs returns all IDs (to other nodes) that were added for the given edge
|
|
// name in this mutation.
|
|
func (m *LockMutation) AddedIDs(name string) []ent.Value {
|
|
return nil
|
|
}
|
|
|
|
// RemovedEdges returns all edge names that were removed in this mutation.
|
|
func (m *LockMutation) RemovedEdges() []string {
|
|
edges := make([]string, 0, 0)
|
|
return edges
|
|
}
|
|
|
|
// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
|
|
// the given name in this mutation.
|
|
func (m *LockMutation) RemovedIDs(name string) []ent.Value {
|
|
return nil
|
|
}
|
|
|
|
// ClearedEdges returns all edge names that were cleared in this mutation.
|
|
func (m *LockMutation) ClearedEdges() []string {
|
|
edges := make([]string, 0, 0)
|
|
return edges
|
|
}
|
|
|
|
// EdgeCleared returns a boolean which indicates if the edge with the given name
|
|
// was cleared in this mutation.
|
|
func (m *LockMutation) EdgeCleared(name string) bool {
|
|
return false
|
|
}
|
|
|
|
// ClearEdge clears the value of the edge with the given name. It returns an error
|
|
// if that edge is not defined in the schema.
|
|
func (m *LockMutation) ClearEdge(name string) error {
|
|
return fmt.Errorf("unknown Lock 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 *LockMutation) ResetEdge(name string) error {
|
|
return fmt.Errorf("unknown Lock edge %s", name)
|
|
}
|
|
|
|
// MachineMutation represents an operation that mutates the Machine nodes in the graph.
|
|
type MachineMutation struct {
|
|
config
|
|
op Op
|
|
typ string
|
|
id *int
|
|
created_at *time.Time
|
|
updated_at *time.Time
|
|
last_push *time.Time
|
|
last_heartbeat *time.Time
|
|
machineId *string
|
|
password *string
|
|
ipAddress *string
|
|
scenarios *string
|
|
version *string
|
|
isValidated *bool
|
|
status *string
|
|
auth_type *string
|
|
clearedFields map[string]struct{}
|
|
alerts map[int]struct{}
|
|
removedalerts map[int]struct{}
|
|
clearedalerts bool
|
|
done bool
|
|
oldValue func(context.Context) (*Machine, error)
|
|
predicates []predicate.Machine
|
|
}
|
|
|
|
var _ ent.Mutation = (*MachineMutation)(nil)
|
|
|
|
// machineOption allows management of the mutation configuration using functional options.
|
|
type machineOption func(*MachineMutation)
|
|
|
|
// newMachineMutation creates new mutation for the Machine entity.
|
|
func newMachineMutation(c config, op Op, opts ...machineOption) *MachineMutation {
|
|
m := &MachineMutation{
|
|
config: c,
|
|
op: op,
|
|
typ: TypeMachine,
|
|
clearedFields: make(map[string]struct{}),
|
|
}
|
|
for _, opt := range opts {
|
|
opt(m)
|
|
}
|
|
return m
|
|
}
|
|
|
|
// withMachineID sets the ID field of the mutation.
|
|
func withMachineID(id int) machineOption {
|
|
return func(m *MachineMutation) {
|
|
var (
|
|
err error
|
|
once sync.Once
|
|
value *Machine
|
|
)
|
|
m.oldValue = func(ctx context.Context) (*Machine, error) {
|
|
once.Do(func() {
|
|
if m.done {
|
|
err = errors.New("querying old values post mutation is not allowed")
|
|
} else {
|
|
value, err = m.Client().Machine.Get(ctx, id)
|
|
}
|
|
})
|
|
return value, err
|
|
}
|
|
m.id = &id
|
|
}
|
|
}
|
|
|
|
// withMachine sets the old Machine of the mutation.
|
|
func withMachine(node *Machine) machineOption {
|
|
return func(m *MachineMutation) {
|
|
m.oldValue = func(context.Context) (*Machine, error) {
|
|
return node, nil
|
|
}
|
|
m.id = &node.ID
|
|
}
|
|
}
|
|
|
|
// Client returns a new `ent.Client` from the mutation. If the mutation was
|
|
// executed in a transaction (ent.Tx), a transactional client is returned.
|
|
func (m MachineMutation) Client() *Client {
|
|
client := &Client{config: m.config}
|
|
client.init()
|
|
return client
|
|
}
|
|
|
|
// Tx returns an `ent.Tx` for mutations that were executed in transactions;
|
|
// it returns an error otherwise.
|
|
func (m MachineMutation) Tx() (*Tx, error) {
|
|
if _, ok := m.driver.(*txDriver); !ok {
|
|
return nil, errors.New("ent: mutation is not running in a transaction")
|
|
}
|
|
tx := &Tx{config: m.config}
|
|
tx.init()
|
|
return tx, nil
|
|
}
|
|
|
|
// ID returns the ID value in the mutation. Note that the ID is only available
|
|
// if it was provided to the builder or after it was returned from the database.
|
|
func (m *MachineMutation) ID() (id int, exists bool) {
|
|
if m.id == nil {
|
|
return
|
|
}
|
|
return *m.id, true
|
|
}
|
|
|
|
// IDs queries the database and returns the entity ids that match the mutation's predicate.
|
|
// That means, if the mutation is applied within a transaction with an isolation level such
|
|
// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
|
|
// or updated by the mutation.
|
|
func (m *MachineMutation) IDs(ctx context.Context) ([]int, error) {
|
|
switch {
|
|
case m.op.Is(OpUpdateOne | OpDeleteOne):
|
|
id, exists := m.ID()
|
|
if exists {
|
|
return []int{id}, nil
|
|
}
|
|
fallthrough
|
|
case m.op.Is(OpUpdate | OpDelete):
|
|
return m.Client().Machine.Query().Where(m.predicates...).IDs(ctx)
|
|
default:
|
|
return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
|
|
}
|
|
}
|
|
|
|
// SetCreatedAt sets the "created_at" field.
|
|
func (m *MachineMutation) SetCreatedAt(t time.Time) {
|
|
m.created_at = &t
|
|
}
|
|
|
|
// CreatedAt returns the value of the "created_at" field in the mutation.
|
|
func (m *MachineMutation) CreatedAt() (r time.Time, exists bool) {
|
|
v := m.created_at
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldCreatedAt returns the old "created_at" field's value of the Machine entity.
|
|
// If the Machine object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *MachineMutation) OldCreatedAt(ctx context.Context) (v *time.Time, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldCreatedAt requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldCreatedAt: %w", err)
|
|
}
|
|
return oldValue.CreatedAt, nil
|
|
}
|
|
|
|
// ClearCreatedAt clears the value of the "created_at" field.
|
|
func (m *MachineMutation) ClearCreatedAt() {
|
|
m.created_at = nil
|
|
m.clearedFields[machine.FieldCreatedAt] = struct{}{}
|
|
}
|
|
|
|
// CreatedAtCleared returns if the "created_at" field was cleared in this mutation.
|
|
func (m *MachineMutation) CreatedAtCleared() bool {
|
|
_, ok := m.clearedFields[machine.FieldCreatedAt]
|
|
return ok
|
|
}
|
|
|
|
// ResetCreatedAt resets all changes to the "created_at" field.
|
|
func (m *MachineMutation) ResetCreatedAt() {
|
|
m.created_at = nil
|
|
delete(m.clearedFields, machine.FieldCreatedAt)
|
|
}
|
|
|
|
// SetUpdatedAt sets the "updated_at" field.
|
|
func (m *MachineMutation) SetUpdatedAt(t time.Time) {
|
|
m.updated_at = &t
|
|
}
|
|
|
|
// UpdatedAt returns the value of the "updated_at" field in the mutation.
|
|
func (m *MachineMutation) UpdatedAt() (r time.Time, exists bool) {
|
|
v := m.updated_at
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldUpdatedAt returns the old "updated_at" field's value of the Machine entity.
|
|
// If the Machine object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *MachineMutation) OldUpdatedAt(ctx context.Context) (v *time.Time, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldUpdatedAt requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldUpdatedAt: %w", err)
|
|
}
|
|
return oldValue.UpdatedAt, nil
|
|
}
|
|
|
|
// ClearUpdatedAt clears the value of the "updated_at" field.
|
|
func (m *MachineMutation) ClearUpdatedAt() {
|
|
m.updated_at = nil
|
|
m.clearedFields[machine.FieldUpdatedAt] = struct{}{}
|
|
}
|
|
|
|
// UpdatedAtCleared returns if the "updated_at" field was cleared in this mutation.
|
|
func (m *MachineMutation) UpdatedAtCleared() bool {
|
|
_, ok := m.clearedFields[machine.FieldUpdatedAt]
|
|
return ok
|
|
}
|
|
|
|
// ResetUpdatedAt resets all changes to the "updated_at" field.
|
|
func (m *MachineMutation) ResetUpdatedAt() {
|
|
m.updated_at = nil
|
|
delete(m.clearedFields, machine.FieldUpdatedAt)
|
|
}
|
|
|
|
// SetLastPush sets the "last_push" field.
|
|
func (m *MachineMutation) SetLastPush(t time.Time) {
|
|
m.last_push = &t
|
|
}
|
|
|
|
// LastPush returns the value of the "last_push" field in the mutation.
|
|
func (m *MachineMutation) LastPush() (r time.Time, exists bool) {
|
|
v := m.last_push
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldLastPush returns the old "last_push" field's value of the Machine entity.
|
|
// If the Machine object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *MachineMutation) OldLastPush(ctx context.Context) (v *time.Time, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldLastPush is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldLastPush requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldLastPush: %w", err)
|
|
}
|
|
return oldValue.LastPush, nil
|
|
}
|
|
|
|
// ClearLastPush clears the value of the "last_push" field.
|
|
func (m *MachineMutation) ClearLastPush() {
|
|
m.last_push = nil
|
|
m.clearedFields[machine.FieldLastPush] = struct{}{}
|
|
}
|
|
|
|
// LastPushCleared returns if the "last_push" field was cleared in this mutation.
|
|
func (m *MachineMutation) LastPushCleared() bool {
|
|
_, ok := m.clearedFields[machine.FieldLastPush]
|
|
return ok
|
|
}
|
|
|
|
// ResetLastPush resets all changes to the "last_push" field.
|
|
func (m *MachineMutation) ResetLastPush() {
|
|
m.last_push = nil
|
|
delete(m.clearedFields, machine.FieldLastPush)
|
|
}
|
|
|
|
// SetLastHeartbeat sets the "last_heartbeat" field.
|
|
func (m *MachineMutation) SetLastHeartbeat(t time.Time) {
|
|
m.last_heartbeat = &t
|
|
}
|
|
|
|
// LastHeartbeat returns the value of the "last_heartbeat" field in the mutation.
|
|
func (m *MachineMutation) LastHeartbeat() (r time.Time, exists bool) {
|
|
v := m.last_heartbeat
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldLastHeartbeat returns the old "last_heartbeat" field's value of the Machine entity.
|
|
// If the Machine object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *MachineMutation) OldLastHeartbeat(ctx context.Context) (v *time.Time, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldLastHeartbeat is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldLastHeartbeat requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldLastHeartbeat: %w", err)
|
|
}
|
|
return oldValue.LastHeartbeat, nil
|
|
}
|
|
|
|
// ClearLastHeartbeat clears the value of the "last_heartbeat" field.
|
|
func (m *MachineMutation) ClearLastHeartbeat() {
|
|
m.last_heartbeat = nil
|
|
m.clearedFields[machine.FieldLastHeartbeat] = struct{}{}
|
|
}
|
|
|
|
// LastHeartbeatCleared returns if the "last_heartbeat" field was cleared in this mutation.
|
|
func (m *MachineMutation) LastHeartbeatCleared() bool {
|
|
_, ok := m.clearedFields[machine.FieldLastHeartbeat]
|
|
return ok
|
|
}
|
|
|
|
// ResetLastHeartbeat resets all changes to the "last_heartbeat" field.
|
|
func (m *MachineMutation) ResetLastHeartbeat() {
|
|
m.last_heartbeat = nil
|
|
delete(m.clearedFields, machine.FieldLastHeartbeat)
|
|
}
|
|
|
|
// SetMachineId sets the "machineId" field.
|
|
func (m *MachineMutation) SetMachineId(s string) {
|
|
m.machineId = &s
|
|
}
|
|
|
|
// MachineId returns the value of the "machineId" field in the mutation.
|
|
func (m *MachineMutation) MachineId() (r string, exists bool) {
|
|
v := m.machineId
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldMachineId returns the old "machineId" field's value of the Machine entity.
|
|
// If the Machine object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *MachineMutation) OldMachineId(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldMachineId is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldMachineId requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldMachineId: %w", err)
|
|
}
|
|
return oldValue.MachineId, nil
|
|
}
|
|
|
|
// ResetMachineId resets all changes to the "machineId" field.
|
|
func (m *MachineMutation) ResetMachineId() {
|
|
m.machineId = nil
|
|
}
|
|
|
|
// SetPassword sets the "password" field.
|
|
func (m *MachineMutation) SetPassword(s string) {
|
|
m.password = &s
|
|
}
|
|
|
|
// Password returns the value of the "password" field in the mutation.
|
|
func (m *MachineMutation) Password() (r string, exists bool) {
|
|
v := m.password
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldPassword returns the old "password" field's value of the Machine entity.
|
|
// If the Machine object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *MachineMutation) OldPassword(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldPassword is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldPassword requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldPassword: %w", err)
|
|
}
|
|
return oldValue.Password, nil
|
|
}
|
|
|
|
// ResetPassword resets all changes to the "password" field.
|
|
func (m *MachineMutation) ResetPassword() {
|
|
m.password = nil
|
|
}
|
|
|
|
// SetIpAddress sets the "ipAddress" field.
|
|
func (m *MachineMutation) SetIpAddress(s string) {
|
|
m.ipAddress = &s
|
|
}
|
|
|
|
// IpAddress returns the value of the "ipAddress" field in the mutation.
|
|
func (m *MachineMutation) IpAddress() (r string, exists bool) {
|
|
v := m.ipAddress
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldIpAddress returns the old "ipAddress" field's value of the Machine entity.
|
|
// If the Machine object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *MachineMutation) OldIpAddress(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldIpAddress is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldIpAddress requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldIpAddress: %w", err)
|
|
}
|
|
return oldValue.IpAddress, nil
|
|
}
|
|
|
|
// ResetIpAddress resets all changes to the "ipAddress" field.
|
|
func (m *MachineMutation) ResetIpAddress() {
|
|
m.ipAddress = nil
|
|
}
|
|
|
|
// SetScenarios sets the "scenarios" field.
|
|
func (m *MachineMutation) SetScenarios(s string) {
|
|
m.scenarios = &s
|
|
}
|
|
|
|
// Scenarios returns the value of the "scenarios" field in the mutation.
|
|
func (m *MachineMutation) Scenarios() (r string, exists bool) {
|
|
v := m.scenarios
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldScenarios returns the old "scenarios" field's value of the Machine entity.
|
|
// If the Machine object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *MachineMutation) OldScenarios(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldScenarios is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldScenarios requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldScenarios: %w", err)
|
|
}
|
|
return oldValue.Scenarios, nil
|
|
}
|
|
|
|
// ClearScenarios clears the value of the "scenarios" field.
|
|
func (m *MachineMutation) ClearScenarios() {
|
|
m.scenarios = nil
|
|
m.clearedFields[machine.FieldScenarios] = struct{}{}
|
|
}
|
|
|
|
// ScenariosCleared returns if the "scenarios" field was cleared in this mutation.
|
|
func (m *MachineMutation) ScenariosCleared() bool {
|
|
_, ok := m.clearedFields[machine.FieldScenarios]
|
|
return ok
|
|
}
|
|
|
|
// ResetScenarios resets all changes to the "scenarios" field.
|
|
func (m *MachineMutation) ResetScenarios() {
|
|
m.scenarios = nil
|
|
delete(m.clearedFields, machine.FieldScenarios)
|
|
}
|
|
|
|
// SetVersion sets the "version" field.
|
|
func (m *MachineMutation) SetVersion(s string) {
|
|
m.version = &s
|
|
}
|
|
|
|
// Version returns the value of the "version" field in the mutation.
|
|
func (m *MachineMutation) Version() (r string, exists bool) {
|
|
v := m.version
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldVersion returns the old "version" field's value of the Machine entity.
|
|
// If the Machine object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *MachineMutation) OldVersion(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldVersion is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldVersion requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldVersion: %w", err)
|
|
}
|
|
return oldValue.Version, nil
|
|
}
|
|
|
|
// ClearVersion clears the value of the "version" field.
|
|
func (m *MachineMutation) ClearVersion() {
|
|
m.version = nil
|
|
m.clearedFields[machine.FieldVersion] = struct{}{}
|
|
}
|
|
|
|
// VersionCleared returns if the "version" field was cleared in this mutation.
|
|
func (m *MachineMutation) VersionCleared() bool {
|
|
_, ok := m.clearedFields[machine.FieldVersion]
|
|
return ok
|
|
}
|
|
|
|
// ResetVersion resets all changes to the "version" field.
|
|
func (m *MachineMutation) ResetVersion() {
|
|
m.version = nil
|
|
delete(m.clearedFields, machine.FieldVersion)
|
|
}
|
|
|
|
// SetIsValidated sets the "isValidated" field.
|
|
func (m *MachineMutation) SetIsValidated(b bool) {
|
|
m.isValidated = &b
|
|
}
|
|
|
|
// IsValidated returns the value of the "isValidated" field in the mutation.
|
|
func (m *MachineMutation) IsValidated() (r bool, exists bool) {
|
|
v := m.isValidated
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldIsValidated returns the old "isValidated" field's value of the Machine entity.
|
|
// If the Machine object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *MachineMutation) OldIsValidated(ctx context.Context) (v bool, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldIsValidated is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldIsValidated requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldIsValidated: %w", err)
|
|
}
|
|
return oldValue.IsValidated, nil
|
|
}
|
|
|
|
// ResetIsValidated resets all changes to the "isValidated" field.
|
|
func (m *MachineMutation) ResetIsValidated() {
|
|
m.isValidated = nil
|
|
}
|
|
|
|
// SetStatus sets the "status" field.
|
|
func (m *MachineMutation) SetStatus(s string) {
|
|
m.status = &s
|
|
}
|
|
|
|
// Status returns the value of the "status" field in the mutation.
|
|
func (m *MachineMutation) Status() (r string, exists bool) {
|
|
v := m.status
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldStatus returns the old "status" field's value of the Machine entity.
|
|
// If the Machine object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *MachineMutation) OldStatus(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldStatus is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldStatus requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldStatus: %w", err)
|
|
}
|
|
return oldValue.Status, nil
|
|
}
|
|
|
|
// ClearStatus clears the value of the "status" field.
|
|
func (m *MachineMutation) ClearStatus() {
|
|
m.status = nil
|
|
m.clearedFields[machine.FieldStatus] = struct{}{}
|
|
}
|
|
|
|
// StatusCleared returns if the "status" field was cleared in this mutation.
|
|
func (m *MachineMutation) StatusCleared() bool {
|
|
_, ok := m.clearedFields[machine.FieldStatus]
|
|
return ok
|
|
}
|
|
|
|
// ResetStatus resets all changes to the "status" field.
|
|
func (m *MachineMutation) ResetStatus() {
|
|
m.status = nil
|
|
delete(m.clearedFields, machine.FieldStatus)
|
|
}
|
|
|
|
// SetAuthType sets the "auth_type" field.
|
|
func (m *MachineMutation) SetAuthType(s string) {
|
|
m.auth_type = &s
|
|
}
|
|
|
|
// AuthType returns the value of the "auth_type" field in the mutation.
|
|
func (m *MachineMutation) AuthType() (r string, exists bool) {
|
|
v := m.auth_type
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldAuthType returns the old "auth_type" field's value of the Machine entity.
|
|
// If the Machine object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *MachineMutation) OldAuthType(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldAuthType is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldAuthType requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldAuthType: %w", err)
|
|
}
|
|
return oldValue.AuthType, nil
|
|
}
|
|
|
|
// ResetAuthType resets all changes to the "auth_type" field.
|
|
func (m *MachineMutation) ResetAuthType() {
|
|
m.auth_type = nil
|
|
}
|
|
|
|
// AddAlertIDs adds the "alerts" edge to the Alert entity by ids.
|
|
func (m *MachineMutation) AddAlertIDs(ids ...int) {
|
|
if m.alerts == nil {
|
|
m.alerts = make(map[int]struct{})
|
|
}
|
|
for i := range ids {
|
|
m.alerts[ids[i]] = struct{}{}
|
|
}
|
|
}
|
|
|
|
// ClearAlerts clears the "alerts" edge to the Alert entity.
|
|
func (m *MachineMutation) ClearAlerts() {
|
|
m.clearedalerts = true
|
|
}
|
|
|
|
// AlertsCleared reports if the "alerts" edge to the Alert entity was cleared.
|
|
func (m *MachineMutation) AlertsCleared() bool {
|
|
return m.clearedalerts
|
|
}
|
|
|
|
// RemoveAlertIDs removes the "alerts" edge to the Alert entity by IDs.
|
|
func (m *MachineMutation) RemoveAlertIDs(ids ...int) {
|
|
if m.removedalerts == nil {
|
|
m.removedalerts = make(map[int]struct{})
|
|
}
|
|
for i := range ids {
|
|
delete(m.alerts, ids[i])
|
|
m.removedalerts[ids[i]] = struct{}{}
|
|
}
|
|
}
|
|
|
|
// RemovedAlerts returns the removed IDs of the "alerts" edge to the Alert entity.
|
|
func (m *MachineMutation) RemovedAlertsIDs() (ids []int) {
|
|
for id := range m.removedalerts {
|
|
ids = append(ids, id)
|
|
}
|
|
return
|
|
}
|
|
|
|
// AlertsIDs returns the "alerts" edge IDs in the mutation.
|
|
func (m *MachineMutation) AlertsIDs() (ids []int) {
|
|
for id := range m.alerts {
|
|
ids = append(ids, id)
|
|
}
|
|
return
|
|
}
|
|
|
|
// ResetAlerts resets all changes to the "alerts" edge.
|
|
func (m *MachineMutation) ResetAlerts() {
|
|
m.alerts = nil
|
|
m.clearedalerts = false
|
|
m.removedalerts = nil
|
|
}
|
|
|
|
// Where appends a list predicates to the MachineMutation builder.
|
|
func (m *MachineMutation) Where(ps ...predicate.Machine) {
|
|
m.predicates = append(m.predicates, ps...)
|
|
}
|
|
|
|
// WhereP appends storage-level predicates to the MachineMutation builder. Using this method,
|
|
// users can use type-assertion to append predicates that do not depend on any generated package.
|
|
func (m *MachineMutation) WhereP(ps ...func(*sql.Selector)) {
|
|
p := make([]predicate.Machine, len(ps))
|
|
for i := range ps {
|
|
p[i] = ps[i]
|
|
}
|
|
m.Where(p...)
|
|
}
|
|
|
|
// Op returns the operation name.
|
|
func (m *MachineMutation) Op() Op {
|
|
return m.op
|
|
}
|
|
|
|
// SetOp allows setting the mutation operation.
|
|
func (m *MachineMutation) SetOp(op Op) {
|
|
m.op = op
|
|
}
|
|
|
|
// Type returns the node type of this mutation (Machine).
|
|
func (m *MachineMutation) Type() string {
|
|
return m.typ
|
|
}
|
|
|
|
// Fields returns all fields that were changed during this mutation. Note that in
|
|
// order to get all numeric fields that were incremented/decremented, call
|
|
// AddedFields().
|
|
func (m *MachineMutation) Fields() []string {
|
|
fields := make([]string, 0, 12)
|
|
if m.created_at != nil {
|
|
fields = append(fields, machine.FieldCreatedAt)
|
|
}
|
|
if m.updated_at != nil {
|
|
fields = append(fields, machine.FieldUpdatedAt)
|
|
}
|
|
if m.last_push != nil {
|
|
fields = append(fields, machine.FieldLastPush)
|
|
}
|
|
if m.last_heartbeat != nil {
|
|
fields = append(fields, machine.FieldLastHeartbeat)
|
|
}
|
|
if m.machineId != nil {
|
|
fields = append(fields, machine.FieldMachineId)
|
|
}
|
|
if m.password != nil {
|
|
fields = append(fields, machine.FieldPassword)
|
|
}
|
|
if m.ipAddress != nil {
|
|
fields = append(fields, machine.FieldIpAddress)
|
|
}
|
|
if m.scenarios != nil {
|
|
fields = append(fields, machine.FieldScenarios)
|
|
}
|
|
if m.version != nil {
|
|
fields = append(fields, machine.FieldVersion)
|
|
}
|
|
if m.isValidated != nil {
|
|
fields = append(fields, machine.FieldIsValidated)
|
|
}
|
|
if m.status != nil {
|
|
fields = append(fields, machine.FieldStatus)
|
|
}
|
|
if m.auth_type != nil {
|
|
fields = append(fields, machine.FieldAuthType)
|
|
}
|
|
return fields
|
|
}
|
|
|
|
// Field returns the value of a field with the given name. The second boolean
|
|
// return value indicates that this field was not set, or was not defined in the
|
|
// schema.
|
|
func (m *MachineMutation) Field(name string) (ent.Value, bool) {
|
|
switch name {
|
|
case machine.FieldCreatedAt:
|
|
return m.CreatedAt()
|
|
case machine.FieldUpdatedAt:
|
|
return m.UpdatedAt()
|
|
case machine.FieldLastPush:
|
|
return m.LastPush()
|
|
case machine.FieldLastHeartbeat:
|
|
return m.LastHeartbeat()
|
|
case machine.FieldMachineId:
|
|
return m.MachineId()
|
|
case machine.FieldPassword:
|
|
return m.Password()
|
|
case machine.FieldIpAddress:
|
|
return m.IpAddress()
|
|
case machine.FieldScenarios:
|
|
return m.Scenarios()
|
|
case machine.FieldVersion:
|
|
return m.Version()
|
|
case machine.FieldIsValidated:
|
|
return m.IsValidated()
|
|
case machine.FieldStatus:
|
|
return m.Status()
|
|
case machine.FieldAuthType:
|
|
return m.AuthType()
|
|
}
|
|
return nil, false
|
|
}
|
|
|
|
// OldField returns the old value of the field from the database. An error is
|
|
// returned if the mutation operation is not UpdateOne, or the query to the
|
|
// database failed.
|
|
func (m *MachineMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
|
|
switch name {
|
|
case machine.FieldCreatedAt:
|
|
return m.OldCreatedAt(ctx)
|
|
case machine.FieldUpdatedAt:
|
|
return m.OldUpdatedAt(ctx)
|
|
case machine.FieldLastPush:
|
|
return m.OldLastPush(ctx)
|
|
case machine.FieldLastHeartbeat:
|
|
return m.OldLastHeartbeat(ctx)
|
|
case machine.FieldMachineId:
|
|
return m.OldMachineId(ctx)
|
|
case machine.FieldPassword:
|
|
return m.OldPassword(ctx)
|
|
case machine.FieldIpAddress:
|
|
return m.OldIpAddress(ctx)
|
|
case machine.FieldScenarios:
|
|
return m.OldScenarios(ctx)
|
|
case machine.FieldVersion:
|
|
return m.OldVersion(ctx)
|
|
case machine.FieldIsValidated:
|
|
return m.OldIsValidated(ctx)
|
|
case machine.FieldStatus:
|
|
return m.OldStatus(ctx)
|
|
case machine.FieldAuthType:
|
|
return m.OldAuthType(ctx)
|
|
}
|
|
return nil, fmt.Errorf("unknown Machine field %s", name)
|
|
}
|
|
|
|
// SetField sets the value of a field with the given name. It returns an error if
|
|
// the field is not defined in the schema, or if the type mismatched the field
|
|
// type.
|
|
func (m *MachineMutation) SetField(name string, value ent.Value) error {
|
|
switch name {
|
|
case machine.FieldCreatedAt:
|
|
v, ok := value.(time.Time)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetCreatedAt(v)
|
|
return nil
|
|
case machine.FieldUpdatedAt:
|
|
v, ok := value.(time.Time)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetUpdatedAt(v)
|
|
return nil
|
|
case machine.FieldLastPush:
|
|
v, ok := value.(time.Time)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetLastPush(v)
|
|
return nil
|
|
case machine.FieldLastHeartbeat:
|
|
v, ok := value.(time.Time)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetLastHeartbeat(v)
|
|
return nil
|
|
case machine.FieldMachineId:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetMachineId(v)
|
|
return nil
|
|
case machine.FieldPassword:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetPassword(v)
|
|
return nil
|
|
case machine.FieldIpAddress:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetIpAddress(v)
|
|
return nil
|
|
case machine.FieldScenarios:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetScenarios(v)
|
|
return nil
|
|
case machine.FieldVersion:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetVersion(v)
|
|
return nil
|
|
case machine.FieldIsValidated:
|
|
v, ok := value.(bool)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetIsValidated(v)
|
|
return nil
|
|
case machine.FieldStatus:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetStatus(v)
|
|
return nil
|
|
case machine.FieldAuthType:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetAuthType(v)
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Machine field %s", name)
|
|
}
|
|
|
|
// AddedFields returns all numeric fields that were incremented/decremented during
|
|
// this mutation.
|
|
func (m *MachineMutation) AddedFields() []string {
|
|
return nil
|
|
}
|
|
|
|
// AddedField returns the numeric value that was incremented/decremented on a field
|
|
// with the given name. The second boolean return value indicates that this field
|
|
// was not set, or was not defined in the schema.
|
|
func (m *MachineMutation) AddedField(name string) (ent.Value, bool) {
|
|
return nil, false
|
|
}
|
|
|
|
// AddField adds the value to the field with the given name. It returns an error if
|
|
// the field is not defined in the schema, or if the type mismatched the field
|
|
// type.
|
|
func (m *MachineMutation) AddField(name string, value ent.Value) error {
|
|
switch name {
|
|
}
|
|
return fmt.Errorf("unknown Machine numeric field %s", name)
|
|
}
|
|
|
|
// ClearedFields returns all nullable fields that were cleared during this
|
|
// mutation.
|
|
func (m *MachineMutation) ClearedFields() []string {
|
|
var fields []string
|
|
if m.FieldCleared(machine.FieldCreatedAt) {
|
|
fields = append(fields, machine.FieldCreatedAt)
|
|
}
|
|
if m.FieldCleared(machine.FieldUpdatedAt) {
|
|
fields = append(fields, machine.FieldUpdatedAt)
|
|
}
|
|
if m.FieldCleared(machine.FieldLastPush) {
|
|
fields = append(fields, machine.FieldLastPush)
|
|
}
|
|
if m.FieldCleared(machine.FieldLastHeartbeat) {
|
|
fields = append(fields, machine.FieldLastHeartbeat)
|
|
}
|
|
if m.FieldCleared(machine.FieldScenarios) {
|
|
fields = append(fields, machine.FieldScenarios)
|
|
}
|
|
if m.FieldCleared(machine.FieldVersion) {
|
|
fields = append(fields, machine.FieldVersion)
|
|
}
|
|
if m.FieldCleared(machine.FieldStatus) {
|
|
fields = append(fields, machine.FieldStatus)
|
|
}
|
|
return fields
|
|
}
|
|
|
|
// FieldCleared returns a boolean indicating if a field with the given name was
|
|
// cleared in this mutation.
|
|
func (m *MachineMutation) FieldCleared(name string) bool {
|
|
_, ok := m.clearedFields[name]
|
|
return ok
|
|
}
|
|
|
|
// ClearField clears the value of the field with the given name. It returns an
|
|
// error if the field is not defined in the schema.
|
|
func (m *MachineMutation) ClearField(name string) error {
|
|
switch name {
|
|
case machine.FieldCreatedAt:
|
|
m.ClearCreatedAt()
|
|
return nil
|
|
case machine.FieldUpdatedAt:
|
|
m.ClearUpdatedAt()
|
|
return nil
|
|
case machine.FieldLastPush:
|
|
m.ClearLastPush()
|
|
return nil
|
|
case machine.FieldLastHeartbeat:
|
|
m.ClearLastHeartbeat()
|
|
return nil
|
|
case machine.FieldScenarios:
|
|
m.ClearScenarios()
|
|
return nil
|
|
case machine.FieldVersion:
|
|
m.ClearVersion()
|
|
return nil
|
|
case machine.FieldStatus:
|
|
m.ClearStatus()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Machine nullable field %s", name)
|
|
}
|
|
|
|
// ResetField resets all changes in the mutation for the field with the given name.
|
|
// It returns an error if the field is not defined in the schema.
|
|
func (m *MachineMutation) ResetField(name string) error {
|
|
switch name {
|
|
case machine.FieldCreatedAt:
|
|
m.ResetCreatedAt()
|
|
return nil
|
|
case machine.FieldUpdatedAt:
|
|
m.ResetUpdatedAt()
|
|
return nil
|
|
case machine.FieldLastPush:
|
|
m.ResetLastPush()
|
|
return nil
|
|
case machine.FieldLastHeartbeat:
|
|
m.ResetLastHeartbeat()
|
|
return nil
|
|
case machine.FieldMachineId:
|
|
m.ResetMachineId()
|
|
return nil
|
|
case machine.FieldPassword:
|
|
m.ResetPassword()
|
|
return nil
|
|
case machine.FieldIpAddress:
|
|
m.ResetIpAddress()
|
|
return nil
|
|
case machine.FieldScenarios:
|
|
m.ResetScenarios()
|
|
return nil
|
|
case machine.FieldVersion:
|
|
m.ResetVersion()
|
|
return nil
|
|
case machine.FieldIsValidated:
|
|
m.ResetIsValidated()
|
|
return nil
|
|
case machine.FieldStatus:
|
|
m.ResetStatus()
|
|
return nil
|
|
case machine.FieldAuthType:
|
|
m.ResetAuthType()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Machine field %s", name)
|
|
}
|
|
|
|
// AddedEdges returns all edge names that were set/added in this mutation.
|
|
func (m *MachineMutation) AddedEdges() []string {
|
|
edges := make([]string, 0, 1)
|
|
if m.alerts != nil {
|
|
edges = append(edges, machine.EdgeAlerts)
|
|
}
|
|
return edges
|
|
}
|
|
|
|
// AddedIDs returns all IDs (to other nodes) that were added for the given edge
|
|
// name in this mutation.
|
|
func (m *MachineMutation) AddedIDs(name string) []ent.Value {
|
|
switch name {
|
|
case machine.EdgeAlerts:
|
|
ids := make([]ent.Value, 0, len(m.alerts))
|
|
for id := range m.alerts {
|
|
ids = append(ids, id)
|
|
}
|
|
return ids
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// RemovedEdges returns all edge names that were removed in this mutation.
|
|
func (m *MachineMutation) RemovedEdges() []string {
|
|
edges := make([]string, 0, 1)
|
|
if m.removedalerts != nil {
|
|
edges = append(edges, machine.EdgeAlerts)
|
|
}
|
|
return edges
|
|
}
|
|
|
|
// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
|
|
// the given name in this mutation.
|
|
func (m *MachineMutation) RemovedIDs(name string) []ent.Value {
|
|
switch name {
|
|
case machine.EdgeAlerts:
|
|
ids := make([]ent.Value, 0, len(m.removedalerts))
|
|
for id := range m.removedalerts {
|
|
ids = append(ids, id)
|
|
}
|
|
return ids
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// ClearedEdges returns all edge names that were cleared in this mutation.
|
|
func (m *MachineMutation) ClearedEdges() []string {
|
|
edges := make([]string, 0, 1)
|
|
if m.clearedalerts {
|
|
edges = append(edges, machine.EdgeAlerts)
|
|
}
|
|
return edges
|
|
}
|
|
|
|
// EdgeCleared returns a boolean which indicates if the edge with the given name
|
|
// was cleared in this mutation.
|
|
func (m *MachineMutation) EdgeCleared(name string) bool {
|
|
switch name {
|
|
case machine.EdgeAlerts:
|
|
return m.clearedalerts
|
|
}
|
|
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 *MachineMutation) ClearEdge(name string) error {
|
|
switch name {
|
|
}
|
|
return fmt.Errorf("unknown Machine 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 *MachineMutation) ResetEdge(name string) error {
|
|
switch name {
|
|
case machine.EdgeAlerts:
|
|
m.ResetAlerts()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Machine edge %s", name)
|
|
}
|
|
|
|
// MetaMutation represents an operation that mutates the Meta nodes in the graph.
|
|
type MetaMutation struct {
|
|
config
|
|
op Op
|
|
typ string
|
|
id *int
|
|
created_at *time.Time
|
|
updated_at *time.Time
|
|
key *string
|
|
value *string
|
|
clearedFields map[string]struct{}
|
|
owner *int
|
|
clearedowner bool
|
|
done bool
|
|
oldValue func(context.Context) (*Meta, error)
|
|
predicates []predicate.Meta
|
|
}
|
|
|
|
var _ ent.Mutation = (*MetaMutation)(nil)
|
|
|
|
// metaOption allows management of the mutation configuration using functional options.
|
|
type metaOption func(*MetaMutation)
|
|
|
|
// newMetaMutation creates new mutation for the Meta entity.
|
|
func newMetaMutation(c config, op Op, opts ...metaOption) *MetaMutation {
|
|
m := &MetaMutation{
|
|
config: c,
|
|
op: op,
|
|
typ: TypeMeta,
|
|
clearedFields: make(map[string]struct{}),
|
|
}
|
|
for _, opt := range opts {
|
|
opt(m)
|
|
}
|
|
return m
|
|
}
|
|
|
|
// withMetaID sets the ID field of the mutation.
|
|
func withMetaID(id int) metaOption {
|
|
return func(m *MetaMutation) {
|
|
var (
|
|
err error
|
|
once sync.Once
|
|
value *Meta
|
|
)
|
|
m.oldValue = func(ctx context.Context) (*Meta, error) {
|
|
once.Do(func() {
|
|
if m.done {
|
|
err = errors.New("querying old values post mutation is not allowed")
|
|
} else {
|
|
value, err = m.Client().Meta.Get(ctx, id)
|
|
}
|
|
})
|
|
return value, err
|
|
}
|
|
m.id = &id
|
|
}
|
|
}
|
|
|
|
// withMeta sets the old Meta of the mutation.
|
|
func withMeta(node *Meta) metaOption {
|
|
return func(m *MetaMutation) {
|
|
m.oldValue = func(context.Context) (*Meta, error) {
|
|
return node, nil
|
|
}
|
|
m.id = &node.ID
|
|
}
|
|
}
|
|
|
|
// Client returns a new `ent.Client` from the mutation. If the mutation was
|
|
// executed in a transaction (ent.Tx), a transactional client is returned.
|
|
func (m MetaMutation) Client() *Client {
|
|
client := &Client{config: m.config}
|
|
client.init()
|
|
return client
|
|
}
|
|
|
|
// Tx returns an `ent.Tx` for mutations that were executed in transactions;
|
|
// it returns an error otherwise.
|
|
func (m MetaMutation) Tx() (*Tx, error) {
|
|
if _, ok := m.driver.(*txDriver); !ok {
|
|
return nil, errors.New("ent: mutation is not running in a transaction")
|
|
}
|
|
tx := &Tx{config: m.config}
|
|
tx.init()
|
|
return tx, nil
|
|
}
|
|
|
|
// ID returns the ID value in the mutation. Note that the ID is only available
|
|
// if it was provided to the builder or after it was returned from the database.
|
|
func (m *MetaMutation) ID() (id int, exists bool) {
|
|
if m.id == nil {
|
|
return
|
|
}
|
|
return *m.id, true
|
|
}
|
|
|
|
// IDs queries the database and returns the entity ids that match the mutation's predicate.
|
|
// That means, if the mutation is applied within a transaction with an isolation level such
|
|
// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
|
|
// or updated by the mutation.
|
|
func (m *MetaMutation) IDs(ctx context.Context) ([]int, error) {
|
|
switch {
|
|
case m.op.Is(OpUpdateOne | OpDeleteOne):
|
|
id, exists := m.ID()
|
|
if exists {
|
|
return []int{id}, nil
|
|
}
|
|
fallthrough
|
|
case m.op.Is(OpUpdate | OpDelete):
|
|
return m.Client().Meta.Query().Where(m.predicates...).IDs(ctx)
|
|
default:
|
|
return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
|
|
}
|
|
}
|
|
|
|
// SetCreatedAt sets the "created_at" field.
|
|
func (m *MetaMutation) SetCreatedAt(t time.Time) {
|
|
m.created_at = &t
|
|
}
|
|
|
|
// CreatedAt returns the value of the "created_at" field in the mutation.
|
|
func (m *MetaMutation) CreatedAt() (r time.Time, exists bool) {
|
|
v := m.created_at
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldCreatedAt returns the old "created_at" field's value of the Meta entity.
|
|
// If the Meta object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *MetaMutation) OldCreatedAt(ctx context.Context) (v *time.Time, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldCreatedAt requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldCreatedAt: %w", err)
|
|
}
|
|
return oldValue.CreatedAt, nil
|
|
}
|
|
|
|
// ClearCreatedAt clears the value of the "created_at" field.
|
|
func (m *MetaMutation) ClearCreatedAt() {
|
|
m.created_at = nil
|
|
m.clearedFields[meta.FieldCreatedAt] = struct{}{}
|
|
}
|
|
|
|
// CreatedAtCleared returns if the "created_at" field was cleared in this mutation.
|
|
func (m *MetaMutation) CreatedAtCleared() bool {
|
|
_, ok := m.clearedFields[meta.FieldCreatedAt]
|
|
return ok
|
|
}
|
|
|
|
// ResetCreatedAt resets all changes to the "created_at" field.
|
|
func (m *MetaMutation) ResetCreatedAt() {
|
|
m.created_at = nil
|
|
delete(m.clearedFields, meta.FieldCreatedAt)
|
|
}
|
|
|
|
// SetUpdatedAt sets the "updated_at" field.
|
|
func (m *MetaMutation) SetUpdatedAt(t time.Time) {
|
|
m.updated_at = &t
|
|
}
|
|
|
|
// UpdatedAt returns the value of the "updated_at" field in the mutation.
|
|
func (m *MetaMutation) UpdatedAt() (r time.Time, exists bool) {
|
|
v := m.updated_at
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldUpdatedAt returns the old "updated_at" field's value of the Meta entity.
|
|
// If the Meta object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *MetaMutation) OldUpdatedAt(ctx context.Context) (v *time.Time, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldUpdatedAt requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldUpdatedAt: %w", err)
|
|
}
|
|
return oldValue.UpdatedAt, nil
|
|
}
|
|
|
|
// ClearUpdatedAt clears the value of the "updated_at" field.
|
|
func (m *MetaMutation) ClearUpdatedAt() {
|
|
m.updated_at = nil
|
|
m.clearedFields[meta.FieldUpdatedAt] = struct{}{}
|
|
}
|
|
|
|
// UpdatedAtCleared returns if the "updated_at" field was cleared in this mutation.
|
|
func (m *MetaMutation) UpdatedAtCleared() bool {
|
|
_, ok := m.clearedFields[meta.FieldUpdatedAt]
|
|
return ok
|
|
}
|
|
|
|
// ResetUpdatedAt resets all changes to the "updated_at" field.
|
|
func (m *MetaMutation) ResetUpdatedAt() {
|
|
m.updated_at = nil
|
|
delete(m.clearedFields, meta.FieldUpdatedAt)
|
|
}
|
|
|
|
// SetKey sets the "key" field.
|
|
func (m *MetaMutation) SetKey(s string) {
|
|
m.key = &s
|
|
}
|
|
|
|
// Key returns the value of the "key" field in the mutation.
|
|
func (m *MetaMutation) Key() (r string, exists bool) {
|
|
v := m.key
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldKey returns the old "key" field's value of the Meta entity.
|
|
// If the Meta object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *MetaMutation) OldKey(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldKey is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldKey requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldKey: %w", err)
|
|
}
|
|
return oldValue.Key, nil
|
|
}
|
|
|
|
// ResetKey resets all changes to the "key" field.
|
|
func (m *MetaMutation) ResetKey() {
|
|
m.key = nil
|
|
}
|
|
|
|
// SetValue sets the "value" field.
|
|
func (m *MetaMutation) SetValue(s string) {
|
|
m.value = &s
|
|
}
|
|
|
|
// Value returns the value of the "value" field in the mutation.
|
|
func (m *MetaMutation) Value() (r string, exists bool) {
|
|
v := m.value
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldValue returns the old "value" field's value of the Meta entity.
|
|
// If the Meta object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *MetaMutation) OldValue(ctx context.Context) (v string, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldValue is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldValue requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldValue: %w", err)
|
|
}
|
|
return oldValue.Value, nil
|
|
}
|
|
|
|
// ResetValue resets all changes to the "value" field.
|
|
func (m *MetaMutation) ResetValue() {
|
|
m.value = nil
|
|
}
|
|
|
|
// SetAlertMetas sets the "alert_metas" field.
|
|
func (m *MetaMutation) SetAlertMetas(i int) {
|
|
m.owner = &i
|
|
}
|
|
|
|
// AlertMetas returns the value of the "alert_metas" field in the mutation.
|
|
func (m *MetaMutation) AlertMetas() (r int, exists bool) {
|
|
v := m.owner
|
|
if v == nil {
|
|
return
|
|
}
|
|
return *v, true
|
|
}
|
|
|
|
// OldAlertMetas returns the old "alert_metas" field's value of the Meta entity.
|
|
// If the Meta object wasn't provided to the builder, the object is fetched from the database.
|
|
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
|
|
func (m *MetaMutation) OldAlertMetas(ctx context.Context) (v int, err error) {
|
|
if !m.op.Is(OpUpdateOne) {
|
|
return v, errors.New("OldAlertMetas is only allowed on UpdateOne operations")
|
|
}
|
|
if m.id == nil || m.oldValue == nil {
|
|
return v, errors.New("OldAlertMetas requires an ID field in the mutation")
|
|
}
|
|
oldValue, err := m.oldValue(ctx)
|
|
if err != nil {
|
|
return v, fmt.Errorf("querying old value for OldAlertMetas: %w", err)
|
|
}
|
|
return oldValue.AlertMetas, nil
|
|
}
|
|
|
|
// ClearAlertMetas clears the value of the "alert_metas" field.
|
|
func (m *MetaMutation) ClearAlertMetas() {
|
|
m.owner = nil
|
|
m.clearedFields[meta.FieldAlertMetas] = struct{}{}
|
|
}
|
|
|
|
// AlertMetasCleared returns if the "alert_metas" field was cleared in this mutation.
|
|
func (m *MetaMutation) AlertMetasCleared() bool {
|
|
_, ok := m.clearedFields[meta.FieldAlertMetas]
|
|
return ok
|
|
}
|
|
|
|
// ResetAlertMetas resets all changes to the "alert_metas" field.
|
|
func (m *MetaMutation) ResetAlertMetas() {
|
|
m.owner = nil
|
|
delete(m.clearedFields, meta.FieldAlertMetas)
|
|
}
|
|
|
|
// SetOwnerID sets the "owner" edge to the Alert entity by id.
|
|
func (m *MetaMutation) SetOwnerID(id int) {
|
|
m.owner = &id
|
|
}
|
|
|
|
// ClearOwner clears the "owner" edge to the Alert entity.
|
|
func (m *MetaMutation) ClearOwner() {
|
|
m.clearedowner = true
|
|
m.clearedFields[meta.FieldAlertMetas] = struct{}{}
|
|
}
|
|
|
|
// OwnerCleared reports if the "owner" edge to the Alert entity was cleared.
|
|
func (m *MetaMutation) OwnerCleared() bool {
|
|
return m.AlertMetasCleared() || m.clearedowner
|
|
}
|
|
|
|
// OwnerID returns the "owner" edge ID in the mutation.
|
|
func (m *MetaMutation) OwnerID() (id int, exists bool) {
|
|
if m.owner != nil {
|
|
return *m.owner, true
|
|
}
|
|
return
|
|
}
|
|
|
|
// OwnerIDs returns the "owner" edge IDs in the mutation.
|
|
// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use
|
|
// OwnerID instead. It exists only for internal usage by the builders.
|
|
func (m *MetaMutation) OwnerIDs() (ids []int) {
|
|
if id := m.owner; id != nil {
|
|
ids = append(ids, *id)
|
|
}
|
|
return
|
|
}
|
|
|
|
// ResetOwner resets all changes to the "owner" edge.
|
|
func (m *MetaMutation) ResetOwner() {
|
|
m.owner = nil
|
|
m.clearedowner = false
|
|
}
|
|
|
|
// Where appends a list predicates to the MetaMutation builder.
|
|
func (m *MetaMutation) Where(ps ...predicate.Meta) {
|
|
m.predicates = append(m.predicates, ps...)
|
|
}
|
|
|
|
// WhereP appends storage-level predicates to the MetaMutation builder. Using this method,
|
|
// users can use type-assertion to append predicates that do not depend on any generated package.
|
|
func (m *MetaMutation) WhereP(ps ...func(*sql.Selector)) {
|
|
p := make([]predicate.Meta, len(ps))
|
|
for i := range ps {
|
|
p[i] = ps[i]
|
|
}
|
|
m.Where(p...)
|
|
}
|
|
|
|
// Op returns the operation name.
|
|
func (m *MetaMutation) Op() Op {
|
|
return m.op
|
|
}
|
|
|
|
// SetOp allows setting the mutation operation.
|
|
func (m *MetaMutation) SetOp(op Op) {
|
|
m.op = op
|
|
}
|
|
|
|
// Type returns the node type of this mutation (Meta).
|
|
func (m *MetaMutation) Type() string {
|
|
return m.typ
|
|
}
|
|
|
|
// Fields returns all fields that were changed during this mutation. Note that in
|
|
// order to get all numeric fields that were incremented/decremented, call
|
|
// AddedFields().
|
|
func (m *MetaMutation) Fields() []string {
|
|
fields := make([]string, 0, 5)
|
|
if m.created_at != nil {
|
|
fields = append(fields, meta.FieldCreatedAt)
|
|
}
|
|
if m.updated_at != nil {
|
|
fields = append(fields, meta.FieldUpdatedAt)
|
|
}
|
|
if m.key != nil {
|
|
fields = append(fields, meta.FieldKey)
|
|
}
|
|
if m.value != nil {
|
|
fields = append(fields, meta.FieldValue)
|
|
}
|
|
if m.owner != nil {
|
|
fields = append(fields, meta.FieldAlertMetas)
|
|
}
|
|
return fields
|
|
}
|
|
|
|
// Field returns the value of a field with the given name. The second boolean
|
|
// return value indicates that this field was not set, or was not defined in the
|
|
// schema.
|
|
func (m *MetaMutation) Field(name string) (ent.Value, bool) {
|
|
switch name {
|
|
case meta.FieldCreatedAt:
|
|
return m.CreatedAt()
|
|
case meta.FieldUpdatedAt:
|
|
return m.UpdatedAt()
|
|
case meta.FieldKey:
|
|
return m.Key()
|
|
case meta.FieldValue:
|
|
return m.Value()
|
|
case meta.FieldAlertMetas:
|
|
return m.AlertMetas()
|
|
}
|
|
return nil, false
|
|
}
|
|
|
|
// OldField returns the old value of the field from the database. An error is
|
|
// returned if the mutation operation is not UpdateOne, or the query to the
|
|
// database failed.
|
|
func (m *MetaMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
|
|
switch name {
|
|
case meta.FieldCreatedAt:
|
|
return m.OldCreatedAt(ctx)
|
|
case meta.FieldUpdatedAt:
|
|
return m.OldUpdatedAt(ctx)
|
|
case meta.FieldKey:
|
|
return m.OldKey(ctx)
|
|
case meta.FieldValue:
|
|
return m.OldValue(ctx)
|
|
case meta.FieldAlertMetas:
|
|
return m.OldAlertMetas(ctx)
|
|
}
|
|
return nil, fmt.Errorf("unknown Meta field %s", name)
|
|
}
|
|
|
|
// SetField sets the value of a field with the given name. It returns an error if
|
|
// the field is not defined in the schema, or if the type mismatched the field
|
|
// type.
|
|
func (m *MetaMutation) SetField(name string, value ent.Value) error {
|
|
switch name {
|
|
case meta.FieldCreatedAt:
|
|
v, ok := value.(time.Time)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetCreatedAt(v)
|
|
return nil
|
|
case meta.FieldUpdatedAt:
|
|
v, ok := value.(time.Time)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetUpdatedAt(v)
|
|
return nil
|
|
case meta.FieldKey:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetKey(v)
|
|
return nil
|
|
case meta.FieldValue:
|
|
v, ok := value.(string)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetValue(v)
|
|
return nil
|
|
case meta.FieldAlertMetas:
|
|
v, ok := value.(int)
|
|
if !ok {
|
|
return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
}
|
|
m.SetAlertMetas(v)
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Meta field %s", name)
|
|
}
|
|
|
|
// AddedFields returns all numeric fields that were incremented/decremented during
|
|
// this mutation.
|
|
func (m *MetaMutation) AddedFields() []string {
|
|
var fields []string
|
|
return fields
|
|
}
|
|
|
|
// AddedField returns the numeric value that was incremented/decremented on a field
|
|
// with the given name. The second boolean return value indicates that this field
|
|
// was not set, or was not defined in the schema.
|
|
func (m *MetaMutation) AddedField(name string) (ent.Value, bool) {
|
|
switch name {
|
|
}
|
|
return nil, false
|
|
}
|
|
|
|
// AddField adds the value to the field with the given name. It returns an error if
|
|
// the field is not defined in the schema, or if the type mismatched the field
|
|
// type.
|
|
func (m *MetaMutation) AddField(name string, value ent.Value) error {
|
|
switch name {
|
|
}
|
|
return fmt.Errorf("unknown Meta numeric field %s", name)
|
|
}
|
|
|
|
// ClearedFields returns all nullable fields that were cleared during this
|
|
// mutation.
|
|
func (m *MetaMutation) ClearedFields() []string {
|
|
var fields []string
|
|
if m.FieldCleared(meta.FieldCreatedAt) {
|
|
fields = append(fields, meta.FieldCreatedAt)
|
|
}
|
|
if m.FieldCleared(meta.FieldUpdatedAt) {
|
|
fields = append(fields, meta.FieldUpdatedAt)
|
|
}
|
|
if m.FieldCleared(meta.FieldAlertMetas) {
|
|
fields = append(fields, meta.FieldAlertMetas)
|
|
}
|
|
return fields
|
|
}
|
|
|
|
// FieldCleared returns a boolean indicating if a field with the given name was
|
|
// cleared in this mutation.
|
|
func (m *MetaMutation) FieldCleared(name string) bool {
|
|
_, ok := m.clearedFields[name]
|
|
return ok
|
|
}
|
|
|
|
// ClearField clears the value of the field with the given name. It returns an
|
|
// error if the field is not defined in the schema.
|
|
func (m *MetaMutation) ClearField(name string) error {
|
|
switch name {
|
|
case meta.FieldCreatedAt:
|
|
m.ClearCreatedAt()
|
|
return nil
|
|
case meta.FieldUpdatedAt:
|
|
m.ClearUpdatedAt()
|
|
return nil
|
|
case meta.FieldAlertMetas:
|
|
m.ClearAlertMetas()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Meta nullable field %s", name)
|
|
}
|
|
|
|
// ResetField resets all changes in the mutation for the field with the given name.
|
|
// It returns an error if the field is not defined in the schema.
|
|
func (m *MetaMutation) ResetField(name string) error {
|
|
switch name {
|
|
case meta.FieldCreatedAt:
|
|
m.ResetCreatedAt()
|
|
return nil
|
|
case meta.FieldUpdatedAt:
|
|
m.ResetUpdatedAt()
|
|
return nil
|
|
case meta.FieldKey:
|
|
m.ResetKey()
|
|
return nil
|
|
case meta.FieldValue:
|
|
m.ResetValue()
|
|
return nil
|
|
case meta.FieldAlertMetas:
|
|
m.ResetAlertMetas()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Meta field %s", name)
|
|
}
|
|
|
|
// AddedEdges returns all edge names that were set/added in this mutation.
|
|
func (m *MetaMutation) AddedEdges() []string {
|
|
edges := make([]string, 0, 1)
|
|
if m.owner != nil {
|
|
edges = append(edges, meta.EdgeOwner)
|
|
}
|
|
return edges
|
|
}
|
|
|
|
// AddedIDs returns all IDs (to other nodes) that were added for the given edge
|
|
// name in this mutation.
|
|
func (m *MetaMutation) AddedIDs(name string) []ent.Value {
|
|
switch name {
|
|
case meta.EdgeOwner:
|
|
if id := m.owner; id != nil {
|
|
return []ent.Value{*id}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// RemovedEdges returns all edge names that were removed in this mutation.
|
|
func (m *MetaMutation) RemovedEdges() []string {
|
|
edges := make([]string, 0, 1)
|
|
return edges
|
|
}
|
|
|
|
// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
|
|
// the given name in this mutation.
|
|
func (m *MetaMutation) RemovedIDs(name string) []ent.Value {
|
|
return nil
|
|
}
|
|
|
|
// ClearedEdges returns all edge names that were cleared in this mutation.
|
|
func (m *MetaMutation) ClearedEdges() []string {
|
|
edges := make([]string, 0, 1)
|
|
if m.clearedowner {
|
|
edges = append(edges, meta.EdgeOwner)
|
|
}
|
|
return edges
|
|
}
|
|
|
|
// EdgeCleared returns a boolean which indicates if the edge with the given name
|
|
// was cleared in this mutation.
|
|
func (m *MetaMutation) EdgeCleared(name string) bool {
|
|
switch name {
|
|
case meta.EdgeOwner:
|
|
return m.clearedowner
|
|
}
|
|
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 *MetaMutation) ClearEdge(name string) error {
|
|
switch name {
|
|
case meta.EdgeOwner:
|
|
m.ClearOwner()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Meta 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 *MetaMutation) ResetEdge(name string) error {
|
|
switch name {
|
|
case meta.EdgeOwner:
|
|
m.ResetOwner()
|
|
return nil
|
|
}
|
|
return fmt.Errorf("unknown Meta edge %s", name)
|
|
}
|