pcmt/ent/mutation.go
leo 593454d616
All checks were successful
continuous-integration/drone/push Build is passing
go: add user email handling + improve sessions
* add Email field to User entity (+codegen)
* switch to Echo contrib sessions backed by Gorilla sessions
* use SessionCookieSecret value from the config
* stage mod,sum changes
* add clearer signup/signin redirect logic
* render error pages on 500/404s and only fall back to returning raw
  errors when the error is some unexpected kind
* add username/email "exists" funcs+tests - handle "not found" and "not
  unique" errors, return errors otherwise
2023-05-01 22:48:11 +02:00

1828 lines
53 KiB
Go

// Code generated by ent, DO NOT EDIT.
package ent
import (
"context"
"errors"
"fmt"
"sync"
"time"
"entgo.io/ent"
"entgo.io/ent/dialect/sql"
"git.dotya.ml/mirre-mt/pcmt/ent/hibp"
"git.dotya.ml/mirre-mt/pcmt/ent/predicate"
"git.dotya.ml/mirre-mt/pcmt/ent/user"
"github.com/google/uuid"
)
const (
// Operation types.
OpCreate = ent.OpCreate
OpDelete = ent.OpDelete
OpDeleteOne = ent.OpDeleteOne
OpUpdate = ent.OpUpdate
OpUpdateOne = ent.OpUpdateOne
// Node types.
TypeHIBP = "HIBP"
TypeUser = "User"
)
// HIBPMutation represents an operation that mutates the HIBP nodes in the graph.
type HIBPMutation struct {
config
op Op
typ string
id *uuid.UUID
name *string
domain *string
breach_date *time.Time
added_date *time.Time
modified_date *time.Time
pwn_count *int
addpwn_count *int
description *string
dataclasses *[]string
appenddataclasses []string
is_verified *bool
is_fabricated *bool
is_sensitive *bool
is_retired *bool
is_spamList *bool
is_malware *bool
logo *string
clearedFields map[string]struct{}
done bool
oldValue func(context.Context) (*HIBP, error)
predicates []predicate.HIBP
}
var _ ent.Mutation = (*HIBPMutation)(nil)
// hibpOption allows management of the mutation configuration using functional options.
type hibpOption func(*HIBPMutation)
// newHIBPMutation creates new mutation for the HIBP entity.
func newHIBPMutation(c config, op Op, opts ...hibpOption) *HIBPMutation {
m := &HIBPMutation{
config: c,
op: op,
typ: TypeHIBP,
clearedFields: make(map[string]struct{}),
}
for _, opt := range opts {
opt(m)
}
return m
}
// withHIBPID sets the ID field of the mutation.
func withHIBPID(id uuid.UUID) hibpOption {
return func(m *HIBPMutation) {
var (
err error
once sync.Once
value *HIBP
)
m.oldValue = func(ctx context.Context) (*HIBP, error) {
once.Do(func() {
if m.done {
err = errors.New("querying old values post mutation is not allowed")
} else {
value, err = m.Client().HIBP.Get(ctx, id)
}
})
return value, err
}
m.id = &id
}
}
// withHIBP sets the old HIBP of the mutation.
func withHIBP(node *HIBP) hibpOption {
return func(m *HIBPMutation) {
m.oldValue = func(context.Context) (*HIBP, 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 HIBPMutation) 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 HIBPMutation) 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 HIBP entities.
func (m *HIBPMutation) SetID(id uuid.UUID) {
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 *HIBPMutation) ID() (id uuid.UUID, 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 *HIBPMutation) IDs(ctx context.Context) ([]uuid.UUID, error) {
switch {
case m.op.Is(OpUpdateOne | OpDeleteOne):
id, exists := m.ID()
if exists {
return []uuid.UUID{id}, nil
}
fallthrough
case m.op.Is(OpUpdate | OpDelete):
return m.Client().HIBP.Query().Where(m.predicates...).IDs(ctx)
default:
return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
}
}
// SetName sets the "name" field.
func (m *HIBPMutation) SetName(s string) {
m.name = &s
}
// Name returns the value of the "name" field in the mutation.
func (m *HIBPMutation) 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 HIBP entity.
// If the HIBP 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 *HIBPMutation) 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 *HIBPMutation) ResetName() {
m.name = nil
}
// SetDomain sets the "domain" field.
func (m *HIBPMutation) SetDomain(s string) {
m.domain = &s
}
// Domain returns the value of the "domain" field in the mutation.
func (m *HIBPMutation) Domain() (r string, exists bool) {
v := m.domain
if v == nil {
return
}
return *v, true
}
// OldDomain returns the old "domain" field's value of the HIBP entity.
// If the HIBP 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 *HIBPMutation) OldDomain(ctx context.Context) (v string, err error) {
if !m.op.Is(OpUpdateOne) {
return v, errors.New("OldDomain is only allowed on UpdateOne operations")
}
if m.id == nil || m.oldValue == nil {
return v, errors.New("OldDomain requires an ID field in the mutation")
}
oldValue, err := m.oldValue(ctx)
if err != nil {
return v, fmt.Errorf("querying old value for OldDomain: %w", err)
}
return oldValue.Domain, nil
}
// ResetDomain resets all changes to the "domain" field.
func (m *HIBPMutation) ResetDomain() {
m.domain = nil
}
// SetBreachDate sets the "breach_date" field.
func (m *HIBPMutation) SetBreachDate(t time.Time) {
m.breach_date = &t
}
// BreachDate returns the value of the "breach_date" field in the mutation.
func (m *HIBPMutation) BreachDate() (r time.Time, exists bool) {
v := m.breach_date
if v == nil {
return
}
return *v, true
}
// OldBreachDate returns the old "breach_date" field's value of the HIBP entity.
// If the HIBP 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 *HIBPMutation) OldBreachDate(ctx context.Context) (v time.Time, err error) {
if !m.op.Is(OpUpdateOne) {
return v, errors.New("OldBreachDate is only allowed on UpdateOne operations")
}
if m.id == nil || m.oldValue == nil {
return v, errors.New("OldBreachDate requires an ID field in the mutation")
}
oldValue, err := m.oldValue(ctx)
if err != nil {
return v, fmt.Errorf("querying old value for OldBreachDate: %w", err)
}
return oldValue.BreachDate, nil
}
// ResetBreachDate resets all changes to the "breach_date" field.
func (m *HIBPMutation) ResetBreachDate() {
m.breach_date = nil
}
// SetAddedDate sets the "added_date" field.
func (m *HIBPMutation) SetAddedDate(t time.Time) {
m.added_date = &t
}
// AddedDate returns the value of the "added_date" field in the mutation.
func (m *HIBPMutation) AddedDate() (r time.Time, exists bool) {
v := m.added_date
if v == nil {
return
}
return *v, true
}
// OldAddedDate returns the old "added_date" field's value of the HIBP entity.
// If the HIBP 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 *HIBPMutation) OldAddedDate(ctx context.Context) (v time.Time, err error) {
if !m.op.Is(OpUpdateOne) {
return v, errors.New("OldAddedDate is only allowed on UpdateOne operations")
}
if m.id == nil || m.oldValue == nil {
return v, errors.New("OldAddedDate requires an ID field in the mutation")
}
oldValue, err := m.oldValue(ctx)
if err != nil {
return v, fmt.Errorf("querying old value for OldAddedDate: %w", err)
}
return oldValue.AddedDate, nil
}
// ResetAddedDate resets all changes to the "added_date" field.
func (m *HIBPMutation) ResetAddedDate() {
m.added_date = nil
}
// SetModifiedDate sets the "modified_date" field.
func (m *HIBPMutation) SetModifiedDate(t time.Time) {
m.modified_date = &t
}
// ModifiedDate returns the value of the "modified_date" field in the mutation.
func (m *HIBPMutation) ModifiedDate() (r time.Time, exists bool) {
v := m.modified_date
if v == nil {
return
}
return *v, true
}
// OldModifiedDate returns the old "modified_date" field's value of the HIBP entity.
// If the HIBP 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 *HIBPMutation) OldModifiedDate(ctx context.Context) (v time.Time, err error) {
if !m.op.Is(OpUpdateOne) {
return v, errors.New("OldModifiedDate is only allowed on UpdateOne operations")
}
if m.id == nil || m.oldValue == nil {
return v, errors.New("OldModifiedDate requires an ID field in the mutation")
}
oldValue, err := m.oldValue(ctx)
if err != nil {
return v, fmt.Errorf("querying old value for OldModifiedDate: %w", err)
}
return oldValue.ModifiedDate, nil
}
// ResetModifiedDate resets all changes to the "modified_date" field.
func (m *HIBPMutation) ResetModifiedDate() {
m.modified_date = nil
}
// SetPwnCount sets the "pwn_count" field.
func (m *HIBPMutation) SetPwnCount(i int) {
m.pwn_count = &i
m.addpwn_count = nil
}
// PwnCount returns the value of the "pwn_count" field in the mutation.
func (m *HIBPMutation) PwnCount() (r int, exists bool) {
v := m.pwn_count
if v == nil {
return
}
return *v, true
}
// OldPwnCount returns the old "pwn_count" field's value of the HIBP entity.
// If the HIBP 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 *HIBPMutation) OldPwnCount(ctx context.Context) (v int, err error) {
if !m.op.Is(OpUpdateOne) {
return v, errors.New("OldPwnCount is only allowed on UpdateOne operations")
}
if m.id == nil || m.oldValue == nil {
return v, errors.New("OldPwnCount requires an ID field in the mutation")
}
oldValue, err := m.oldValue(ctx)
if err != nil {
return v, fmt.Errorf("querying old value for OldPwnCount: %w", err)
}
return oldValue.PwnCount, nil
}
// AddPwnCount adds i to the "pwn_count" field.
func (m *HIBPMutation) AddPwnCount(i int) {
if m.addpwn_count != nil {
*m.addpwn_count += i
} else {
m.addpwn_count = &i
}
}
// AddedPwnCount returns the value that was added to the "pwn_count" field in this mutation.
func (m *HIBPMutation) AddedPwnCount() (r int, exists bool) {
v := m.addpwn_count
if v == nil {
return
}
return *v, true
}
// ResetPwnCount resets all changes to the "pwn_count" field.
func (m *HIBPMutation) ResetPwnCount() {
m.pwn_count = nil
m.addpwn_count = nil
}
// SetDescription sets the "description" field.
func (m *HIBPMutation) SetDescription(s string) {
m.description = &s
}
// Description returns the value of the "description" field in the mutation.
func (m *HIBPMutation) Description() (r string, exists bool) {
v := m.description
if v == nil {
return
}
return *v, true
}
// OldDescription returns the old "description" field's value of the HIBP entity.
// If the HIBP 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 *HIBPMutation) OldDescription(ctx context.Context) (v string, err error) {
if !m.op.Is(OpUpdateOne) {
return v, errors.New("OldDescription is only allowed on UpdateOne operations")
}
if m.id == nil || m.oldValue == nil {
return v, errors.New("OldDescription requires an ID field in the mutation")
}
oldValue, err := m.oldValue(ctx)
if err != nil {
return v, fmt.Errorf("querying old value for OldDescription: %w", err)
}
return oldValue.Description, nil
}
// ResetDescription resets all changes to the "description" field.
func (m *HIBPMutation) ResetDescription() {
m.description = nil
}
// SetDataclasses sets the "dataclasses" field.
func (m *HIBPMutation) SetDataclasses(s []string) {
m.dataclasses = &s
m.appenddataclasses = nil
}
// Dataclasses returns the value of the "dataclasses" field in the mutation.
func (m *HIBPMutation) Dataclasses() (r []string, exists bool) {
v := m.dataclasses
if v == nil {
return
}
return *v, true
}
// OldDataclasses returns the old "dataclasses" field's value of the HIBP entity.
// If the HIBP 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 *HIBPMutation) OldDataclasses(ctx context.Context) (v []string, err error) {
if !m.op.Is(OpUpdateOne) {
return v, errors.New("OldDataclasses is only allowed on UpdateOne operations")
}
if m.id == nil || m.oldValue == nil {
return v, errors.New("OldDataclasses requires an ID field in the mutation")
}
oldValue, err := m.oldValue(ctx)
if err != nil {
return v, fmt.Errorf("querying old value for OldDataclasses: %w", err)
}
return oldValue.Dataclasses, nil
}
// AppendDataclasses adds s to the "dataclasses" field.
func (m *HIBPMutation) AppendDataclasses(s []string) {
m.appenddataclasses = append(m.appenddataclasses, s...)
}
// AppendedDataclasses returns the list of values that were appended to the "dataclasses" field in this mutation.
func (m *HIBPMutation) AppendedDataclasses() ([]string, bool) {
if len(m.appenddataclasses) == 0 {
return nil, false
}
return m.appenddataclasses, true
}
// ResetDataclasses resets all changes to the "dataclasses" field.
func (m *HIBPMutation) ResetDataclasses() {
m.dataclasses = nil
m.appenddataclasses = nil
}
// SetIsVerified sets the "is_verified" field.
func (m *HIBPMutation) SetIsVerified(b bool) {
m.is_verified = &b
}
// IsVerified returns the value of the "is_verified" field in the mutation.
func (m *HIBPMutation) IsVerified() (r bool, exists bool) {
v := m.is_verified
if v == nil {
return
}
return *v, true
}
// OldIsVerified returns the old "is_verified" field's value of the HIBP entity.
// If the HIBP 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 *HIBPMutation) OldIsVerified(ctx context.Context) (v bool, err error) {
if !m.op.Is(OpUpdateOne) {
return v, errors.New("OldIsVerified is only allowed on UpdateOne operations")
}
if m.id == nil || m.oldValue == nil {
return v, errors.New("OldIsVerified requires an ID field in the mutation")
}
oldValue, err := m.oldValue(ctx)
if err != nil {
return v, fmt.Errorf("querying old value for OldIsVerified: %w", err)
}
return oldValue.IsVerified, nil
}
// ResetIsVerified resets all changes to the "is_verified" field.
func (m *HIBPMutation) ResetIsVerified() {
m.is_verified = nil
}
// SetIsFabricated sets the "is_fabricated" field.
func (m *HIBPMutation) SetIsFabricated(b bool) {
m.is_fabricated = &b
}
// IsFabricated returns the value of the "is_fabricated" field in the mutation.
func (m *HIBPMutation) IsFabricated() (r bool, exists bool) {
v := m.is_fabricated
if v == nil {
return
}
return *v, true
}
// OldIsFabricated returns the old "is_fabricated" field's value of the HIBP entity.
// If the HIBP 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 *HIBPMutation) OldIsFabricated(ctx context.Context) (v bool, err error) {
if !m.op.Is(OpUpdateOne) {
return v, errors.New("OldIsFabricated is only allowed on UpdateOne operations")
}
if m.id == nil || m.oldValue == nil {
return v, errors.New("OldIsFabricated requires an ID field in the mutation")
}
oldValue, err := m.oldValue(ctx)
if err != nil {
return v, fmt.Errorf("querying old value for OldIsFabricated: %w", err)
}
return oldValue.IsFabricated, nil
}
// ResetIsFabricated resets all changes to the "is_fabricated" field.
func (m *HIBPMutation) ResetIsFabricated() {
m.is_fabricated = nil
}
// SetIsSensitive sets the "is_sensitive" field.
func (m *HIBPMutation) SetIsSensitive(b bool) {
m.is_sensitive = &b
}
// IsSensitive returns the value of the "is_sensitive" field in the mutation.
func (m *HIBPMutation) IsSensitive() (r bool, exists bool) {
v := m.is_sensitive
if v == nil {
return
}
return *v, true
}
// OldIsSensitive returns the old "is_sensitive" field's value of the HIBP entity.
// If the HIBP 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 *HIBPMutation) OldIsSensitive(ctx context.Context) (v bool, err error) {
if !m.op.Is(OpUpdateOne) {
return v, errors.New("OldIsSensitive is only allowed on UpdateOne operations")
}
if m.id == nil || m.oldValue == nil {
return v, errors.New("OldIsSensitive requires an ID field in the mutation")
}
oldValue, err := m.oldValue(ctx)
if err != nil {
return v, fmt.Errorf("querying old value for OldIsSensitive: %w", err)
}
return oldValue.IsSensitive, nil
}
// ResetIsSensitive resets all changes to the "is_sensitive" field.
func (m *HIBPMutation) ResetIsSensitive() {
m.is_sensitive = nil
}
// SetIsRetired sets the "is_retired" field.
func (m *HIBPMutation) SetIsRetired(b bool) {
m.is_retired = &b
}
// IsRetired returns the value of the "is_retired" field in the mutation.
func (m *HIBPMutation) IsRetired() (r bool, exists bool) {
v := m.is_retired
if v == nil {
return
}
return *v, true
}
// OldIsRetired returns the old "is_retired" field's value of the HIBP entity.
// If the HIBP 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 *HIBPMutation) OldIsRetired(ctx context.Context) (v bool, err error) {
if !m.op.Is(OpUpdateOne) {
return v, errors.New("OldIsRetired is only allowed on UpdateOne operations")
}
if m.id == nil || m.oldValue == nil {
return v, errors.New("OldIsRetired requires an ID field in the mutation")
}
oldValue, err := m.oldValue(ctx)
if err != nil {
return v, fmt.Errorf("querying old value for OldIsRetired: %w", err)
}
return oldValue.IsRetired, nil
}
// ResetIsRetired resets all changes to the "is_retired" field.
func (m *HIBPMutation) ResetIsRetired() {
m.is_retired = nil
}
// SetIsSpamList sets the "is_spamList" field.
func (m *HIBPMutation) SetIsSpamList(b bool) {
m.is_spamList = &b
}
// IsSpamList returns the value of the "is_spamList" field in the mutation.
func (m *HIBPMutation) IsSpamList() (r bool, exists bool) {
v := m.is_spamList
if v == nil {
return
}
return *v, true
}
// OldIsSpamList returns the old "is_spamList" field's value of the HIBP entity.
// If the HIBP 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 *HIBPMutation) OldIsSpamList(ctx context.Context) (v bool, err error) {
if !m.op.Is(OpUpdateOne) {
return v, errors.New("OldIsSpamList is only allowed on UpdateOne operations")
}
if m.id == nil || m.oldValue == nil {
return v, errors.New("OldIsSpamList requires an ID field in the mutation")
}
oldValue, err := m.oldValue(ctx)
if err != nil {
return v, fmt.Errorf("querying old value for OldIsSpamList: %w", err)
}
return oldValue.IsSpamList, nil
}
// ResetIsSpamList resets all changes to the "is_spamList" field.
func (m *HIBPMutation) ResetIsSpamList() {
m.is_spamList = nil
}
// SetIsMalware sets the "is_malware" field.
func (m *HIBPMutation) SetIsMalware(b bool) {
m.is_malware = &b
}
// IsMalware returns the value of the "is_malware" field in the mutation.
func (m *HIBPMutation) IsMalware() (r bool, exists bool) {
v := m.is_malware
if v == nil {
return
}
return *v, true
}
// OldIsMalware returns the old "is_malware" field's value of the HIBP entity.
// If the HIBP 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 *HIBPMutation) OldIsMalware(ctx context.Context) (v bool, err error) {
if !m.op.Is(OpUpdateOne) {
return v, errors.New("OldIsMalware is only allowed on UpdateOne operations")
}
if m.id == nil || m.oldValue == nil {
return v, errors.New("OldIsMalware requires an ID field in the mutation")
}
oldValue, err := m.oldValue(ctx)
if err != nil {
return v, fmt.Errorf("querying old value for OldIsMalware: %w", err)
}
return oldValue.IsMalware, nil
}
// ResetIsMalware resets all changes to the "is_malware" field.
func (m *HIBPMutation) ResetIsMalware() {
m.is_malware = nil
}
// SetLogo sets the "logo" field.
func (m *HIBPMutation) SetLogo(s string) {
m.logo = &s
}
// Logo returns the value of the "logo" field in the mutation.
func (m *HIBPMutation) Logo() (r string, exists bool) {
v := m.logo
if v == nil {
return
}
return *v, true
}
// OldLogo returns the old "logo" field's value of the HIBP entity.
// If the HIBP 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 *HIBPMutation) OldLogo(ctx context.Context) (v string, err error) {
if !m.op.Is(OpUpdateOne) {
return v, errors.New("OldLogo is only allowed on UpdateOne operations")
}
if m.id == nil || m.oldValue == nil {
return v, errors.New("OldLogo requires an ID field in the mutation")
}
oldValue, err := m.oldValue(ctx)
if err != nil {
return v, fmt.Errorf("querying old value for OldLogo: %w", err)
}
return oldValue.Logo, nil
}
// ResetLogo resets all changes to the "logo" field.
func (m *HIBPMutation) ResetLogo() {
m.logo = nil
}
// Where appends a list predicates to the HIBPMutation builder.
func (m *HIBPMutation) Where(ps ...predicate.HIBP) {
m.predicates = append(m.predicates, ps...)
}
// WhereP appends storage-level predicates to the HIBPMutation builder. Using this method,
// users can use type-assertion to append predicates that do not depend on any generated package.
func (m *HIBPMutation) WhereP(ps ...func(*sql.Selector)) {
p := make([]predicate.HIBP, len(ps))
for i := range ps {
p[i] = ps[i]
}
m.Where(p...)
}
// Op returns the operation name.
func (m *HIBPMutation) Op() Op {
return m.op
}
// SetOp allows setting the mutation operation.
func (m *HIBPMutation) SetOp(op Op) {
m.op = op
}
// Type returns the node type of this mutation (HIBP).
func (m *HIBPMutation) 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 *HIBPMutation) Fields() []string {
fields := make([]string, 0, 15)
if m.name != nil {
fields = append(fields, hibp.FieldName)
}
if m.domain != nil {
fields = append(fields, hibp.FieldDomain)
}
if m.breach_date != nil {
fields = append(fields, hibp.FieldBreachDate)
}
if m.added_date != nil {
fields = append(fields, hibp.FieldAddedDate)
}
if m.modified_date != nil {
fields = append(fields, hibp.FieldModifiedDate)
}
if m.pwn_count != nil {
fields = append(fields, hibp.FieldPwnCount)
}
if m.description != nil {
fields = append(fields, hibp.FieldDescription)
}
if m.dataclasses != nil {
fields = append(fields, hibp.FieldDataclasses)
}
if m.is_verified != nil {
fields = append(fields, hibp.FieldIsVerified)
}
if m.is_fabricated != nil {
fields = append(fields, hibp.FieldIsFabricated)
}
if m.is_sensitive != nil {
fields = append(fields, hibp.FieldIsSensitive)
}
if m.is_retired != nil {
fields = append(fields, hibp.FieldIsRetired)
}
if m.is_spamList != nil {
fields = append(fields, hibp.FieldIsSpamList)
}
if m.is_malware != nil {
fields = append(fields, hibp.FieldIsMalware)
}
if m.logo != nil {
fields = append(fields, hibp.FieldLogo)
}
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 *HIBPMutation) Field(name string) (ent.Value, bool) {
switch name {
case hibp.FieldName:
return m.Name()
case hibp.FieldDomain:
return m.Domain()
case hibp.FieldBreachDate:
return m.BreachDate()
case hibp.FieldAddedDate:
return m.AddedDate()
case hibp.FieldModifiedDate:
return m.ModifiedDate()
case hibp.FieldPwnCount:
return m.PwnCount()
case hibp.FieldDescription:
return m.Description()
case hibp.FieldDataclasses:
return m.Dataclasses()
case hibp.FieldIsVerified:
return m.IsVerified()
case hibp.FieldIsFabricated:
return m.IsFabricated()
case hibp.FieldIsSensitive:
return m.IsSensitive()
case hibp.FieldIsRetired:
return m.IsRetired()
case hibp.FieldIsSpamList:
return m.IsSpamList()
case hibp.FieldIsMalware:
return m.IsMalware()
case hibp.FieldLogo:
return m.Logo()
}
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 *HIBPMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
switch name {
case hibp.FieldName:
return m.OldName(ctx)
case hibp.FieldDomain:
return m.OldDomain(ctx)
case hibp.FieldBreachDate:
return m.OldBreachDate(ctx)
case hibp.FieldAddedDate:
return m.OldAddedDate(ctx)
case hibp.FieldModifiedDate:
return m.OldModifiedDate(ctx)
case hibp.FieldPwnCount:
return m.OldPwnCount(ctx)
case hibp.FieldDescription:
return m.OldDescription(ctx)
case hibp.FieldDataclasses:
return m.OldDataclasses(ctx)
case hibp.FieldIsVerified:
return m.OldIsVerified(ctx)
case hibp.FieldIsFabricated:
return m.OldIsFabricated(ctx)
case hibp.FieldIsSensitive:
return m.OldIsSensitive(ctx)
case hibp.FieldIsRetired:
return m.OldIsRetired(ctx)
case hibp.FieldIsSpamList:
return m.OldIsSpamList(ctx)
case hibp.FieldIsMalware:
return m.OldIsMalware(ctx)
case hibp.FieldLogo:
return m.OldLogo(ctx)
}
return nil, fmt.Errorf("unknown HIBP 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 *HIBPMutation) SetField(name string, value ent.Value) error {
switch name {
case hibp.FieldName:
v, ok := value.(string)
if !ok {
return fmt.Errorf("unexpected type %T for field %s", value, name)
}
m.SetName(v)
return nil
case hibp.FieldDomain:
v, ok := value.(string)
if !ok {
return fmt.Errorf("unexpected type %T for field %s", value, name)
}
m.SetDomain(v)
return nil
case hibp.FieldBreachDate:
v, ok := value.(time.Time)
if !ok {
return fmt.Errorf("unexpected type %T for field %s", value, name)
}
m.SetBreachDate(v)
return nil
case hibp.FieldAddedDate:
v, ok := value.(time.Time)
if !ok {
return fmt.Errorf("unexpected type %T for field %s", value, name)
}
m.SetAddedDate(v)
return nil
case hibp.FieldModifiedDate:
v, ok := value.(time.Time)
if !ok {
return fmt.Errorf("unexpected type %T for field %s", value, name)
}
m.SetModifiedDate(v)
return nil
case hibp.FieldPwnCount:
v, ok := value.(int)
if !ok {
return fmt.Errorf("unexpected type %T for field %s", value, name)
}
m.SetPwnCount(v)
return nil
case hibp.FieldDescription:
v, ok := value.(string)
if !ok {
return fmt.Errorf("unexpected type %T for field %s", value, name)
}
m.SetDescription(v)
return nil
case hibp.FieldDataclasses:
v, ok := value.([]string)
if !ok {
return fmt.Errorf("unexpected type %T for field %s", value, name)
}
m.SetDataclasses(v)
return nil
case hibp.FieldIsVerified:
v, ok := value.(bool)
if !ok {
return fmt.Errorf("unexpected type %T for field %s", value, name)
}
m.SetIsVerified(v)
return nil
case hibp.FieldIsFabricated:
v, ok := value.(bool)
if !ok {
return fmt.Errorf("unexpected type %T for field %s", value, name)
}
m.SetIsFabricated(v)
return nil
case hibp.FieldIsSensitive:
v, ok := value.(bool)
if !ok {
return fmt.Errorf("unexpected type %T for field %s", value, name)
}
m.SetIsSensitive(v)
return nil
case hibp.FieldIsRetired:
v, ok := value.(bool)
if !ok {
return fmt.Errorf("unexpected type %T for field %s", value, name)
}
m.SetIsRetired(v)
return nil
case hibp.FieldIsSpamList:
v, ok := value.(bool)
if !ok {
return fmt.Errorf("unexpected type %T for field %s", value, name)
}
m.SetIsSpamList(v)
return nil
case hibp.FieldIsMalware:
v, ok := value.(bool)
if !ok {
return fmt.Errorf("unexpected type %T for field %s", value, name)
}
m.SetIsMalware(v)
return nil
case hibp.FieldLogo:
v, ok := value.(string)
if !ok {
return fmt.Errorf("unexpected type %T for field %s", value, name)
}
m.SetLogo(v)
return nil
}
return fmt.Errorf("unknown HIBP field %s", name)
}
// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *HIBPMutation) AddedFields() []string {
var fields []string
if m.addpwn_count != nil {
fields = append(fields, hibp.FieldPwnCount)
}
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 *HIBPMutation) AddedField(name string) (ent.Value, bool) {
switch name {
case hibp.FieldPwnCount:
return m.AddedPwnCount()
}
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 *HIBPMutation) AddField(name string, value ent.Value) error {
switch name {
case hibp.FieldPwnCount:
v, ok := value.(int)
if !ok {
return fmt.Errorf("unexpected type %T for field %s", value, name)
}
m.AddPwnCount(v)
return nil
}
return fmt.Errorf("unknown HIBP numeric field %s", name)
}
// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *HIBPMutation) ClearedFields() []string {
return nil
}
// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *HIBPMutation) 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 *HIBPMutation) ClearField(name string) error {
return fmt.Errorf("unknown HIBP 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 *HIBPMutation) ResetField(name string) error {
switch name {
case hibp.FieldName:
m.ResetName()
return nil
case hibp.FieldDomain:
m.ResetDomain()
return nil
case hibp.FieldBreachDate:
m.ResetBreachDate()
return nil
case hibp.FieldAddedDate:
m.ResetAddedDate()
return nil
case hibp.FieldModifiedDate:
m.ResetModifiedDate()
return nil
case hibp.FieldPwnCount:
m.ResetPwnCount()
return nil
case hibp.FieldDescription:
m.ResetDescription()
return nil
case hibp.FieldDataclasses:
m.ResetDataclasses()
return nil
case hibp.FieldIsVerified:
m.ResetIsVerified()
return nil
case hibp.FieldIsFabricated:
m.ResetIsFabricated()
return nil
case hibp.FieldIsSensitive:
m.ResetIsSensitive()
return nil
case hibp.FieldIsRetired:
m.ResetIsRetired()
return nil
case hibp.FieldIsSpamList:
m.ResetIsSpamList()
return nil
case hibp.FieldIsMalware:
m.ResetIsMalware()
return nil
case hibp.FieldLogo:
m.ResetLogo()
return nil
}
return fmt.Errorf("unknown HIBP field %s", name)
}
// AddedEdges returns all edge names that were set/added in this mutation.
func (m *HIBPMutation) 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 *HIBPMutation) AddedIDs(name string) []ent.Value {
return nil
}
// RemovedEdges returns all edge names that were removed in this mutation.
func (m *HIBPMutation) 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 *HIBPMutation) RemovedIDs(name string) []ent.Value {
return nil
}
// ClearedEdges returns all edge names that were cleared in this mutation.
func (m *HIBPMutation) 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 *HIBPMutation) 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 *HIBPMutation) ClearEdge(name string) error {
return fmt.Errorf("unknown HIBP 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 *HIBPMutation) ResetEdge(name string) error {
return fmt.Errorf("unknown HIBP edge %s", name)
}
// UserMutation represents an operation that mutates the User nodes in the graph.
type UserMutation struct {
config
op Op
typ string
id *uuid.UUID
username *string
email *string
password *string
is_admin *bool
is_active *bool
created_at *time.Time
updated_at *time.Time
clearedFields map[string]struct{}
done bool
oldValue func(context.Context) (*User, error)
predicates []predicate.User
}
var _ ent.Mutation = (*UserMutation)(nil)
// userOption allows management of the mutation configuration using functional options.
type userOption func(*UserMutation)
// newUserMutation creates new mutation for the User entity.
func newUserMutation(c config, op Op, opts ...userOption) *UserMutation {
m := &UserMutation{
config: c,
op: op,
typ: TypeUser,
clearedFields: make(map[string]struct{}),
}
for _, opt := range opts {
opt(m)
}
return m
}
// withUserID sets the ID field of the mutation.
func withUserID(id uuid.UUID) userOption {
return func(m *UserMutation) {
var (
err error
once sync.Once
value *User
)
m.oldValue = func(ctx context.Context) (*User, error) {
once.Do(func() {
if m.done {
err = errors.New("querying old values post mutation is not allowed")
} else {
value, err = m.Client().User.Get(ctx, id)
}
})
return value, err
}
m.id = &id
}
}
// withUser sets the old User of the mutation.
func withUser(node *User) userOption {
return func(m *UserMutation) {
m.oldValue = func(context.Context) (*User, 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 UserMutation) 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 UserMutation) 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 User entities.
func (m *UserMutation) SetID(id uuid.UUID) {
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 *UserMutation) ID() (id uuid.UUID, 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 *UserMutation) IDs(ctx context.Context) ([]uuid.UUID, error) {
switch {
case m.op.Is(OpUpdateOne | OpDeleteOne):
id, exists := m.ID()
if exists {
return []uuid.UUID{id}, nil
}
fallthrough
case m.op.Is(OpUpdate | OpDelete):
return m.Client().User.Query().Where(m.predicates...).IDs(ctx)
default:
return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
}
}
// SetUsername sets the "username" field.
func (m *UserMutation) SetUsername(s string) {
m.username = &s
}
// Username returns the value of the "username" field in the mutation.
func (m *UserMutation) Username() (r string, exists bool) {
v := m.username
if v == nil {
return
}
return *v, true
}
// OldUsername returns the old "username" field's value of the User entity.
// If the User 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 *UserMutation) OldUsername(ctx context.Context) (v string, err error) {
if !m.op.Is(OpUpdateOne) {
return v, errors.New("OldUsername is only allowed on UpdateOne operations")
}
if m.id == nil || m.oldValue == nil {
return v, errors.New("OldUsername requires an ID field in the mutation")
}
oldValue, err := m.oldValue(ctx)
if err != nil {
return v, fmt.Errorf("querying old value for OldUsername: %w", err)
}
return oldValue.Username, nil
}
// ResetUsername resets all changes to the "username" field.
func (m *UserMutation) ResetUsername() {
m.username = nil
}
// SetEmail sets the "email" field.
func (m *UserMutation) SetEmail(s string) {
m.email = &s
}
// Email returns the value of the "email" field in the mutation.
func (m *UserMutation) Email() (r string, exists bool) {
v := m.email
if v == nil {
return
}
return *v, true
}
// OldEmail returns the old "email" field's value of the User entity.
// If the User 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 *UserMutation) OldEmail(ctx context.Context) (v string, err error) {
if !m.op.Is(OpUpdateOne) {
return v, errors.New("OldEmail is only allowed on UpdateOne operations")
}
if m.id == nil || m.oldValue == nil {
return v, errors.New("OldEmail requires an ID field in the mutation")
}
oldValue, err := m.oldValue(ctx)
if err != nil {
return v, fmt.Errorf("querying old value for OldEmail: %w", err)
}
return oldValue.Email, nil
}
// ResetEmail resets all changes to the "email" field.
func (m *UserMutation) ResetEmail() {
m.email = nil
}
// SetPassword sets the "password" field.
func (m *UserMutation) SetPassword(s string) {
m.password = &s
}
// Password returns the value of the "password" field in the mutation.
func (m *UserMutation) Password() (r string, exists bool) {
v := m.password
if v == nil {
return
}
return *v, true
}
// OldPassword returns the old "password" field's value of the User entity.
// If the User 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 *UserMutation) OldPassword(ctx context.Context) (v string, err error) {
if !m.op.Is(OpUpdateOne) {
return v, errors.New("OldPassword is only allowed on UpdateOne operations")
}
if m.id == nil || m.oldValue == nil {
return v, errors.New("OldPassword requires an ID field in the mutation")
}
oldValue, err := m.oldValue(ctx)
if err != nil {
return v, fmt.Errorf("querying old value for OldPassword: %w", err)
}
return oldValue.Password, nil
}
// ResetPassword resets all changes to the "password" field.
func (m *UserMutation) ResetPassword() {
m.password = nil
}
// SetIsAdmin sets the "is_admin" field.
func (m *UserMutation) SetIsAdmin(b bool) {
m.is_admin = &b
}
// IsAdmin returns the value of the "is_admin" field in the mutation.
func (m *UserMutation) IsAdmin() (r bool, exists bool) {
v := m.is_admin
if v == nil {
return
}
return *v, true
}
// OldIsAdmin returns the old "is_admin" field's value of the User entity.
// If the User 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 *UserMutation) OldIsAdmin(ctx context.Context) (v bool, err error) {
if !m.op.Is(OpUpdateOne) {
return v, errors.New("OldIsAdmin is only allowed on UpdateOne operations")
}
if m.id == nil || m.oldValue == nil {
return v, errors.New("OldIsAdmin requires an ID field in the mutation")
}
oldValue, err := m.oldValue(ctx)
if err != nil {
return v, fmt.Errorf("querying old value for OldIsAdmin: %w", err)
}
return oldValue.IsAdmin, nil
}
// ResetIsAdmin resets all changes to the "is_admin" field.
func (m *UserMutation) ResetIsAdmin() {
m.is_admin = nil
}
// SetIsActive sets the "is_active" field.
func (m *UserMutation) SetIsActive(b bool) {
m.is_active = &b
}
// IsActive returns the value of the "is_active" field in the mutation.
func (m *UserMutation) IsActive() (r bool, exists bool) {
v := m.is_active
if v == nil {
return
}
return *v, true
}
// OldIsActive returns the old "is_active" field's value of the User entity.
// If the User 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 *UserMutation) OldIsActive(ctx context.Context) (v bool, err error) {
if !m.op.Is(OpUpdateOne) {
return v, errors.New("OldIsActive is only allowed on UpdateOne operations")
}
if m.id == nil || m.oldValue == nil {
return v, errors.New("OldIsActive requires an ID field in the mutation")
}
oldValue, err := m.oldValue(ctx)
if err != nil {
return v, fmt.Errorf("querying old value for OldIsActive: %w", err)
}
return oldValue.IsActive, nil
}
// ResetIsActive resets all changes to the "is_active" field.
func (m *UserMutation) ResetIsActive() {
m.is_active = nil
}
// SetCreatedAt sets the "created_at" field.
func (m *UserMutation) SetCreatedAt(t time.Time) {
m.created_at = &t
}
// CreatedAt returns the value of the "created_at" field in the mutation.
func (m *UserMutation) 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 User entity.
// If the User 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 *UserMutation) 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 *UserMutation) ResetCreatedAt() {
m.created_at = nil
}
// SetUpdatedAt sets the "updated_at" field.
func (m *UserMutation) SetUpdatedAt(t time.Time) {
m.updated_at = &t
}
// UpdatedAt returns the value of the "updated_at" field in the mutation.
func (m *UserMutation) 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 User entity.
// If the User 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 *UserMutation) 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 *UserMutation) ResetUpdatedAt() {
m.updated_at = nil
}
// Where appends a list predicates to the UserMutation builder.
func (m *UserMutation) Where(ps ...predicate.User) {
m.predicates = append(m.predicates, ps...)
}
// WhereP appends storage-level predicates to the UserMutation builder. Using this method,
// users can use type-assertion to append predicates that do not depend on any generated package.
func (m *UserMutation) WhereP(ps ...func(*sql.Selector)) {
p := make([]predicate.User, len(ps))
for i := range ps {
p[i] = ps[i]
}
m.Where(p...)
}
// Op returns the operation name.
func (m *UserMutation) Op() Op {
return m.op
}
// SetOp allows setting the mutation operation.
func (m *UserMutation) SetOp(op Op) {
m.op = op
}
// Type returns the node type of this mutation (User).
func (m *UserMutation) 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 *UserMutation) Fields() []string {
fields := make([]string, 0, 7)
if m.username != nil {
fields = append(fields, user.FieldUsername)
}
if m.email != nil {
fields = append(fields, user.FieldEmail)
}
if m.password != nil {
fields = append(fields, user.FieldPassword)
}
if m.is_admin != nil {
fields = append(fields, user.FieldIsAdmin)
}
if m.is_active != nil {
fields = append(fields, user.FieldIsActive)
}
if m.created_at != nil {
fields = append(fields, user.FieldCreatedAt)
}
if m.updated_at != nil {
fields = append(fields, user.FieldUpdatedAt)
}
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 *UserMutation) Field(name string) (ent.Value, bool) {
switch name {
case user.FieldUsername:
return m.Username()
case user.FieldEmail:
return m.Email()
case user.FieldPassword:
return m.Password()
case user.FieldIsAdmin:
return m.IsAdmin()
case user.FieldIsActive:
return m.IsActive()
case user.FieldCreatedAt:
return m.CreatedAt()
case user.FieldUpdatedAt:
return m.UpdatedAt()
}
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 *UserMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
switch name {
case user.FieldUsername:
return m.OldUsername(ctx)
case user.FieldEmail:
return m.OldEmail(ctx)
case user.FieldPassword:
return m.OldPassword(ctx)
case user.FieldIsAdmin:
return m.OldIsAdmin(ctx)
case user.FieldIsActive:
return m.OldIsActive(ctx)
case user.FieldCreatedAt:
return m.OldCreatedAt(ctx)
case user.FieldUpdatedAt:
return m.OldUpdatedAt(ctx)
}
return nil, fmt.Errorf("unknown User 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 *UserMutation) SetField(name string, value ent.Value) error {
switch name {
case user.FieldUsername:
v, ok := value.(string)
if !ok {
return fmt.Errorf("unexpected type %T for field %s", value, name)
}
m.SetUsername(v)
return nil
case user.FieldEmail:
v, ok := value.(string)
if !ok {
return fmt.Errorf("unexpected type %T for field %s", value, name)
}
m.SetEmail(v)
return nil
case user.FieldPassword:
v, ok := value.(string)
if !ok {
return fmt.Errorf("unexpected type %T for field %s", value, name)
}
m.SetPassword(v)
return nil
case user.FieldIsAdmin:
v, ok := value.(bool)
if !ok {
return fmt.Errorf("unexpected type %T for field %s", value, name)
}
m.SetIsAdmin(v)
return nil
case user.FieldIsActive:
v, ok := value.(bool)
if !ok {
return fmt.Errorf("unexpected type %T for field %s", value, name)
}
m.SetIsActive(v)
return nil
case user.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 user.FieldUpdatedAt:
v, ok := value.(time.Time)
if !ok {
return fmt.Errorf("unexpected type %T for field %s", value, name)
}
m.SetUpdatedAt(v)
return nil
}
return fmt.Errorf("unknown User field %s", name)
}
// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *UserMutation) 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 *UserMutation) 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 *UserMutation) AddField(name string, value ent.Value) error {
switch name {
}
return fmt.Errorf("unknown User numeric field %s", name)
}
// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *UserMutation) ClearedFields() []string {
return nil
}
// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *UserMutation) 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 *UserMutation) ClearField(name string) error {
return fmt.Errorf("unknown User 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 *UserMutation) ResetField(name string) error {
switch name {
case user.FieldUsername:
m.ResetUsername()
return nil
case user.FieldEmail:
m.ResetEmail()
return nil
case user.FieldPassword:
m.ResetPassword()
return nil
case user.FieldIsAdmin:
m.ResetIsAdmin()
return nil
case user.FieldIsActive:
m.ResetIsActive()
return nil
case user.FieldCreatedAt:
m.ResetCreatedAt()
return nil
case user.FieldUpdatedAt:
m.ResetUpdatedAt()
return nil
}
return fmt.Errorf("unknown User field %s", name)
}
// AddedEdges returns all edge names that were set/added in this mutation.
func (m *UserMutation) 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 *UserMutation) AddedIDs(name string) []ent.Value {
return nil
}
// RemovedEdges returns all edge names that were removed in this mutation.
func (m *UserMutation) 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 *UserMutation) RemovedIDs(name string) []ent.Value {
return nil
}
// ClearedEdges returns all edge names that were cleared in this mutation.
func (m *UserMutation) 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 *UserMutation) 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 *UserMutation) ClearEdge(name string) error {
return fmt.Errorf("unknown User 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 *UserMutation) ResetEdge(name string) error {
return fmt.Errorf("unknown User edge %s", name)
}