|
@@ -9,6 +9,9 @@ import (
|
|
|
"sync"
|
|
|
"time"
|
|
|
"wechat-api/ent/contact"
|
|
|
+ "wechat-api/ent/label"
|
|
|
+ "wechat-api/ent/labelrelationship"
|
|
|
+ "wechat-api/ent/message"
|
|
|
"wechat-api/ent/predicate"
|
|
|
"wechat-api/ent/server"
|
|
|
"wechat-api/ent/wx"
|
|
@@ -26,45 +29,51 @@ const (
|
|
|
OpUpdateOne = ent.OpUpdateOne
|
|
|
|
|
|
// Node types.
|
|
|
- TypeContact = "Contact"
|
|
|
- TypeServer = "Server"
|
|
|
- TypeWx = "Wx"
|
|
|
+ TypeContact = "Contact"
|
|
|
+ TypeLabel = "Label"
|
|
|
+ TypeLabelRelationship = "LabelRelationship"
|
|
|
+ TypeMessage = "Message"
|
|
|
+ TypeServer = "Server"
|
|
|
+ TypeWx = "Wx"
|
|
|
)
|
|
|
|
|
|
// ContactMutation represents an operation that mutates the Contact nodes in the graph.
|
|
|
type ContactMutation struct {
|
|
|
config
|
|
|
- op Op
|
|
|
- typ string
|
|
|
- id *uint64
|
|
|
- created_at *time.Time
|
|
|
- updated_at *time.Time
|
|
|
- status *uint8
|
|
|
- addstatus *int8
|
|
|
- deleted_at *time.Time
|
|
|
- wx_wxid *string
|
|
|
- _type *int
|
|
|
- add_type *int
|
|
|
- wxid *string
|
|
|
- account *string
|
|
|
- nickname *string
|
|
|
- markname *string
|
|
|
- headimg *string
|
|
|
- sex *int
|
|
|
- addsex *int
|
|
|
- starrole *string
|
|
|
- dontseeit *int
|
|
|
- adddontseeit *int
|
|
|
- dontseeme *int
|
|
|
- adddontseeme *int
|
|
|
- lag *string
|
|
|
- gid *string
|
|
|
- gname *string
|
|
|
- v3 *string
|
|
|
- clearedFields map[string]struct{}
|
|
|
- done bool
|
|
|
- oldValue func(context.Context) (*Contact, error)
|
|
|
- predicates []predicate.Contact
|
|
|
+ op Op
|
|
|
+ typ string
|
|
|
+ id *uint64
|
|
|
+ created_at *time.Time
|
|
|
+ updated_at *time.Time
|
|
|
+ status *uint8
|
|
|
+ addstatus *int8
|
|
|
+ deleted_at *time.Time
|
|
|
+ wx_wxid *string
|
|
|
+ _type *int
|
|
|
+ add_type *int
|
|
|
+ wxid *string
|
|
|
+ account *string
|
|
|
+ nickname *string
|
|
|
+ markname *string
|
|
|
+ headimg *string
|
|
|
+ sex *int
|
|
|
+ addsex *int
|
|
|
+ starrole *string
|
|
|
+ dontseeit *int
|
|
|
+ adddontseeit *int
|
|
|
+ dontseeme *int
|
|
|
+ adddontseeme *int
|
|
|
+ lag *string
|
|
|
+ gid *string
|
|
|
+ gname *string
|
|
|
+ v3 *string
|
|
|
+ clearedFields map[string]struct{}
|
|
|
+ contact_relationships map[uint64]struct{}
|
|
|
+ removedcontact_relationships map[uint64]struct{}
|
|
|
+ clearedcontact_relationships bool
|
|
|
+ done bool
|
|
|
+ oldValue func(context.Context) (*Contact, error)
|
|
|
+ predicates []predicate.Contact
|
|
|
}
|
|
|
|
|
|
var _ ent.Mutation = (*ContactMutation)(nil)
|
|
@@ -1009,6 +1018,60 @@ func (m *ContactMutation) ResetV3() {
|
|
|
m.v3 = nil
|
|
|
}
|
|
|
|
|
|
+// AddContactRelationshipIDs adds the "contact_relationships" edge to the LabelRelationship entity by ids.
|
|
|
+func (m *ContactMutation) AddContactRelationshipIDs(ids ...uint64) {
|
|
|
+ if m.contact_relationships == nil {
|
|
|
+ m.contact_relationships = make(map[uint64]struct{})
|
|
|
+ }
|
|
|
+ for i := range ids {
|
|
|
+ m.contact_relationships[ids[i]] = struct{}{}
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+// ClearContactRelationships clears the "contact_relationships" edge to the LabelRelationship entity.
|
|
|
+func (m *ContactMutation) ClearContactRelationships() {
|
|
|
+ m.clearedcontact_relationships = true
|
|
|
+}
|
|
|
+
|
|
|
+// ContactRelationshipsCleared reports if the "contact_relationships" edge to the LabelRelationship entity was cleared.
|
|
|
+func (m *ContactMutation) ContactRelationshipsCleared() bool {
|
|
|
+ return m.clearedcontact_relationships
|
|
|
+}
|
|
|
+
|
|
|
+// RemoveContactRelationshipIDs removes the "contact_relationships" edge to the LabelRelationship entity by IDs.
|
|
|
+func (m *ContactMutation) RemoveContactRelationshipIDs(ids ...uint64) {
|
|
|
+ if m.removedcontact_relationships == nil {
|
|
|
+ m.removedcontact_relationships = make(map[uint64]struct{})
|
|
|
+ }
|
|
|
+ for i := range ids {
|
|
|
+ delete(m.contact_relationships, ids[i])
|
|
|
+ m.removedcontact_relationships[ids[i]] = struct{}{}
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+// RemovedContactRelationships returns the removed IDs of the "contact_relationships" edge to the LabelRelationship entity.
|
|
|
+func (m *ContactMutation) RemovedContactRelationshipsIDs() (ids []uint64) {
|
|
|
+ for id := range m.removedcontact_relationships {
|
|
|
+ ids = append(ids, id)
|
|
|
+ }
|
|
|
+ return
|
|
|
+}
|
|
|
+
|
|
|
+// ContactRelationshipsIDs returns the "contact_relationships" edge IDs in the mutation.
|
|
|
+func (m *ContactMutation) ContactRelationshipsIDs() (ids []uint64) {
|
|
|
+ for id := range m.contact_relationships {
|
|
|
+ ids = append(ids, id)
|
|
|
+ }
|
|
|
+ return
|
|
|
+}
|
|
|
+
|
|
|
+// ResetContactRelationships resets all changes to the "contact_relationships" edge.
|
|
|
+func (m *ContactMutation) ResetContactRelationships() {
|
|
|
+ m.contact_relationships = nil
|
|
|
+ m.clearedcontact_relationships = false
|
|
|
+ m.removedcontact_relationships = nil
|
|
|
+}
|
|
|
+
|
|
|
// Where appends a list predicates to the ContactMutation builder.
|
|
|
func (m *ContactMutation) Where(ps ...predicate.Contact) {
|
|
|
m.predicates = append(m.predicates, ps...)
|
|
@@ -1538,52 +1601,2403 @@ func (m *ContactMutation) ResetField(name string) error {
|
|
|
|
|
|
// AddedEdges returns all edge names that were set/added in this mutation.
|
|
|
func (m *ContactMutation) AddedEdges() []string {
|
|
|
- edges := make([]string, 0, 0)
|
|
|
+ edges := make([]string, 0, 1)
|
|
|
+ if m.contact_relationships != nil {
|
|
|
+ edges = append(edges, contact.EdgeContactRelationships)
|
|
|
+ }
|
|
|
return edges
|
|
|
}
|
|
|
|
|
|
// AddedIDs returns all IDs (to other nodes) that were added for the given edge
|
|
|
// name in this mutation.
|
|
|
func (m *ContactMutation) AddedIDs(name string) []ent.Value {
|
|
|
+ switch name {
|
|
|
+ case contact.EdgeContactRelationships:
|
|
|
+ ids := make([]ent.Value, 0, len(m.contact_relationships))
|
|
|
+ for id := range m.contact_relationships {
|
|
|
+ ids = append(ids, id)
|
|
|
+ }
|
|
|
+ return ids
|
|
|
+ }
|
|
|
return nil
|
|
|
}
|
|
|
|
|
|
// RemovedEdges returns all edge names that were removed in this mutation.
|
|
|
func (m *ContactMutation) RemovedEdges() []string {
|
|
|
- edges := make([]string, 0, 0)
|
|
|
+ edges := make([]string, 0, 1)
|
|
|
+ if m.removedcontact_relationships != nil {
|
|
|
+ edges = append(edges, contact.EdgeContactRelationships)
|
|
|
+ }
|
|
|
return edges
|
|
|
}
|
|
|
|
|
|
// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
|
|
|
// the given name in this mutation.
|
|
|
func (m *ContactMutation) RemovedIDs(name string) []ent.Value {
|
|
|
+ switch name {
|
|
|
+ case contact.EdgeContactRelationships:
|
|
|
+ ids := make([]ent.Value, 0, len(m.removedcontact_relationships))
|
|
|
+ for id := range m.removedcontact_relationships {
|
|
|
+ ids = append(ids, id)
|
|
|
+ }
|
|
|
+ return ids
|
|
|
+ }
|
|
|
return nil
|
|
|
}
|
|
|
|
|
|
// ClearedEdges returns all edge names that were cleared in this mutation.
|
|
|
func (m *ContactMutation) ClearedEdges() []string {
|
|
|
- edges := make([]string, 0, 0)
|
|
|
+ edges := make([]string, 0, 1)
|
|
|
+ if m.clearedcontact_relationships {
|
|
|
+ edges = append(edges, contact.EdgeContactRelationships)
|
|
|
+ }
|
|
|
return edges
|
|
|
}
|
|
|
|
|
|
// EdgeCleared returns a boolean which indicates if the edge with the given name
|
|
|
// was cleared in this mutation.
|
|
|
func (m *ContactMutation) EdgeCleared(name string) bool {
|
|
|
+ switch name {
|
|
|
+ case contact.EdgeContactRelationships:
|
|
|
+ return m.clearedcontact_relationships
|
|
|
+ }
|
|
|
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 *ContactMutation) ClearEdge(name string) error {
|
|
|
+ switch name {
|
|
|
+ }
|
|
|
return fmt.Errorf("unknown Contact 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 *ContactMutation) ResetEdge(name string) error {
|
|
|
+ switch name {
|
|
|
+ case contact.EdgeContactRelationships:
|
|
|
+ m.ResetContactRelationships()
|
|
|
+ return nil
|
|
|
+ }
|
|
|
return fmt.Errorf("unknown Contact edge %s", name)
|
|
|
}
|
|
|
|
|
|
+// LabelMutation represents an operation that mutates the Label nodes in the graph.
|
|
|
+type LabelMutation struct {
|
|
|
+ config
|
|
|
+ op Op
|
|
|
+ typ string
|
|
|
+ id *uint64
|
|
|
+ created_at *time.Time
|
|
|
+ updated_at *time.Time
|
|
|
+ status *uint8
|
|
|
+ addstatus *int8
|
|
|
+ deleted_at *time.Time
|
|
|
+ _type *int
|
|
|
+ add_type *int
|
|
|
+ name *string
|
|
|
+ from *int
|
|
|
+ addfrom *int
|
|
|
+ mode *int
|
|
|
+ addmode *int
|
|
|
+ conditions *string
|
|
|
+ clearedFields map[string]struct{}
|
|
|
+ label_relationships map[uint64]struct{}
|
|
|
+ removedlabel_relationships map[uint64]struct{}
|
|
|
+ clearedlabel_relationships bool
|
|
|
+ done bool
|
|
|
+ oldValue func(context.Context) (*Label, error)
|
|
|
+ predicates []predicate.Label
|
|
|
+}
|
|
|
+
|
|
|
+var _ ent.Mutation = (*LabelMutation)(nil)
|
|
|
+
|
|
|
+// labelOption allows management of the mutation configuration using functional options.
|
|
|
+type labelOption func(*LabelMutation)
|
|
|
+
|
|
|
+// newLabelMutation creates new mutation for the Label entity.
|
|
|
+func newLabelMutation(c config, op Op, opts ...labelOption) *LabelMutation {
|
|
|
+ m := &LabelMutation{
|
|
|
+ config: c,
|
|
|
+ op: op,
|
|
|
+ typ: TypeLabel,
|
|
|
+ clearedFields: make(map[string]struct{}),
|
|
|
+ }
|
|
|
+ for _, opt := range opts {
|
|
|
+ opt(m)
|
|
|
+ }
|
|
|
+ return m
|
|
|
+}
|
|
|
+
|
|
|
+// withLabelID sets the ID field of the mutation.
|
|
|
+func withLabelID(id uint64) labelOption {
|
|
|
+ return func(m *LabelMutation) {
|
|
|
+ var (
|
|
|
+ err error
|
|
|
+ once sync.Once
|
|
|
+ value *Label
|
|
|
+ )
|
|
|
+ m.oldValue = func(ctx context.Context) (*Label, error) {
|
|
|
+ once.Do(func() {
|
|
|
+ if m.done {
|
|
|
+ err = errors.New("querying old values post mutation is not allowed")
|
|
|
+ } else {
|
|
|
+ value, err = m.Client().Label.Get(ctx, id)
|
|
|
+ }
|
|
|
+ })
|
|
|
+ return value, err
|
|
|
+ }
|
|
|
+ m.id = &id
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+// withLabel sets the old Label of the mutation.
|
|
|
+func withLabel(node *Label) labelOption {
|
|
|
+ return func(m *LabelMutation) {
|
|
|
+ m.oldValue = func(context.Context) (*Label, 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 LabelMutation) 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 LabelMutation) 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
|
|
|
+}
|
|
|
+
|
|
|
+// SetID sets the value of the id field. Note that this
|
|
|
+// operation is only accepted on creation of Label entities.
|
|
|
+func (m *LabelMutation) SetID(id uint64) {
|
|
|
+ m.id = &id
|
|
|
+}
|
|
|
+
|
|
|
+// 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 *LabelMutation) ID() (id uint64, 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 *LabelMutation) IDs(ctx context.Context) ([]uint64, error) {
|
|
|
+ switch {
|
|
|
+ case m.op.Is(OpUpdateOne | OpDeleteOne):
|
|
|
+ id, exists := m.ID()
|
|
|
+ if exists {
|
|
|
+ return []uint64{id}, nil
|
|
|
+ }
|
|
|
+ fallthrough
|
|
|
+ case m.op.Is(OpUpdate | OpDelete):
|
|
|
+ return m.Client().Label.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 *LabelMutation) SetCreatedAt(t time.Time) {
|
|
|
+ m.created_at = &t
|
|
|
+}
|
|
|
+
|
|
|
+// CreatedAt returns the value of the "created_at" field in the mutation.
|
|
|
+func (m *LabelMutation) 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 Label entity.
|
|
|
+// If the Label 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 *LabelMutation) 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 *LabelMutation) ResetCreatedAt() {
|
|
|
+ m.created_at = nil
|
|
|
+}
|
|
|
+
|
|
|
+// SetUpdatedAt sets the "updated_at" field.
|
|
|
+func (m *LabelMutation) SetUpdatedAt(t time.Time) {
|
|
|
+ m.updated_at = &t
|
|
|
+}
|
|
|
+
|
|
|
+// UpdatedAt returns the value of the "updated_at" field in the mutation.
|
|
|
+func (m *LabelMutation) 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 Label entity.
|
|
|
+// If the Label 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 *LabelMutation) 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
|
|
|
+}
|
|
|
+
|
|
|
+// ResetUpdatedAt resets all changes to the "updated_at" field.
|
|
|
+func (m *LabelMutation) ResetUpdatedAt() {
|
|
|
+ m.updated_at = nil
|
|
|
+}
|
|
|
+
|
|
|
+// SetStatus sets the "status" field.
|
|
|
+func (m *LabelMutation) SetStatus(u uint8) {
|
|
|
+ m.status = &u
|
|
|
+ m.addstatus = nil
|
|
|
+}
|
|
|
+
|
|
|
+// Status returns the value of the "status" field in the mutation.
|
|
|
+func (m *LabelMutation) Status() (r uint8, exists bool) {
|
|
|
+ v := m.status
|
|
|
+ if v == nil {
|
|
|
+ return
|
|
|
+ }
|
|
|
+ return *v, true
|
|
|
+}
|
|
|
+
|
|
|
+// OldStatus returns the old "status" field's value of the Label entity.
|
|
|
+// If the Label 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 *LabelMutation) OldStatus(ctx context.Context) (v uint8, 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
|
|
|
+}
|
|
|
+
|
|
|
+// AddStatus adds u to the "status" field.
|
|
|
+func (m *LabelMutation) AddStatus(u int8) {
|
|
|
+ if m.addstatus != nil {
|
|
|
+ *m.addstatus += u
|
|
|
+ } else {
|
|
|
+ m.addstatus = &u
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+// AddedStatus returns the value that was added to the "status" field in this mutation.
|
|
|
+func (m *LabelMutation) AddedStatus() (r int8, exists bool) {
|
|
|
+ v := m.addstatus
|
|
|
+ if v == nil {
|
|
|
+ return
|
|
|
+ }
|
|
|
+ return *v, true
|
|
|
+}
|
|
|
+
|
|
|
+// ClearStatus clears the value of the "status" field.
|
|
|
+func (m *LabelMutation) ClearStatus() {
|
|
|
+ m.status = nil
|
|
|
+ m.addstatus = nil
|
|
|
+ m.clearedFields[label.FieldStatus] = struct{}{}
|
|
|
+}
|
|
|
+
|
|
|
+// StatusCleared returns if the "status" field was cleared in this mutation.
|
|
|
+func (m *LabelMutation) StatusCleared() bool {
|
|
|
+ _, ok := m.clearedFields[label.FieldStatus]
|
|
|
+ return ok
|
|
|
+}
|
|
|
+
|
|
|
+// ResetStatus resets all changes to the "status" field.
|
|
|
+func (m *LabelMutation) ResetStatus() {
|
|
|
+ m.status = nil
|
|
|
+ m.addstatus = nil
|
|
|
+ delete(m.clearedFields, label.FieldStatus)
|
|
|
+}
|
|
|
+
|
|
|
+// SetDeletedAt sets the "deleted_at" field.
|
|
|
+func (m *LabelMutation) SetDeletedAt(t time.Time) {
|
|
|
+ m.deleted_at = &t
|
|
|
+}
|
|
|
+
|
|
|
+// DeletedAt returns the value of the "deleted_at" field in the mutation.
|
|
|
+func (m *LabelMutation) DeletedAt() (r time.Time, exists bool) {
|
|
|
+ v := m.deleted_at
|
|
|
+ if v == nil {
|
|
|
+ return
|
|
|
+ }
|
|
|
+ return *v, true
|
|
|
+}
|
|
|
+
|
|
|
+// OldDeletedAt returns the old "deleted_at" field's value of the Label entity.
|
|
|
+// If the Label 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 *LabelMutation) OldDeletedAt(ctx context.Context) (v time.Time, err error) {
|
|
|
+ if !m.op.Is(OpUpdateOne) {
|
|
|
+ return v, errors.New("OldDeletedAt is only allowed on UpdateOne operations")
|
|
|
+ }
|
|
|
+ if m.id == nil || m.oldValue == nil {
|
|
|
+ return v, errors.New("OldDeletedAt requires an ID field in the mutation")
|
|
|
+ }
|
|
|
+ oldValue, err := m.oldValue(ctx)
|
|
|
+ if err != nil {
|
|
|
+ return v, fmt.Errorf("querying old value for OldDeletedAt: %w", err)
|
|
|
+ }
|
|
|
+ return oldValue.DeletedAt, nil
|
|
|
+}
|
|
|
+
|
|
|
+// ClearDeletedAt clears the value of the "deleted_at" field.
|
|
|
+func (m *LabelMutation) ClearDeletedAt() {
|
|
|
+ m.deleted_at = nil
|
|
|
+ m.clearedFields[label.FieldDeletedAt] = struct{}{}
|
|
|
+}
|
|
|
+
|
|
|
+// DeletedAtCleared returns if the "deleted_at" field was cleared in this mutation.
|
|
|
+func (m *LabelMutation) DeletedAtCleared() bool {
|
|
|
+ _, ok := m.clearedFields[label.FieldDeletedAt]
|
|
|
+ return ok
|
|
|
+}
|
|
|
+
|
|
|
+// ResetDeletedAt resets all changes to the "deleted_at" field.
|
|
|
+func (m *LabelMutation) ResetDeletedAt() {
|
|
|
+ m.deleted_at = nil
|
|
|
+ delete(m.clearedFields, label.FieldDeletedAt)
|
|
|
+}
|
|
|
+
|
|
|
+// SetType sets the "type" field.
|
|
|
+func (m *LabelMutation) SetType(i int) {
|
|
|
+ m._type = &i
|
|
|
+ m.add_type = nil
|
|
|
+}
|
|
|
+
|
|
|
+// GetType returns the value of the "type" field in the mutation.
|
|
|
+func (m *LabelMutation) GetType() (r int, exists bool) {
|
|
|
+ v := m._type
|
|
|
+ if v == nil {
|
|
|
+ return
|
|
|
+ }
|
|
|
+ return *v, true
|
|
|
+}
|
|
|
+
|
|
|
+// OldType returns the old "type" field's value of the Label entity.
|
|
|
+// If the Label 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 *LabelMutation) OldType(ctx context.Context) (v int, 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
|
|
|
+}
|
|
|
+
|
|
|
+// AddType adds i to the "type" field.
|
|
|
+func (m *LabelMutation) AddType(i int) {
|
|
|
+ if m.add_type != nil {
|
|
|
+ *m.add_type += i
|
|
|
+ } else {
|
|
|
+ m.add_type = &i
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+// AddedType returns the value that was added to the "type" field in this mutation.
|
|
|
+func (m *LabelMutation) AddedType() (r int, exists bool) {
|
|
|
+ v := m.add_type
|
|
|
+ if v == nil {
|
|
|
+ return
|
|
|
+ }
|
|
|
+ return *v, true
|
|
|
+}
|
|
|
+
|
|
|
+// ResetType resets all changes to the "type" field.
|
|
|
+func (m *LabelMutation) ResetType() {
|
|
|
+ m._type = nil
|
|
|
+ m.add_type = nil
|
|
|
+}
|
|
|
+
|
|
|
+// SetName sets the "name" field.
|
|
|
+func (m *LabelMutation) SetName(s string) {
|
|
|
+ m.name = &s
|
|
|
+}
|
|
|
+
|
|
|
+// Name returns the value of the "name" field in the mutation.
|
|
|
+func (m *LabelMutation) 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 Label entity.
|
|
|
+// If the Label 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 *LabelMutation) 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 *LabelMutation) ResetName() {
|
|
|
+ m.name = nil
|
|
|
+}
|
|
|
+
|
|
|
+// SetFrom sets the "from" field.
|
|
|
+func (m *LabelMutation) SetFrom(i int) {
|
|
|
+ m.from = &i
|
|
|
+ m.addfrom = nil
|
|
|
+}
|
|
|
+
|
|
|
+// From returns the value of the "from" field in the mutation.
|
|
|
+func (m *LabelMutation) From() (r int, exists bool) {
|
|
|
+ v := m.from
|
|
|
+ if v == nil {
|
|
|
+ return
|
|
|
+ }
|
|
|
+ return *v, true
|
|
|
+}
|
|
|
+
|
|
|
+// OldFrom returns the old "from" field's value of the Label entity.
|
|
|
+// If the Label 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 *LabelMutation) OldFrom(ctx context.Context) (v int, err error) {
|
|
|
+ if !m.op.Is(OpUpdateOne) {
|
|
|
+ return v, errors.New("OldFrom is only allowed on UpdateOne operations")
|
|
|
+ }
|
|
|
+ if m.id == nil || m.oldValue == nil {
|
|
|
+ return v, errors.New("OldFrom requires an ID field in the mutation")
|
|
|
+ }
|
|
|
+ oldValue, err := m.oldValue(ctx)
|
|
|
+ if err != nil {
|
|
|
+ return v, fmt.Errorf("querying old value for OldFrom: %w", err)
|
|
|
+ }
|
|
|
+ return oldValue.From, nil
|
|
|
+}
|
|
|
+
|
|
|
+// AddFrom adds i to the "from" field.
|
|
|
+func (m *LabelMutation) AddFrom(i int) {
|
|
|
+ if m.addfrom != nil {
|
|
|
+ *m.addfrom += i
|
|
|
+ } else {
|
|
|
+ m.addfrom = &i
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+// AddedFrom returns the value that was added to the "from" field in this mutation.
|
|
|
+func (m *LabelMutation) AddedFrom() (r int, exists bool) {
|
|
|
+ v := m.addfrom
|
|
|
+ if v == nil {
|
|
|
+ return
|
|
|
+ }
|
|
|
+ return *v, true
|
|
|
+}
|
|
|
+
|
|
|
+// ResetFrom resets all changes to the "from" field.
|
|
|
+func (m *LabelMutation) ResetFrom() {
|
|
|
+ m.from = nil
|
|
|
+ m.addfrom = nil
|
|
|
+}
|
|
|
+
|
|
|
+// SetMode sets the "mode" field.
|
|
|
+func (m *LabelMutation) SetMode(i int) {
|
|
|
+ m.mode = &i
|
|
|
+ m.addmode = nil
|
|
|
+}
|
|
|
+
|
|
|
+// Mode returns the value of the "mode" field in the mutation.
|
|
|
+func (m *LabelMutation) Mode() (r int, exists bool) {
|
|
|
+ v := m.mode
|
|
|
+ if v == nil {
|
|
|
+ return
|
|
|
+ }
|
|
|
+ return *v, true
|
|
|
+}
|
|
|
+
|
|
|
+// OldMode returns the old "mode" field's value of the Label entity.
|
|
|
+// If the Label 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 *LabelMutation) OldMode(ctx context.Context) (v int, err error) {
|
|
|
+ if !m.op.Is(OpUpdateOne) {
|
|
|
+ return v, errors.New("OldMode is only allowed on UpdateOne operations")
|
|
|
+ }
|
|
|
+ if m.id == nil || m.oldValue == nil {
|
|
|
+ return v, errors.New("OldMode requires an ID field in the mutation")
|
|
|
+ }
|
|
|
+ oldValue, err := m.oldValue(ctx)
|
|
|
+ if err != nil {
|
|
|
+ return v, fmt.Errorf("querying old value for OldMode: %w", err)
|
|
|
+ }
|
|
|
+ return oldValue.Mode, nil
|
|
|
+}
|
|
|
+
|
|
|
+// AddMode adds i to the "mode" field.
|
|
|
+func (m *LabelMutation) AddMode(i int) {
|
|
|
+ if m.addmode != nil {
|
|
|
+ *m.addmode += i
|
|
|
+ } else {
|
|
|
+ m.addmode = &i
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+// AddedMode returns the value that was added to the "mode" field in this mutation.
|
|
|
+func (m *LabelMutation) AddedMode() (r int, exists bool) {
|
|
|
+ v := m.addmode
|
|
|
+ if v == nil {
|
|
|
+ return
|
|
|
+ }
|
|
|
+ return *v, true
|
|
|
+}
|
|
|
+
|
|
|
+// ResetMode resets all changes to the "mode" field.
|
|
|
+func (m *LabelMutation) ResetMode() {
|
|
|
+ m.mode = nil
|
|
|
+ m.addmode = nil
|
|
|
+}
|
|
|
+
|
|
|
+// SetConditions sets the "conditions" field.
|
|
|
+func (m *LabelMutation) SetConditions(s string) {
|
|
|
+ m.conditions = &s
|
|
|
+}
|
|
|
+
|
|
|
+// Conditions returns the value of the "conditions" field in the mutation.
|
|
|
+func (m *LabelMutation) Conditions() (r string, exists bool) {
|
|
|
+ v := m.conditions
|
|
|
+ if v == nil {
|
|
|
+ return
|
|
|
+ }
|
|
|
+ return *v, true
|
|
|
+}
|
|
|
+
|
|
|
+// OldConditions returns the old "conditions" field's value of the Label entity.
|
|
|
+// If the Label 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 *LabelMutation) OldConditions(ctx context.Context) (v string, err error) {
|
|
|
+ if !m.op.Is(OpUpdateOne) {
|
|
|
+ return v, errors.New("OldConditions is only allowed on UpdateOne operations")
|
|
|
+ }
|
|
|
+ if m.id == nil || m.oldValue == nil {
|
|
|
+ return v, errors.New("OldConditions requires an ID field in the mutation")
|
|
|
+ }
|
|
|
+ oldValue, err := m.oldValue(ctx)
|
|
|
+ if err != nil {
|
|
|
+ return v, fmt.Errorf("querying old value for OldConditions: %w", err)
|
|
|
+ }
|
|
|
+ return oldValue.Conditions, nil
|
|
|
+}
|
|
|
+
|
|
|
+// ClearConditions clears the value of the "conditions" field.
|
|
|
+func (m *LabelMutation) ClearConditions() {
|
|
|
+ m.conditions = nil
|
|
|
+ m.clearedFields[label.FieldConditions] = struct{}{}
|
|
|
+}
|
|
|
+
|
|
|
+// ConditionsCleared returns if the "conditions" field was cleared in this mutation.
|
|
|
+func (m *LabelMutation) ConditionsCleared() bool {
|
|
|
+ _, ok := m.clearedFields[label.FieldConditions]
|
|
|
+ return ok
|
|
|
+}
|
|
|
+
|
|
|
+// ResetConditions resets all changes to the "conditions" field.
|
|
|
+func (m *LabelMutation) ResetConditions() {
|
|
|
+ m.conditions = nil
|
|
|
+ delete(m.clearedFields, label.FieldConditions)
|
|
|
+}
|
|
|
+
|
|
|
+// AddLabelRelationshipIDs adds the "label_relationships" edge to the LabelRelationship entity by ids.
|
|
|
+func (m *LabelMutation) AddLabelRelationshipIDs(ids ...uint64) {
|
|
|
+ if m.label_relationships == nil {
|
|
|
+ m.label_relationships = make(map[uint64]struct{})
|
|
|
+ }
|
|
|
+ for i := range ids {
|
|
|
+ m.label_relationships[ids[i]] = struct{}{}
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+// ClearLabelRelationships clears the "label_relationships" edge to the LabelRelationship entity.
|
|
|
+func (m *LabelMutation) ClearLabelRelationships() {
|
|
|
+ m.clearedlabel_relationships = true
|
|
|
+}
|
|
|
+
|
|
|
+// LabelRelationshipsCleared reports if the "label_relationships" edge to the LabelRelationship entity was cleared.
|
|
|
+func (m *LabelMutation) LabelRelationshipsCleared() bool {
|
|
|
+ return m.clearedlabel_relationships
|
|
|
+}
|
|
|
+
|
|
|
+// RemoveLabelRelationshipIDs removes the "label_relationships" edge to the LabelRelationship entity by IDs.
|
|
|
+func (m *LabelMutation) RemoveLabelRelationshipIDs(ids ...uint64) {
|
|
|
+ if m.removedlabel_relationships == nil {
|
|
|
+ m.removedlabel_relationships = make(map[uint64]struct{})
|
|
|
+ }
|
|
|
+ for i := range ids {
|
|
|
+ delete(m.label_relationships, ids[i])
|
|
|
+ m.removedlabel_relationships[ids[i]] = struct{}{}
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+// RemovedLabelRelationships returns the removed IDs of the "label_relationships" edge to the LabelRelationship entity.
|
|
|
+func (m *LabelMutation) RemovedLabelRelationshipsIDs() (ids []uint64) {
|
|
|
+ for id := range m.removedlabel_relationships {
|
|
|
+ ids = append(ids, id)
|
|
|
+ }
|
|
|
+ return
|
|
|
+}
|
|
|
+
|
|
|
+// LabelRelationshipsIDs returns the "label_relationships" edge IDs in the mutation.
|
|
|
+func (m *LabelMutation) LabelRelationshipsIDs() (ids []uint64) {
|
|
|
+ for id := range m.label_relationships {
|
|
|
+ ids = append(ids, id)
|
|
|
+ }
|
|
|
+ return
|
|
|
+}
|
|
|
+
|
|
|
+// ResetLabelRelationships resets all changes to the "label_relationships" edge.
|
|
|
+func (m *LabelMutation) ResetLabelRelationships() {
|
|
|
+ m.label_relationships = nil
|
|
|
+ m.clearedlabel_relationships = false
|
|
|
+ m.removedlabel_relationships = nil
|
|
|
+}
|
|
|
+
|
|
|
+// Where appends a list predicates to the LabelMutation builder.
|
|
|
+func (m *LabelMutation) Where(ps ...predicate.Label) {
|
|
|
+ m.predicates = append(m.predicates, ps...)
|
|
|
+}
|
|
|
+
|
|
|
+// WhereP appends storage-level predicates to the LabelMutation builder. Using this method,
|
|
|
+// users can use type-assertion to append predicates that do not depend on any generated package.
|
|
|
+func (m *LabelMutation) WhereP(ps ...func(*sql.Selector)) {
|
|
|
+ p := make([]predicate.Label, len(ps))
|
|
|
+ for i := range ps {
|
|
|
+ p[i] = ps[i]
|
|
|
+ }
|
|
|
+ m.Where(p...)
|
|
|
+}
|
|
|
+
|
|
|
+// Op returns the operation name.
|
|
|
+func (m *LabelMutation) Op() Op {
|
|
|
+ return m.op
|
|
|
+}
|
|
|
+
|
|
|
+// SetOp allows setting the mutation operation.
|
|
|
+func (m *LabelMutation) SetOp(op Op) {
|
|
|
+ m.op = op
|
|
|
+}
|
|
|
+
|
|
|
+// Type returns the node type of this mutation (Label).
|
|
|
+func (m *LabelMutation) 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 *LabelMutation) Fields() []string {
|
|
|
+ fields := make([]string, 0, 9)
|
|
|
+ if m.created_at != nil {
|
|
|
+ fields = append(fields, label.FieldCreatedAt)
|
|
|
+ }
|
|
|
+ if m.updated_at != nil {
|
|
|
+ fields = append(fields, label.FieldUpdatedAt)
|
|
|
+ }
|
|
|
+ if m.status != nil {
|
|
|
+ fields = append(fields, label.FieldStatus)
|
|
|
+ }
|
|
|
+ if m.deleted_at != nil {
|
|
|
+ fields = append(fields, label.FieldDeletedAt)
|
|
|
+ }
|
|
|
+ if m._type != nil {
|
|
|
+ fields = append(fields, label.FieldType)
|
|
|
+ }
|
|
|
+ if m.name != nil {
|
|
|
+ fields = append(fields, label.FieldName)
|
|
|
+ }
|
|
|
+ if m.from != nil {
|
|
|
+ fields = append(fields, label.FieldFrom)
|
|
|
+ }
|
|
|
+ if m.mode != nil {
|
|
|
+ fields = append(fields, label.FieldMode)
|
|
|
+ }
|
|
|
+ if m.conditions != nil {
|
|
|
+ fields = append(fields, label.FieldConditions)
|
|
|
+ }
|
|
|
+ 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 *LabelMutation) Field(name string) (ent.Value, bool) {
|
|
|
+ switch name {
|
|
|
+ case label.FieldCreatedAt:
|
|
|
+ return m.CreatedAt()
|
|
|
+ case label.FieldUpdatedAt:
|
|
|
+ return m.UpdatedAt()
|
|
|
+ case label.FieldStatus:
|
|
|
+ return m.Status()
|
|
|
+ case label.FieldDeletedAt:
|
|
|
+ return m.DeletedAt()
|
|
|
+ case label.FieldType:
|
|
|
+ return m.GetType()
|
|
|
+ case label.FieldName:
|
|
|
+ return m.Name()
|
|
|
+ case label.FieldFrom:
|
|
|
+ return m.From()
|
|
|
+ case label.FieldMode:
|
|
|
+ return m.Mode()
|
|
|
+ case label.FieldConditions:
|
|
|
+ return m.Conditions()
|
|
|
+ }
|
|
|
+ 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 *LabelMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
|
|
|
+ switch name {
|
|
|
+ case label.FieldCreatedAt:
|
|
|
+ return m.OldCreatedAt(ctx)
|
|
|
+ case label.FieldUpdatedAt:
|
|
|
+ return m.OldUpdatedAt(ctx)
|
|
|
+ case label.FieldStatus:
|
|
|
+ return m.OldStatus(ctx)
|
|
|
+ case label.FieldDeletedAt:
|
|
|
+ return m.OldDeletedAt(ctx)
|
|
|
+ case label.FieldType:
|
|
|
+ return m.OldType(ctx)
|
|
|
+ case label.FieldName:
|
|
|
+ return m.OldName(ctx)
|
|
|
+ case label.FieldFrom:
|
|
|
+ return m.OldFrom(ctx)
|
|
|
+ case label.FieldMode:
|
|
|
+ return m.OldMode(ctx)
|
|
|
+ case label.FieldConditions:
|
|
|
+ return m.OldConditions(ctx)
|
|
|
+ }
|
|
|
+ return nil, fmt.Errorf("unknown Label 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 *LabelMutation) SetField(name string, value ent.Value) error {
|
|
|
+ switch name {
|
|
|
+ case label.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 label.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 label.FieldStatus:
|
|
|
+ v, ok := value.(uint8)
|
|
|
+ if !ok {
|
|
|
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
|
+ }
|
|
|
+ m.SetStatus(v)
|
|
|
+ return nil
|
|
|
+ case label.FieldDeletedAt:
|
|
|
+ v, ok := value.(time.Time)
|
|
|
+ if !ok {
|
|
|
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
|
+ }
|
|
|
+ m.SetDeletedAt(v)
|
|
|
+ return nil
|
|
|
+ case label.FieldType:
|
|
|
+ v, ok := value.(int)
|
|
|
+ if !ok {
|
|
|
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
|
+ }
|
|
|
+ m.SetType(v)
|
|
|
+ return nil
|
|
|
+ case label.FieldName:
|
|
|
+ v, ok := value.(string)
|
|
|
+ if !ok {
|
|
|
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
|
+ }
|
|
|
+ m.SetName(v)
|
|
|
+ return nil
|
|
|
+ case label.FieldFrom:
|
|
|
+ v, ok := value.(int)
|
|
|
+ if !ok {
|
|
|
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
|
+ }
|
|
|
+ m.SetFrom(v)
|
|
|
+ return nil
|
|
|
+ case label.FieldMode:
|
|
|
+ v, ok := value.(int)
|
|
|
+ if !ok {
|
|
|
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
|
+ }
|
|
|
+ m.SetMode(v)
|
|
|
+ return nil
|
|
|
+ case label.FieldConditions:
|
|
|
+ v, ok := value.(string)
|
|
|
+ if !ok {
|
|
|
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
|
+ }
|
|
|
+ m.SetConditions(v)
|
|
|
+ return nil
|
|
|
+ }
|
|
|
+ return fmt.Errorf("unknown Label field %s", name)
|
|
|
+}
|
|
|
+
|
|
|
+// AddedFields returns all numeric fields that were incremented/decremented during
|
|
|
+// this mutation.
|
|
|
+func (m *LabelMutation) AddedFields() []string {
|
|
|
+ var fields []string
|
|
|
+ if m.addstatus != nil {
|
|
|
+ fields = append(fields, label.FieldStatus)
|
|
|
+ }
|
|
|
+ if m.add_type != nil {
|
|
|
+ fields = append(fields, label.FieldType)
|
|
|
+ }
|
|
|
+ if m.addfrom != nil {
|
|
|
+ fields = append(fields, label.FieldFrom)
|
|
|
+ }
|
|
|
+ if m.addmode != nil {
|
|
|
+ fields = append(fields, label.FieldMode)
|
|
|
+ }
|
|
|
+ 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 *LabelMutation) AddedField(name string) (ent.Value, bool) {
|
|
|
+ switch name {
|
|
|
+ case label.FieldStatus:
|
|
|
+ return m.AddedStatus()
|
|
|
+ case label.FieldType:
|
|
|
+ return m.AddedType()
|
|
|
+ case label.FieldFrom:
|
|
|
+ return m.AddedFrom()
|
|
|
+ case label.FieldMode:
|
|
|
+ return m.AddedMode()
|
|
|
+ }
|
|
|
+ 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 *LabelMutation) AddField(name string, value ent.Value) error {
|
|
|
+ switch name {
|
|
|
+ case label.FieldStatus:
|
|
|
+ v, ok := value.(int8)
|
|
|
+ if !ok {
|
|
|
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
|
+ }
|
|
|
+ m.AddStatus(v)
|
|
|
+ return nil
|
|
|
+ case label.FieldType:
|
|
|
+ v, ok := value.(int)
|
|
|
+ if !ok {
|
|
|
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
|
+ }
|
|
|
+ m.AddType(v)
|
|
|
+ return nil
|
|
|
+ case label.FieldFrom:
|
|
|
+ v, ok := value.(int)
|
|
|
+ if !ok {
|
|
|
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
|
+ }
|
|
|
+ m.AddFrom(v)
|
|
|
+ return nil
|
|
|
+ case label.FieldMode:
|
|
|
+ v, ok := value.(int)
|
|
|
+ if !ok {
|
|
|
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
|
+ }
|
|
|
+ m.AddMode(v)
|
|
|
+ return nil
|
|
|
+ }
|
|
|
+ return fmt.Errorf("unknown Label numeric field %s", name)
|
|
|
+}
|
|
|
+
|
|
|
+// ClearedFields returns all nullable fields that were cleared during this
|
|
|
+// mutation.
|
|
|
+func (m *LabelMutation) ClearedFields() []string {
|
|
|
+ var fields []string
|
|
|
+ if m.FieldCleared(label.FieldStatus) {
|
|
|
+ fields = append(fields, label.FieldStatus)
|
|
|
+ }
|
|
|
+ if m.FieldCleared(label.FieldDeletedAt) {
|
|
|
+ fields = append(fields, label.FieldDeletedAt)
|
|
|
+ }
|
|
|
+ if m.FieldCleared(label.FieldConditions) {
|
|
|
+ fields = append(fields, label.FieldConditions)
|
|
|
+ }
|
|
|
+ return fields
|
|
|
+}
|
|
|
+
|
|
|
+// FieldCleared returns a boolean indicating if a field with the given name was
|
|
|
+// cleared in this mutation.
|
|
|
+func (m *LabelMutation) 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 *LabelMutation) ClearField(name string) error {
|
|
|
+ switch name {
|
|
|
+ case label.FieldStatus:
|
|
|
+ m.ClearStatus()
|
|
|
+ return nil
|
|
|
+ case label.FieldDeletedAt:
|
|
|
+ m.ClearDeletedAt()
|
|
|
+ return nil
|
|
|
+ case label.FieldConditions:
|
|
|
+ m.ClearConditions()
|
|
|
+ return nil
|
|
|
+ }
|
|
|
+ return fmt.Errorf("unknown Label 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 *LabelMutation) ResetField(name string) error {
|
|
|
+ switch name {
|
|
|
+ case label.FieldCreatedAt:
|
|
|
+ m.ResetCreatedAt()
|
|
|
+ return nil
|
|
|
+ case label.FieldUpdatedAt:
|
|
|
+ m.ResetUpdatedAt()
|
|
|
+ return nil
|
|
|
+ case label.FieldStatus:
|
|
|
+ m.ResetStatus()
|
|
|
+ return nil
|
|
|
+ case label.FieldDeletedAt:
|
|
|
+ m.ResetDeletedAt()
|
|
|
+ return nil
|
|
|
+ case label.FieldType:
|
|
|
+ m.ResetType()
|
|
|
+ return nil
|
|
|
+ case label.FieldName:
|
|
|
+ m.ResetName()
|
|
|
+ return nil
|
|
|
+ case label.FieldFrom:
|
|
|
+ m.ResetFrom()
|
|
|
+ return nil
|
|
|
+ case label.FieldMode:
|
|
|
+ m.ResetMode()
|
|
|
+ return nil
|
|
|
+ case label.FieldConditions:
|
|
|
+ m.ResetConditions()
|
|
|
+ return nil
|
|
|
+ }
|
|
|
+ return fmt.Errorf("unknown Label field %s", name)
|
|
|
+}
|
|
|
+
|
|
|
+// AddedEdges returns all edge names that were set/added in this mutation.
|
|
|
+func (m *LabelMutation) AddedEdges() []string {
|
|
|
+ edges := make([]string, 0, 1)
|
|
|
+ if m.label_relationships != nil {
|
|
|
+ edges = append(edges, label.EdgeLabelRelationships)
|
|
|
+ }
|
|
|
+ return edges
|
|
|
+}
|
|
|
+
|
|
|
+// AddedIDs returns all IDs (to other nodes) that were added for the given edge
|
|
|
+// name in this mutation.
|
|
|
+func (m *LabelMutation) AddedIDs(name string) []ent.Value {
|
|
|
+ switch name {
|
|
|
+ case label.EdgeLabelRelationships:
|
|
|
+ ids := make([]ent.Value, 0, len(m.label_relationships))
|
|
|
+ for id := range m.label_relationships {
|
|
|
+ ids = append(ids, id)
|
|
|
+ }
|
|
|
+ return ids
|
|
|
+ }
|
|
|
+ return nil
|
|
|
+}
|
|
|
+
|
|
|
+// RemovedEdges returns all edge names that were removed in this mutation.
|
|
|
+func (m *LabelMutation) RemovedEdges() []string {
|
|
|
+ edges := make([]string, 0, 1)
|
|
|
+ if m.removedlabel_relationships != nil {
|
|
|
+ edges = append(edges, label.EdgeLabelRelationships)
|
|
|
+ }
|
|
|
+ return edges
|
|
|
+}
|
|
|
+
|
|
|
+// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
|
|
|
+// the given name in this mutation.
|
|
|
+func (m *LabelMutation) RemovedIDs(name string) []ent.Value {
|
|
|
+ switch name {
|
|
|
+ case label.EdgeLabelRelationships:
|
|
|
+ ids := make([]ent.Value, 0, len(m.removedlabel_relationships))
|
|
|
+ for id := range m.removedlabel_relationships {
|
|
|
+ ids = append(ids, id)
|
|
|
+ }
|
|
|
+ return ids
|
|
|
+ }
|
|
|
+ return nil
|
|
|
+}
|
|
|
+
|
|
|
+// ClearedEdges returns all edge names that were cleared in this mutation.
|
|
|
+func (m *LabelMutation) ClearedEdges() []string {
|
|
|
+ edges := make([]string, 0, 1)
|
|
|
+ if m.clearedlabel_relationships {
|
|
|
+ edges = append(edges, label.EdgeLabelRelationships)
|
|
|
+ }
|
|
|
+ return edges
|
|
|
+}
|
|
|
+
|
|
|
+// EdgeCleared returns a boolean which indicates if the edge with the given name
|
|
|
+// was cleared in this mutation.
|
|
|
+func (m *LabelMutation) EdgeCleared(name string) bool {
|
|
|
+ switch name {
|
|
|
+ case label.EdgeLabelRelationships:
|
|
|
+ return m.clearedlabel_relationships
|
|
|
+ }
|
|
|
+ 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 *LabelMutation) ClearEdge(name string) error {
|
|
|
+ switch name {
|
|
|
+ }
|
|
|
+ return fmt.Errorf("unknown Label 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 *LabelMutation) ResetEdge(name string) error {
|
|
|
+ switch name {
|
|
|
+ case label.EdgeLabelRelationships:
|
|
|
+ m.ResetLabelRelationships()
|
|
|
+ return nil
|
|
|
+ }
|
|
|
+ return fmt.Errorf("unknown Label edge %s", name)
|
|
|
+}
|
|
|
+
|
|
|
+// LabelRelationshipMutation represents an operation that mutates the LabelRelationship nodes in the graph.
|
|
|
+type LabelRelationshipMutation struct {
|
|
|
+ config
|
|
|
+ op Op
|
|
|
+ typ string
|
|
|
+ id *uint64
|
|
|
+ created_at *time.Time
|
|
|
+ updated_at *time.Time
|
|
|
+ status *uint8
|
|
|
+ addstatus *int8
|
|
|
+ deleted_at *time.Time
|
|
|
+ clearedFields map[string]struct{}
|
|
|
+ contacts *uint64
|
|
|
+ clearedcontacts bool
|
|
|
+ labels *uint64
|
|
|
+ clearedlabels bool
|
|
|
+ done bool
|
|
|
+ oldValue func(context.Context) (*LabelRelationship, error)
|
|
|
+ predicates []predicate.LabelRelationship
|
|
|
+}
|
|
|
+
|
|
|
+var _ ent.Mutation = (*LabelRelationshipMutation)(nil)
|
|
|
+
|
|
|
+// labelrelationshipOption allows management of the mutation configuration using functional options.
|
|
|
+type labelrelationshipOption func(*LabelRelationshipMutation)
|
|
|
+
|
|
|
+// newLabelRelationshipMutation creates new mutation for the LabelRelationship entity.
|
|
|
+func newLabelRelationshipMutation(c config, op Op, opts ...labelrelationshipOption) *LabelRelationshipMutation {
|
|
|
+ m := &LabelRelationshipMutation{
|
|
|
+ config: c,
|
|
|
+ op: op,
|
|
|
+ typ: TypeLabelRelationship,
|
|
|
+ clearedFields: make(map[string]struct{}),
|
|
|
+ }
|
|
|
+ for _, opt := range opts {
|
|
|
+ opt(m)
|
|
|
+ }
|
|
|
+ return m
|
|
|
+}
|
|
|
+
|
|
|
+// withLabelRelationshipID sets the ID field of the mutation.
|
|
|
+func withLabelRelationshipID(id uint64) labelrelationshipOption {
|
|
|
+ return func(m *LabelRelationshipMutation) {
|
|
|
+ var (
|
|
|
+ err error
|
|
|
+ once sync.Once
|
|
|
+ value *LabelRelationship
|
|
|
+ )
|
|
|
+ m.oldValue = func(ctx context.Context) (*LabelRelationship, error) {
|
|
|
+ once.Do(func() {
|
|
|
+ if m.done {
|
|
|
+ err = errors.New("querying old values post mutation is not allowed")
|
|
|
+ } else {
|
|
|
+ value, err = m.Client().LabelRelationship.Get(ctx, id)
|
|
|
+ }
|
|
|
+ })
|
|
|
+ return value, err
|
|
|
+ }
|
|
|
+ m.id = &id
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+// withLabelRelationship sets the old LabelRelationship of the mutation.
|
|
|
+func withLabelRelationship(node *LabelRelationship) labelrelationshipOption {
|
|
|
+ return func(m *LabelRelationshipMutation) {
|
|
|
+ m.oldValue = func(context.Context) (*LabelRelationship, 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 LabelRelationshipMutation) 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 LabelRelationshipMutation) 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
|
|
|
+}
|
|
|
+
|
|
|
+// SetID sets the value of the id field. Note that this
|
|
|
+// operation is only accepted on creation of LabelRelationship entities.
|
|
|
+func (m *LabelRelationshipMutation) SetID(id uint64) {
|
|
|
+ m.id = &id
|
|
|
+}
|
|
|
+
|
|
|
+// 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 *LabelRelationshipMutation) ID() (id uint64, 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 *LabelRelationshipMutation) IDs(ctx context.Context) ([]uint64, error) {
|
|
|
+ switch {
|
|
|
+ case m.op.Is(OpUpdateOne | OpDeleteOne):
|
|
|
+ id, exists := m.ID()
|
|
|
+ if exists {
|
|
|
+ return []uint64{id}, nil
|
|
|
+ }
|
|
|
+ fallthrough
|
|
|
+ case m.op.Is(OpUpdate | OpDelete):
|
|
|
+ return m.Client().LabelRelationship.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 *LabelRelationshipMutation) SetCreatedAt(t time.Time) {
|
|
|
+ m.created_at = &t
|
|
|
+}
|
|
|
+
|
|
|
+// CreatedAt returns the value of the "created_at" field in the mutation.
|
|
|
+func (m *LabelRelationshipMutation) 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 LabelRelationship entity.
|
|
|
+// If the LabelRelationship 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 *LabelRelationshipMutation) 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 *LabelRelationshipMutation) ResetCreatedAt() {
|
|
|
+ m.created_at = nil
|
|
|
+}
|
|
|
+
|
|
|
+// SetUpdatedAt sets the "updated_at" field.
|
|
|
+func (m *LabelRelationshipMutation) SetUpdatedAt(t time.Time) {
|
|
|
+ m.updated_at = &t
|
|
|
+}
|
|
|
+
|
|
|
+// UpdatedAt returns the value of the "updated_at" field in the mutation.
|
|
|
+func (m *LabelRelationshipMutation) 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 LabelRelationship entity.
|
|
|
+// If the LabelRelationship 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 *LabelRelationshipMutation) 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
|
|
|
+}
|
|
|
+
|
|
|
+// ResetUpdatedAt resets all changes to the "updated_at" field.
|
|
|
+func (m *LabelRelationshipMutation) ResetUpdatedAt() {
|
|
|
+ m.updated_at = nil
|
|
|
+}
|
|
|
+
|
|
|
+// SetStatus sets the "status" field.
|
|
|
+func (m *LabelRelationshipMutation) SetStatus(u uint8) {
|
|
|
+ m.status = &u
|
|
|
+ m.addstatus = nil
|
|
|
+}
|
|
|
+
|
|
|
+// Status returns the value of the "status" field in the mutation.
|
|
|
+func (m *LabelRelationshipMutation) Status() (r uint8, exists bool) {
|
|
|
+ v := m.status
|
|
|
+ if v == nil {
|
|
|
+ return
|
|
|
+ }
|
|
|
+ return *v, true
|
|
|
+}
|
|
|
+
|
|
|
+// OldStatus returns the old "status" field's value of the LabelRelationship entity.
|
|
|
+// If the LabelRelationship 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 *LabelRelationshipMutation) OldStatus(ctx context.Context) (v uint8, 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
|
|
|
+}
|
|
|
+
|
|
|
+// AddStatus adds u to the "status" field.
|
|
|
+func (m *LabelRelationshipMutation) AddStatus(u int8) {
|
|
|
+ if m.addstatus != nil {
|
|
|
+ *m.addstatus += u
|
|
|
+ } else {
|
|
|
+ m.addstatus = &u
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+// AddedStatus returns the value that was added to the "status" field in this mutation.
|
|
|
+func (m *LabelRelationshipMutation) AddedStatus() (r int8, exists bool) {
|
|
|
+ v := m.addstatus
|
|
|
+ if v == nil {
|
|
|
+ return
|
|
|
+ }
|
|
|
+ return *v, true
|
|
|
+}
|
|
|
+
|
|
|
+// ClearStatus clears the value of the "status" field.
|
|
|
+func (m *LabelRelationshipMutation) ClearStatus() {
|
|
|
+ m.status = nil
|
|
|
+ m.addstatus = nil
|
|
|
+ m.clearedFields[labelrelationship.FieldStatus] = struct{}{}
|
|
|
+}
|
|
|
+
|
|
|
+// StatusCleared returns if the "status" field was cleared in this mutation.
|
|
|
+func (m *LabelRelationshipMutation) StatusCleared() bool {
|
|
|
+ _, ok := m.clearedFields[labelrelationship.FieldStatus]
|
|
|
+ return ok
|
|
|
+}
|
|
|
+
|
|
|
+// ResetStatus resets all changes to the "status" field.
|
|
|
+func (m *LabelRelationshipMutation) ResetStatus() {
|
|
|
+ m.status = nil
|
|
|
+ m.addstatus = nil
|
|
|
+ delete(m.clearedFields, labelrelationship.FieldStatus)
|
|
|
+}
|
|
|
+
|
|
|
+// SetDeletedAt sets the "deleted_at" field.
|
|
|
+func (m *LabelRelationshipMutation) SetDeletedAt(t time.Time) {
|
|
|
+ m.deleted_at = &t
|
|
|
+}
|
|
|
+
|
|
|
+// DeletedAt returns the value of the "deleted_at" field in the mutation.
|
|
|
+func (m *LabelRelationshipMutation) DeletedAt() (r time.Time, exists bool) {
|
|
|
+ v := m.deleted_at
|
|
|
+ if v == nil {
|
|
|
+ return
|
|
|
+ }
|
|
|
+ return *v, true
|
|
|
+}
|
|
|
+
|
|
|
+// OldDeletedAt returns the old "deleted_at" field's value of the LabelRelationship entity.
|
|
|
+// If the LabelRelationship 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 *LabelRelationshipMutation) OldDeletedAt(ctx context.Context) (v time.Time, err error) {
|
|
|
+ if !m.op.Is(OpUpdateOne) {
|
|
|
+ return v, errors.New("OldDeletedAt is only allowed on UpdateOne operations")
|
|
|
+ }
|
|
|
+ if m.id == nil || m.oldValue == nil {
|
|
|
+ return v, errors.New("OldDeletedAt requires an ID field in the mutation")
|
|
|
+ }
|
|
|
+ oldValue, err := m.oldValue(ctx)
|
|
|
+ if err != nil {
|
|
|
+ return v, fmt.Errorf("querying old value for OldDeletedAt: %w", err)
|
|
|
+ }
|
|
|
+ return oldValue.DeletedAt, nil
|
|
|
+}
|
|
|
+
|
|
|
+// ClearDeletedAt clears the value of the "deleted_at" field.
|
|
|
+func (m *LabelRelationshipMutation) ClearDeletedAt() {
|
|
|
+ m.deleted_at = nil
|
|
|
+ m.clearedFields[labelrelationship.FieldDeletedAt] = struct{}{}
|
|
|
+}
|
|
|
+
|
|
|
+// DeletedAtCleared returns if the "deleted_at" field was cleared in this mutation.
|
|
|
+func (m *LabelRelationshipMutation) DeletedAtCleared() bool {
|
|
|
+ _, ok := m.clearedFields[labelrelationship.FieldDeletedAt]
|
|
|
+ return ok
|
|
|
+}
|
|
|
+
|
|
|
+// ResetDeletedAt resets all changes to the "deleted_at" field.
|
|
|
+func (m *LabelRelationshipMutation) ResetDeletedAt() {
|
|
|
+ m.deleted_at = nil
|
|
|
+ delete(m.clearedFields, labelrelationship.FieldDeletedAt)
|
|
|
+}
|
|
|
+
|
|
|
+// SetLabelID sets the "label_id" field.
|
|
|
+func (m *LabelRelationshipMutation) SetLabelID(u uint64) {
|
|
|
+ m.labels = &u
|
|
|
+}
|
|
|
+
|
|
|
+// LabelID returns the value of the "label_id" field in the mutation.
|
|
|
+func (m *LabelRelationshipMutation) LabelID() (r uint64, exists bool) {
|
|
|
+ v := m.labels
|
|
|
+ if v == nil {
|
|
|
+ return
|
|
|
+ }
|
|
|
+ return *v, true
|
|
|
+}
|
|
|
+
|
|
|
+// OldLabelID returns the old "label_id" field's value of the LabelRelationship entity.
|
|
|
+// If the LabelRelationship 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 *LabelRelationshipMutation) OldLabelID(ctx context.Context) (v uint64, err error) {
|
|
|
+ if !m.op.Is(OpUpdateOne) {
|
|
|
+ return v, errors.New("OldLabelID is only allowed on UpdateOne operations")
|
|
|
+ }
|
|
|
+ if m.id == nil || m.oldValue == nil {
|
|
|
+ return v, errors.New("OldLabelID requires an ID field in the mutation")
|
|
|
+ }
|
|
|
+ oldValue, err := m.oldValue(ctx)
|
|
|
+ if err != nil {
|
|
|
+ return v, fmt.Errorf("querying old value for OldLabelID: %w", err)
|
|
|
+ }
|
|
|
+ return oldValue.LabelID, nil
|
|
|
+}
|
|
|
+
|
|
|
+// ResetLabelID resets all changes to the "label_id" field.
|
|
|
+func (m *LabelRelationshipMutation) ResetLabelID() {
|
|
|
+ m.labels = nil
|
|
|
+}
|
|
|
+
|
|
|
+// SetContactID sets the "contact_id" field.
|
|
|
+func (m *LabelRelationshipMutation) SetContactID(u uint64) {
|
|
|
+ m.contacts = &u
|
|
|
+}
|
|
|
+
|
|
|
+// ContactID returns the value of the "contact_id" field in the mutation.
|
|
|
+func (m *LabelRelationshipMutation) ContactID() (r uint64, exists bool) {
|
|
|
+ v := m.contacts
|
|
|
+ if v == nil {
|
|
|
+ return
|
|
|
+ }
|
|
|
+ return *v, true
|
|
|
+}
|
|
|
+
|
|
|
+// OldContactID returns the old "contact_id" field's value of the LabelRelationship entity.
|
|
|
+// If the LabelRelationship 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 *LabelRelationshipMutation) OldContactID(ctx context.Context) (v uint64, err error) {
|
|
|
+ if !m.op.Is(OpUpdateOne) {
|
|
|
+ return v, errors.New("OldContactID is only allowed on UpdateOne operations")
|
|
|
+ }
|
|
|
+ if m.id == nil || m.oldValue == nil {
|
|
|
+ return v, errors.New("OldContactID requires an ID field in the mutation")
|
|
|
+ }
|
|
|
+ oldValue, err := m.oldValue(ctx)
|
|
|
+ if err != nil {
|
|
|
+ return v, fmt.Errorf("querying old value for OldContactID: %w", err)
|
|
|
+ }
|
|
|
+ return oldValue.ContactID, nil
|
|
|
+}
|
|
|
+
|
|
|
+// ResetContactID resets all changes to the "contact_id" field.
|
|
|
+func (m *LabelRelationshipMutation) ResetContactID() {
|
|
|
+ m.contacts = nil
|
|
|
+}
|
|
|
+
|
|
|
+// SetContactsID sets the "contacts" edge to the Contact entity by id.
|
|
|
+func (m *LabelRelationshipMutation) SetContactsID(id uint64) {
|
|
|
+ m.contacts = &id
|
|
|
+}
|
|
|
+
|
|
|
+// ClearContacts clears the "contacts" edge to the Contact entity.
|
|
|
+func (m *LabelRelationshipMutation) ClearContacts() {
|
|
|
+ m.clearedcontacts = true
|
|
|
+ m.clearedFields[labelrelationship.FieldContactID] = struct{}{}
|
|
|
+}
|
|
|
+
|
|
|
+// ContactsCleared reports if the "contacts" edge to the Contact entity was cleared.
|
|
|
+func (m *LabelRelationshipMutation) ContactsCleared() bool {
|
|
|
+ return m.clearedcontacts
|
|
|
+}
|
|
|
+
|
|
|
+// ContactsID returns the "contacts" edge ID in the mutation.
|
|
|
+func (m *LabelRelationshipMutation) ContactsID() (id uint64, exists bool) {
|
|
|
+ if m.contacts != nil {
|
|
|
+ return *m.contacts, true
|
|
|
+ }
|
|
|
+ return
|
|
|
+}
|
|
|
+
|
|
|
+// ContactsIDs returns the "contacts" edge IDs in the mutation.
|
|
|
+// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use
|
|
|
+// ContactsID instead. It exists only for internal usage by the builders.
|
|
|
+func (m *LabelRelationshipMutation) ContactsIDs() (ids []uint64) {
|
|
|
+ if id := m.contacts; id != nil {
|
|
|
+ ids = append(ids, *id)
|
|
|
+ }
|
|
|
+ return
|
|
|
+}
|
|
|
+
|
|
|
+// ResetContacts resets all changes to the "contacts" edge.
|
|
|
+func (m *LabelRelationshipMutation) ResetContacts() {
|
|
|
+ m.contacts = nil
|
|
|
+ m.clearedcontacts = false
|
|
|
+}
|
|
|
+
|
|
|
+// SetLabelsID sets the "labels" edge to the Label entity by id.
|
|
|
+func (m *LabelRelationshipMutation) SetLabelsID(id uint64) {
|
|
|
+ m.labels = &id
|
|
|
+}
|
|
|
+
|
|
|
+// ClearLabels clears the "labels" edge to the Label entity.
|
|
|
+func (m *LabelRelationshipMutation) ClearLabels() {
|
|
|
+ m.clearedlabels = true
|
|
|
+ m.clearedFields[labelrelationship.FieldLabelID] = struct{}{}
|
|
|
+}
|
|
|
+
|
|
|
+// LabelsCleared reports if the "labels" edge to the Label entity was cleared.
|
|
|
+func (m *LabelRelationshipMutation) LabelsCleared() bool {
|
|
|
+ return m.clearedlabels
|
|
|
+}
|
|
|
+
|
|
|
+// LabelsID returns the "labels" edge ID in the mutation.
|
|
|
+func (m *LabelRelationshipMutation) LabelsID() (id uint64, exists bool) {
|
|
|
+ if m.labels != nil {
|
|
|
+ return *m.labels, true
|
|
|
+ }
|
|
|
+ return
|
|
|
+}
|
|
|
+
|
|
|
+// LabelsIDs returns the "labels" edge IDs in the mutation.
|
|
|
+// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use
|
|
|
+// LabelsID instead. It exists only for internal usage by the builders.
|
|
|
+func (m *LabelRelationshipMutation) LabelsIDs() (ids []uint64) {
|
|
|
+ if id := m.labels; id != nil {
|
|
|
+ ids = append(ids, *id)
|
|
|
+ }
|
|
|
+ return
|
|
|
+}
|
|
|
+
|
|
|
+// ResetLabels resets all changes to the "labels" edge.
|
|
|
+func (m *LabelRelationshipMutation) ResetLabels() {
|
|
|
+ m.labels = nil
|
|
|
+ m.clearedlabels = false
|
|
|
+}
|
|
|
+
|
|
|
+// Where appends a list predicates to the LabelRelationshipMutation builder.
|
|
|
+func (m *LabelRelationshipMutation) Where(ps ...predicate.LabelRelationship) {
|
|
|
+ m.predicates = append(m.predicates, ps...)
|
|
|
+}
|
|
|
+
|
|
|
+// WhereP appends storage-level predicates to the LabelRelationshipMutation builder. Using this method,
|
|
|
+// users can use type-assertion to append predicates that do not depend on any generated package.
|
|
|
+func (m *LabelRelationshipMutation) WhereP(ps ...func(*sql.Selector)) {
|
|
|
+ p := make([]predicate.LabelRelationship, len(ps))
|
|
|
+ for i := range ps {
|
|
|
+ p[i] = ps[i]
|
|
|
+ }
|
|
|
+ m.Where(p...)
|
|
|
+}
|
|
|
+
|
|
|
+// Op returns the operation name.
|
|
|
+func (m *LabelRelationshipMutation) Op() Op {
|
|
|
+ return m.op
|
|
|
+}
|
|
|
+
|
|
|
+// SetOp allows setting the mutation operation.
|
|
|
+func (m *LabelRelationshipMutation) SetOp(op Op) {
|
|
|
+ m.op = op
|
|
|
+}
|
|
|
+
|
|
|
+// Type returns the node type of this mutation (LabelRelationship).
|
|
|
+func (m *LabelRelationshipMutation) 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 *LabelRelationshipMutation) Fields() []string {
|
|
|
+ fields := make([]string, 0, 6)
|
|
|
+ if m.created_at != nil {
|
|
|
+ fields = append(fields, labelrelationship.FieldCreatedAt)
|
|
|
+ }
|
|
|
+ if m.updated_at != nil {
|
|
|
+ fields = append(fields, labelrelationship.FieldUpdatedAt)
|
|
|
+ }
|
|
|
+ if m.status != nil {
|
|
|
+ fields = append(fields, labelrelationship.FieldStatus)
|
|
|
+ }
|
|
|
+ if m.deleted_at != nil {
|
|
|
+ fields = append(fields, labelrelationship.FieldDeletedAt)
|
|
|
+ }
|
|
|
+ if m.labels != nil {
|
|
|
+ fields = append(fields, labelrelationship.FieldLabelID)
|
|
|
+ }
|
|
|
+ if m.contacts != nil {
|
|
|
+ fields = append(fields, labelrelationship.FieldContactID)
|
|
|
+ }
|
|
|
+ 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 *LabelRelationshipMutation) Field(name string) (ent.Value, bool) {
|
|
|
+ switch name {
|
|
|
+ case labelrelationship.FieldCreatedAt:
|
|
|
+ return m.CreatedAt()
|
|
|
+ case labelrelationship.FieldUpdatedAt:
|
|
|
+ return m.UpdatedAt()
|
|
|
+ case labelrelationship.FieldStatus:
|
|
|
+ return m.Status()
|
|
|
+ case labelrelationship.FieldDeletedAt:
|
|
|
+ return m.DeletedAt()
|
|
|
+ case labelrelationship.FieldLabelID:
|
|
|
+ return m.LabelID()
|
|
|
+ case labelrelationship.FieldContactID:
|
|
|
+ return m.ContactID()
|
|
|
+ }
|
|
|
+ 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 *LabelRelationshipMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
|
|
|
+ switch name {
|
|
|
+ case labelrelationship.FieldCreatedAt:
|
|
|
+ return m.OldCreatedAt(ctx)
|
|
|
+ case labelrelationship.FieldUpdatedAt:
|
|
|
+ return m.OldUpdatedAt(ctx)
|
|
|
+ case labelrelationship.FieldStatus:
|
|
|
+ return m.OldStatus(ctx)
|
|
|
+ case labelrelationship.FieldDeletedAt:
|
|
|
+ return m.OldDeletedAt(ctx)
|
|
|
+ case labelrelationship.FieldLabelID:
|
|
|
+ return m.OldLabelID(ctx)
|
|
|
+ case labelrelationship.FieldContactID:
|
|
|
+ return m.OldContactID(ctx)
|
|
|
+ }
|
|
|
+ return nil, fmt.Errorf("unknown LabelRelationship 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 *LabelRelationshipMutation) SetField(name string, value ent.Value) error {
|
|
|
+ switch name {
|
|
|
+ case labelrelationship.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 labelrelationship.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 labelrelationship.FieldStatus:
|
|
|
+ v, ok := value.(uint8)
|
|
|
+ if !ok {
|
|
|
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
|
+ }
|
|
|
+ m.SetStatus(v)
|
|
|
+ return nil
|
|
|
+ case labelrelationship.FieldDeletedAt:
|
|
|
+ v, ok := value.(time.Time)
|
|
|
+ if !ok {
|
|
|
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
|
+ }
|
|
|
+ m.SetDeletedAt(v)
|
|
|
+ return nil
|
|
|
+ case labelrelationship.FieldLabelID:
|
|
|
+ v, ok := value.(uint64)
|
|
|
+ if !ok {
|
|
|
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
|
+ }
|
|
|
+ m.SetLabelID(v)
|
|
|
+ return nil
|
|
|
+ case labelrelationship.FieldContactID:
|
|
|
+ v, ok := value.(uint64)
|
|
|
+ if !ok {
|
|
|
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
|
+ }
|
|
|
+ m.SetContactID(v)
|
|
|
+ return nil
|
|
|
+ }
|
|
|
+ return fmt.Errorf("unknown LabelRelationship field %s", name)
|
|
|
+}
|
|
|
+
|
|
|
+// AddedFields returns all numeric fields that were incremented/decremented during
|
|
|
+// this mutation.
|
|
|
+func (m *LabelRelationshipMutation) AddedFields() []string {
|
|
|
+ var fields []string
|
|
|
+ if m.addstatus != nil {
|
|
|
+ fields = append(fields, labelrelationship.FieldStatus)
|
|
|
+ }
|
|
|
+ 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 *LabelRelationshipMutation) AddedField(name string) (ent.Value, bool) {
|
|
|
+ switch name {
|
|
|
+ case labelrelationship.FieldStatus:
|
|
|
+ return m.AddedStatus()
|
|
|
+ }
|
|
|
+ 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 *LabelRelationshipMutation) AddField(name string, value ent.Value) error {
|
|
|
+ switch name {
|
|
|
+ case labelrelationship.FieldStatus:
|
|
|
+ v, ok := value.(int8)
|
|
|
+ if !ok {
|
|
|
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
|
+ }
|
|
|
+ m.AddStatus(v)
|
|
|
+ return nil
|
|
|
+ }
|
|
|
+ return fmt.Errorf("unknown LabelRelationship numeric field %s", name)
|
|
|
+}
|
|
|
+
|
|
|
+// ClearedFields returns all nullable fields that were cleared during this
|
|
|
+// mutation.
|
|
|
+func (m *LabelRelationshipMutation) ClearedFields() []string {
|
|
|
+ var fields []string
|
|
|
+ if m.FieldCleared(labelrelationship.FieldStatus) {
|
|
|
+ fields = append(fields, labelrelationship.FieldStatus)
|
|
|
+ }
|
|
|
+ if m.FieldCleared(labelrelationship.FieldDeletedAt) {
|
|
|
+ fields = append(fields, labelrelationship.FieldDeletedAt)
|
|
|
+ }
|
|
|
+ return fields
|
|
|
+}
|
|
|
+
|
|
|
+// FieldCleared returns a boolean indicating if a field with the given name was
|
|
|
+// cleared in this mutation.
|
|
|
+func (m *LabelRelationshipMutation) 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 *LabelRelationshipMutation) ClearField(name string) error {
|
|
|
+ switch name {
|
|
|
+ case labelrelationship.FieldStatus:
|
|
|
+ m.ClearStatus()
|
|
|
+ return nil
|
|
|
+ case labelrelationship.FieldDeletedAt:
|
|
|
+ m.ClearDeletedAt()
|
|
|
+ return nil
|
|
|
+ }
|
|
|
+ return fmt.Errorf("unknown LabelRelationship 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 *LabelRelationshipMutation) ResetField(name string) error {
|
|
|
+ switch name {
|
|
|
+ case labelrelationship.FieldCreatedAt:
|
|
|
+ m.ResetCreatedAt()
|
|
|
+ return nil
|
|
|
+ case labelrelationship.FieldUpdatedAt:
|
|
|
+ m.ResetUpdatedAt()
|
|
|
+ return nil
|
|
|
+ case labelrelationship.FieldStatus:
|
|
|
+ m.ResetStatus()
|
|
|
+ return nil
|
|
|
+ case labelrelationship.FieldDeletedAt:
|
|
|
+ m.ResetDeletedAt()
|
|
|
+ return nil
|
|
|
+ case labelrelationship.FieldLabelID:
|
|
|
+ m.ResetLabelID()
|
|
|
+ return nil
|
|
|
+ case labelrelationship.FieldContactID:
|
|
|
+ m.ResetContactID()
|
|
|
+ return nil
|
|
|
+ }
|
|
|
+ return fmt.Errorf("unknown LabelRelationship field %s", name)
|
|
|
+}
|
|
|
+
|
|
|
+// AddedEdges returns all edge names that were set/added in this mutation.
|
|
|
+func (m *LabelRelationshipMutation) AddedEdges() []string {
|
|
|
+ edges := make([]string, 0, 2)
|
|
|
+ if m.contacts != nil {
|
|
|
+ edges = append(edges, labelrelationship.EdgeContacts)
|
|
|
+ }
|
|
|
+ if m.labels != nil {
|
|
|
+ edges = append(edges, labelrelationship.EdgeLabels)
|
|
|
+ }
|
|
|
+ return edges
|
|
|
+}
|
|
|
+
|
|
|
+// AddedIDs returns all IDs (to other nodes) that were added for the given edge
|
|
|
+// name in this mutation.
|
|
|
+func (m *LabelRelationshipMutation) AddedIDs(name string) []ent.Value {
|
|
|
+ switch name {
|
|
|
+ case labelrelationship.EdgeContacts:
|
|
|
+ if id := m.contacts; id != nil {
|
|
|
+ return []ent.Value{*id}
|
|
|
+ }
|
|
|
+ case labelrelationship.EdgeLabels:
|
|
|
+ if id := m.labels; id != nil {
|
|
|
+ return []ent.Value{*id}
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return nil
|
|
|
+}
|
|
|
+
|
|
|
+// RemovedEdges returns all edge names that were removed in this mutation.
|
|
|
+func (m *LabelRelationshipMutation) RemovedEdges() []string {
|
|
|
+ edges := make([]string, 0, 2)
|
|
|
+ return edges
|
|
|
+}
|
|
|
+
|
|
|
+// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
|
|
|
+// the given name in this mutation.
|
|
|
+func (m *LabelRelationshipMutation) RemovedIDs(name string) []ent.Value {
|
|
|
+ return nil
|
|
|
+}
|
|
|
+
|
|
|
+// ClearedEdges returns all edge names that were cleared in this mutation.
|
|
|
+func (m *LabelRelationshipMutation) ClearedEdges() []string {
|
|
|
+ edges := make([]string, 0, 2)
|
|
|
+ if m.clearedcontacts {
|
|
|
+ edges = append(edges, labelrelationship.EdgeContacts)
|
|
|
+ }
|
|
|
+ if m.clearedlabels {
|
|
|
+ edges = append(edges, labelrelationship.EdgeLabels)
|
|
|
+ }
|
|
|
+ return edges
|
|
|
+}
|
|
|
+
|
|
|
+// EdgeCleared returns a boolean which indicates if the edge with the given name
|
|
|
+// was cleared in this mutation.
|
|
|
+func (m *LabelRelationshipMutation) EdgeCleared(name string) bool {
|
|
|
+ switch name {
|
|
|
+ case labelrelationship.EdgeContacts:
|
|
|
+ return m.clearedcontacts
|
|
|
+ case labelrelationship.EdgeLabels:
|
|
|
+ return m.clearedlabels
|
|
|
+ }
|
|
|
+ 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 *LabelRelationshipMutation) ClearEdge(name string) error {
|
|
|
+ switch name {
|
|
|
+ case labelrelationship.EdgeContacts:
|
|
|
+ m.ClearContacts()
|
|
|
+ return nil
|
|
|
+ case labelrelationship.EdgeLabels:
|
|
|
+ m.ClearLabels()
|
|
|
+ return nil
|
|
|
+ }
|
|
|
+ return fmt.Errorf("unknown LabelRelationship 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 *LabelRelationshipMutation) ResetEdge(name string) error {
|
|
|
+ switch name {
|
|
|
+ case labelrelationship.EdgeContacts:
|
|
|
+ m.ResetContacts()
|
|
|
+ return nil
|
|
|
+ case labelrelationship.EdgeLabels:
|
|
|
+ m.ResetLabels()
|
|
|
+ return nil
|
|
|
+ }
|
|
|
+ return fmt.Errorf("unknown LabelRelationship edge %s", name)
|
|
|
+}
|
|
|
+
|
|
|
+// MessageMutation represents an operation that mutates the Message nodes in the graph.
|
|
|
+type MessageMutation struct {
|
|
|
+ config
|
|
|
+ op Op
|
|
|
+ typ string
|
|
|
+ id *int
|
|
|
+ wx_wxid *string
|
|
|
+ wxid *string
|
|
|
+ content *string
|
|
|
+ clearedFields map[string]struct{}
|
|
|
+ done bool
|
|
|
+ oldValue func(context.Context) (*Message, error)
|
|
|
+ predicates []predicate.Message
|
|
|
+}
|
|
|
+
|
|
|
+var _ ent.Mutation = (*MessageMutation)(nil)
|
|
|
+
|
|
|
+// messageOption allows management of the mutation configuration using functional options.
|
|
|
+type messageOption func(*MessageMutation)
|
|
|
+
|
|
|
+// newMessageMutation creates new mutation for the Message entity.
|
|
|
+func newMessageMutation(c config, op Op, opts ...messageOption) *MessageMutation {
|
|
|
+ m := &MessageMutation{
|
|
|
+ config: c,
|
|
|
+ op: op,
|
|
|
+ typ: TypeMessage,
|
|
|
+ clearedFields: make(map[string]struct{}),
|
|
|
+ }
|
|
|
+ for _, opt := range opts {
|
|
|
+ opt(m)
|
|
|
+ }
|
|
|
+ return m
|
|
|
+}
|
|
|
+
|
|
|
+// withMessageID sets the ID field of the mutation.
|
|
|
+func withMessageID(id int) messageOption {
|
|
|
+ return func(m *MessageMutation) {
|
|
|
+ var (
|
|
|
+ err error
|
|
|
+ once sync.Once
|
|
|
+ value *Message
|
|
|
+ )
|
|
|
+ m.oldValue = func(ctx context.Context) (*Message, error) {
|
|
|
+ once.Do(func() {
|
|
|
+ if m.done {
|
|
|
+ err = errors.New("querying old values post mutation is not allowed")
|
|
|
+ } else {
|
|
|
+ value, err = m.Client().Message.Get(ctx, id)
|
|
|
+ }
|
|
|
+ })
|
|
|
+ return value, err
|
|
|
+ }
|
|
|
+ m.id = &id
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+// withMessage sets the old Message of the mutation.
|
|
|
+func withMessage(node *Message) messageOption {
|
|
|
+ return func(m *MessageMutation) {
|
|
|
+ m.oldValue = func(context.Context) (*Message, 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 MessageMutation) 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 MessageMutation) 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 *MessageMutation) 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 *MessageMutation) 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().Message.Query().Where(m.predicates...).IDs(ctx)
|
|
|
+ default:
|
|
|
+ return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+// SetWxWxid sets the "wx_wxid" field.
|
|
|
+func (m *MessageMutation) SetWxWxid(s string) {
|
|
|
+ m.wx_wxid = &s
|
|
|
+}
|
|
|
+
|
|
|
+// WxWxid returns the value of the "wx_wxid" field in the mutation.
|
|
|
+func (m *MessageMutation) WxWxid() (r string, exists bool) {
|
|
|
+ v := m.wx_wxid
|
|
|
+ if v == nil {
|
|
|
+ return
|
|
|
+ }
|
|
|
+ return *v, true
|
|
|
+}
|
|
|
+
|
|
|
+// OldWxWxid returns the old "wx_wxid" field's value of the Message entity.
|
|
|
+// If the Message 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 *MessageMutation) OldWxWxid(ctx context.Context) (v string, err error) {
|
|
|
+ if !m.op.Is(OpUpdateOne) {
|
|
|
+ return v, errors.New("OldWxWxid is only allowed on UpdateOne operations")
|
|
|
+ }
|
|
|
+ if m.id == nil || m.oldValue == nil {
|
|
|
+ return v, errors.New("OldWxWxid requires an ID field in the mutation")
|
|
|
+ }
|
|
|
+ oldValue, err := m.oldValue(ctx)
|
|
|
+ if err != nil {
|
|
|
+ return v, fmt.Errorf("querying old value for OldWxWxid: %w", err)
|
|
|
+ }
|
|
|
+ return oldValue.WxWxid, nil
|
|
|
+}
|
|
|
+
|
|
|
+// ClearWxWxid clears the value of the "wx_wxid" field.
|
|
|
+func (m *MessageMutation) ClearWxWxid() {
|
|
|
+ m.wx_wxid = nil
|
|
|
+ m.clearedFields[message.FieldWxWxid] = struct{}{}
|
|
|
+}
|
|
|
+
|
|
|
+// WxWxidCleared returns if the "wx_wxid" field was cleared in this mutation.
|
|
|
+func (m *MessageMutation) WxWxidCleared() bool {
|
|
|
+ _, ok := m.clearedFields[message.FieldWxWxid]
|
|
|
+ return ok
|
|
|
+}
|
|
|
+
|
|
|
+// ResetWxWxid resets all changes to the "wx_wxid" field.
|
|
|
+func (m *MessageMutation) ResetWxWxid() {
|
|
|
+ m.wx_wxid = nil
|
|
|
+ delete(m.clearedFields, message.FieldWxWxid)
|
|
|
+}
|
|
|
+
|
|
|
+// SetWxid sets the "wxid" field.
|
|
|
+func (m *MessageMutation) SetWxid(s string) {
|
|
|
+ m.wxid = &s
|
|
|
+}
|
|
|
+
|
|
|
+// Wxid returns the value of the "wxid" field in the mutation.
|
|
|
+func (m *MessageMutation) Wxid() (r string, exists bool) {
|
|
|
+ v := m.wxid
|
|
|
+ if v == nil {
|
|
|
+ return
|
|
|
+ }
|
|
|
+ return *v, true
|
|
|
+}
|
|
|
+
|
|
|
+// OldWxid returns the old "wxid" field's value of the Message entity.
|
|
|
+// If the Message 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 *MessageMutation) OldWxid(ctx context.Context) (v string, err error) {
|
|
|
+ if !m.op.Is(OpUpdateOne) {
|
|
|
+ return v, errors.New("OldWxid is only allowed on UpdateOne operations")
|
|
|
+ }
|
|
|
+ if m.id == nil || m.oldValue == nil {
|
|
|
+ return v, errors.New("OldWxid requires an ID field in the mutation")
|
|
|
+ }
|
|
|
+ oldValue, err := m.oldValue(ctx)
|
|
|
+ if err != nil {
|
|
|
+ return v, fmt.Errorf("querying old value for OldWxid: %w", err)
|
|
|
+ }
|
|
|
+ return oldValue.Wxid, nil
|
|
|
+}
|
|
|
+
|
|
|
+// ResetWxid resets all changes to the "wxid" field.
|
|
|
+func (m *MessageMutation) ResetWxid() {
|
|
|
+ m.wxid = nil
|
|
|
+}
|
|
|
+
|
|
|
+// SetContent sets the "content" field.
|
|
|
+func (m *MessageMutation) SetContent(s string) {
|
|
|
+ m.content = &s
|
|
|
+}
|
|
|
+
|
|
|
+// Content returns the value of the "content" field in the mutation.
|
|
|
+func (m *MessageMutation) Content() (r string, exists bool) {
|
|
|
+ v := m.content
|
|
|
+ if v == nil {
|
|
|
+ return
|
|
|
+ }
|
|
|
+ return *v, true
|
|
|
+}
|
|
|
+
|
|
|
+// OldContent returns the old "content" field's value of the Message entity.
|
|
|
+// If the Message 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 *MessageMutation) OldContent(ctx context.Context) (v string, err error) {
|
|
|
+ if !m.op.Is(OpUpdateOne) {
|
|
|
+ return v, errors.New("OldContent is only allowed on UpdateOne operations")
|
|
|
+ }
|
|
|
+ if m.id == nil || m.oldValue == nil {
|
|
|
+ return v, errors.New("OldContent requires an ID field in the mutation")
|
|
|
+ }
|
|
|
+ oldValue, err := m.oldValue(ctx)
|
|
|
+ if err != nil {
|
|
|
+ return v, fmt.Errorf("querying old value for OldContent: %w", err)
|
|
|
+ }
|
|
|
+ return oldValue.Content, nil
|
|
|
+}
|
|
|
+
|
|
|
+// ResetContent resets all changes to the "content" field.
|
|
|
+func (m *MessageMutation) ResetContent() {
|
|
|
+ m.content = nil
|
|
|
+}
|
|
|
+
|
|
|
+// Where appends a list predicates to the MessageMutation builder.
|
|
|
+func (m *MessageMutation) Where(ps ...predicate.Message) {
|
|
|
+ m.predicates = append(m.predicates, ps...)
|
|
|
+}
|
|
|
+
|
|
|
+// WhereP appends storage-level predicates to the MessageMutation builder. Using this method,
|
|
|
+// users can use type-assertion to append predicates that do not depend on any generated package.
|
|
|
+func (m *MessageMutation) WhereP(ps ...func(*sql.Selector)) {
|
|
|
+ p := make([]predicate.Message, len(ps))
|
|
|
+ for i := range ps {
|
|
|
+ p[i] = ps[i]
|
|
|
+ }
|
|
|
+ m.Where(p...)
|
|
|
+}
|
|
|
+
|
|
|
+// Op returns the operation name.
|
|
|
+func (m *MessageMutation) Op() Op {
|
|
|
+ return m.op
|
|
|
+}
|
|
|
+
|
|
|
+// SetOp allows setting the mutation operation.
|
|
|
+func (m *MessageMutation) SetOp(op Op) {
|
|
|
+ m.op = op
|
|
|
+}
|
|
|
+
|
|
|
+// Type returns the node type of this mutation (Message).
|
|
|
+func (m *MessageMutation) 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 *MessageMutation) Fields() []string {
|
|
|
+ fields := make([]string, 0, 3)
|
|
|
+ if m.wx_wxid != nil {
|
|
|
+ fields = append(fields, message.FieldWxWxid)
|
|
|
+ }
|
|
|
+ if m.wxid != nil {
|
|
|
+ fields = append(fields, message.FieldWxid)
|
|
|
+ }
|
|
|
+ if m.content != nil {
|
|
|
+ fields = append(fields, message.FieldContent)
|
|
|
+ }
|
|
|
+ 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 *MessageMutation) Field(name string) (ent.Value, bool) {
|
|
|
+ switch name {
|
|
|
+ case message.FieldWxWxid:
|
|
|
+ return m.WxWxid()
|
|
|
+ case message.FieldWxid:
|
|
|
+ return m.Wxid()
|
|
|
+ case message.FieldContent:
|
|
|
+ return m.Content()
|
|
|
+ }
|
|
|
+ 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 *MessageMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
|
|
|
+ switch name {
|
|
|
+ case message.FieldWxWxid:
|
|
|
+ return m.OldWxWxid(ctx)
|
|
|
+ case message.FieldWxid:
|
|
|
+ return m.OldWxid(ctx)
|
|
|
+ case message.FieldContent:
|
|
|
+ return m.OldContent(ctx)
|
|
|
+ }
|
|
|
+ return nil, fmt.Errorf("unknown Message 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 *MessageMutation) SetField(name string, value ent.Value) error {
|
|
|
+ switch name {
|
|
|
+ case message.FieldWxWxid:
|
|
|
+ v, ok := value.(string)
|
|
|
+ if !ok {
|
|
|
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
|
+ }
|
|
|
+ m.SetWxWxid(v)
|
|
|
+ return nil
|
|
|
+ case message.FieldWxid:
|
|
|
+ v, ok := value.(string)
|
|
|
+ if !ok {
|
|
|
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
|
+ }
|
|
|
+ m.SetWxid(v)
|
|
|
+ return nil
|
|
|
+ case message.FieldContent:
|
|
|
+ v, ok := value.(string)
|
|
|
+ if !ok {
|
|
|
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
|
|
|
+ }
|
|
|
+ m.SetContent(v)
|
|
|
+ return nil
|
|
|
+ }
|
|
|
+ return fmt.Errorf("unknown Message field %s", name)
|
|
|
+}
|
|
|
+
|
|
|
+// AddedFields returns all numeric fields that were incremented/decremented during
|
|
|
+// this mutation.
|
|
|
+func (m *MessageMutation) 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 *MessageMutation) 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 *MessageMutation) AddField(name string, value ent.Value) error {
|
|
|
+ switch name {
|
|
|
+ }
|
|
|
+ return fmt.Errorf("unknown Message numeric field %s", name)
|
|
|
+}
|
|
|
+
|
|
|
+// ClearedFields returns all nullable fields that were cleared during this
|
|
|
+// mutation.
|
|
|
+func (m *MessageMutation) ClearedFields() []string {
|
|
|
+ var fields []string
|
|
|
+ if m.FieldCleared(message.FieldWxWxid) {
|
|
|
+ fields = append(fields, message.FieldWxWxid)
|
|
|
+ }
|
|
|
+ return fields
|
|
|
+}
|
|
|
+
|
|
|
+// FieldCleared returns a boolean indicating if a field with the given name was
|
|
|
+// cleared in this mutation.
|
|
|
+func (m *MessageMutation) 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 *MessageMutation) ClearField(name string) error {
|
|
|
+ switch name {
|
|
|
+ case message.FieldWxWxid:
|
|
|
+ m.ClearWxWxid()
|
|
|
+ return nil
|
|
|
+ }
|
|
|
+ return fmt.Errorf("unknown Message 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 *MessageMutation) ResetField(name string) error {
|
|
|
+ switch name {
|
|
|
+ case message.FieldWxWxid:
|
|
|
+ m.ResetWxWxid()
|
|
|
+ return nil
|
|
|
+ case message.FieldWxid:
|
|
|
+ m.ResetWxid()
|
|
|
+ return nil
|
|
|
+ case message.FieldContent:
|
|
|
+ m.ResetContent()
|
|
|
+ return nil
|
|
|
+ }
|
|
|
+ return fmt.Errorf("unknown Message field %s", name)
|
|
|
+}
|
|
|
+
|
|
|
+// AddedEdges returns all edge names that were set/added in this mutation.
|
|
|
+func (m *MessageMutation) 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 *MessageMutation) AddedIDs(name string) []ent.Value {
|
|
|
+ return nil
|
|
|
+}
|
|
|
+
|
|
|
+// RemovedEdges returns all edge names that were removed in this mutation.
|
|
|
+func (m *MessageMutation) 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 *MessageMutation) RemovedIDs(name string) []ent.Value {
|
|
|
+ return nil
|
|
|
+}
|
|
|
+
|
|
|
+// ClearedEdges returns all edge names that were cleared in this mutation.
|
|
|
+func (m *MessageMutation) 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 *MessageMutation) 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 *MessageMutation) ClearEdge(name string) error {
|
|
|
+ return fmt.Errorf("unknown Message 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 *MessageMutation) ResetEdge(name string) error {
|
|
|
+ return fmt.Errorf("unknown Message edge %s", name)
|
|
|
+}
|
|
|
+
|
|
|
// ServerMutation represents an operation that mutates the Server nodes in the graph.
|
|
|
type ServerMutation struct {
|
|
|
config
|