accountuser_create.go

// Code generated by ent, DO NOT EDIT.

package ent

import (
	"context"
	"errors"
	"fmt"

	"entgo.io/ent/dialect/sql"
	"entgo.io/ent/dialect/sql/sqlgraph"
	"entgo.io/ent/schema/field"
	"github.com/lalifeier/vvgo-mall/app/account/service/internal/data/ent/accountuser"
)

// AccountUserCreate is the builder for creating a AccountUser entity.
type AccountUserCreate struct {
	config
	mutation *AccountUserMutation
	hooks    []Hook
	conflict []sql.ConflictOption
}

// SetUsername sets the "username" field.
func (auc *AccountUserCreate) SetUsername(s string) *AccountUserCreate {
	auc.mutation.SetUsername(s)
	return auc
}

// SetNillableUsername sets the "username" field if the given value is not nil.
func (auc *AccountUserCreate) SetNillableUsername(s *string) *AccountUserCreate {
	if s != nil {
		auc.SetUsername(*s)
	}
	return auc
}

// SetPhone sets the "phone" field.
func (auc *AccountUserCreate) SetPhone(s string) *AccountUserCreate {
	auc.mutation.SetPhone(s)
	return auc
}

// SetNillablePhone sets the "phone" field if the given value is not nil.
func (auc *AccountUserCreate) SetNillablePhone(s *string) *AccountUserCreate {
	if s != nil {
		auc.SetPhone(*s)
	}
	return auc
}

// SetEmail sets the "email" field.
func (auc *AccountUserCreate) SetEmail(s string) *AccountUserCreate {
	auc.mutation.SetEmail(s)
	return auc
}

// SetNillableEmail sets the "email" field if the given value is not nil.
func (auc *AccountUserCreate) SetNillableEmail(s *string) *AccountUserCreate {
	if s != nil {
		auc.SetEmail(*s)
	}
	return auc
}

// SetPassword sets the "password" field.
func (auc *AccountUserCreate) SetPassword(s string) *AccountUserCreate {
	auc.mutation.SetPassword(s)
	return auc
}

// SetNillablePassword sets the "password" field if the given value is not nil.
func (auc *AccountUserCreate) SetNillablePassword(s *string) *AccountUserCreate {
	if s != nil {
		auc.SetPassword(*s)
	}
	return auc
}

// SetCreateAt sets the "create_at" field.
func (auc *AccountUserCreate) SetCreateAt(i int64) *AccountUserCreate {
	auc.mutation.SetCreateAt(i)
	return auc
}

// SetNillableCreateAt sets the "create_at" field if the given value is not nil.
func (auc *AccountUserCreate) SetNillableCreateAt(i *int64) *AccountUserCreate {
	if i != nil {
		auc.SetCreateAt(*i)
	}
	return auc
}

// SetCreateIPAt sets the "create_ip_at" field.
func (auc *AccountUserCreate) SetCreateIPAt(s string) *AccountUserCreate {
	auc.mutation.SetCreateIPAt(s)
	return auc
}

// SetNillableCreateIPAt sets the "create_ip_at" field if the given value is not nil.
func (auc *AccountUserCreate) SetNillableCreateIPAt(s *string) *AccountUserCreate {
	if s != nil {
		auc.SetCreateIPAt(*s)
	}
	return auc
}

// SetLastLoginAt sets the "last_login_at" field.
func (auc *AccountUserCreate) SetLastLoginAt(i int64) *AccountUserCreate {
	auc.mutation.SetLastLoginAt(i)
	return auc
}

// SetNillableLastLoginAt sets the "last_login_at" field if the given value is not nil.
func (auc *AccountUserCreate) SetNillableLastLoginAt(i *int64) *AccountUserCreate {
	if i != nil {
		auc.SetLastLoginAt(*i)
	}
	return auc
}

// SetLastLoginIPAt sets the "last_login_ip_at" field.
func (auc *AccountUserCreate) SetLastLoginIPAt(s string) *AccountUserCreate {
	auc.mutation.SetLastLoginIPAt(s)
	return auc
}

// SetNillableLastLoginIPAt sets the "last_login_ip_at" field if the given value is not nil.
func (auc *AccountUserCreate) SetNillableLastLoginIPAt(s *string) *AccountUserCreate {
	if s != nil {
		auc.SetLastLoginIPAt(*s)
	}
	return auc
}

// SetLoginTimes sets the "login_times" field.
func (auc *AccountUserCreate) SetLoginTimes(i int64) *AccountUserCreate {
	auc.mutation.SetLoginTimes(i)
	return auc
}

// SetNillableLoginTimes sets the "login_times" field if the given value is not nil.
func (auc *AccountUserCreate) SetNillableLoginTimes(i *int64) *AccountUserCreate {
	if i != nil {
		auc.SetLoginTimes(*i)
	}
	return auc
}

// SetStatus sets the "status" field.
func (auc *AccountUserCreate) SetStatus(i int8) *AccountUserCreate {
	auc.mutation.SetStatus(i)
	return auc
}

// SetNillableStatus sets the "status" field if the given value is not nil.
func (auc *AccountUserCreate) SetNillableStatus(i *int8) *AccountUserCreate {
	if i != nil {
		auc.SetStatus(*i)
	}
	return auc
}

// SetID sets the "id" field.
func (auc *AccountUserCreate) SetID(u uint32) *AccountUserCreate {
	auc.mutation.SetID(u)
	return auc
}

// Mutation returns the AccountUserMutation object of the builder.
func (auc *AccountUserCreate) Mutation() *AccountUserMutation {
	return auc.mutation
}

// Save creates the AccountUser in the database.
func (auc *AccountUserCreate) Save(ctx context.Context) (*AccountUser, error) {
	auc.defaults()
	return withHooks[*AccountUser, AccountUserMutation](ctx, auc.sqlSave, auc.mutation, auc.hooks)
}

// SaveX calls Save and panics if Save returns an error.
func (auc *AccountUserCreate) SaveX(ctx context.Context) *AccountUser {
	v, err := auc.Save(ctx)
	if err != nil {
		panic(err)
	}
	return v
}

// Exec executes the query.
func (auc *AccountUserCreate) Exec(ctx context.Context) error {
	_, err := auc.Save(ctx)
	return err
}

// ExecX is like Exec, but panics if an error occurs.
func (auc *AccountUserCreate) ExecX(ctx context.Context) {
	if err := auc.Exec(ctx); err != nil {
		panic(err)
	}
}

// defaults sets the default values of the builder before save.
func (auc *AccountUserCreate) defaults() {
	if _, ok := auc.mutation.Username(); !ok {
		v := accountuser.DefaultUsername
		auc.mutation.SetUsername(v)
	}
	if _, ok := auc.mutation.Phone(); !ok {
		v := accountuser.DefaultPhone
		auc.mutation.SetPhone(v)
	}
	if _, ok := auc.mutation.Email(); !ok {
		v := accountuser.DefaultEmail
		auc.mutation.SetEmail(v)
	}
	if _, ok := auc.mutation.Password(); !ok {
		v := accountuser.DefaultPassword
		auc.mutation.SetPassword(v)
	}
	if _, ok := auc.mutation.CreateAt(); !ok {
		v := accountuser.DefaultCreateAt
		auc.mutation.SetCreateAt(v)
	}
	if _, ok := auc.mutation.CreateIPAt(); !ok {
		v := accountuser.DefaultCreateIPAt
		auc.mutation.SetCreateIPAt(v)
	}
	if _, ok := auc.mutation.LastLoginAt(); !ok {
		v := accountuser.DefaultLastLoginAt
		auc.mutation.SetLastLoginAt(v)
	}
	if _, ok := auc.mutation.LastLoginIPAt(); !ok {
		v := accountuser.DefaultLastLoginIPAt
		auc.mutation.SetLastLoginIPAt(v)
	}
	if _, ok := auc.mutation.LoginTimes(); !ok {
		v := accountuser.DefaultLoginTimes
		auc.mutation.SetLoginTimes(v)
	}
	if _, ok := auc.mutation.Status(); !ok {
		v := accountuser.DefaultStatus
		auc.mutation.SetStatus(v)
	}
}

// check runs all checks and user-defined validators on the builder.
func (auc *AccountUserCreate) check() error {
	if _, ok := auc.mutation.CreateAt(); !ok {
		return &ValidationError{Name: "create_at", err: errors.New(`ent: missing required field "AccountUser.create_at"`)}
	}
	if _, ok := auc.mutation.CreateIPAt(); !ok {
		return &ValidationError{Name: "create_ip_at", err: errors.New(`ent: missing required field "AccountUser.create_ip_at"`)}
	}
	if _, ok := auc.mutation.LastLoginAt(); !ok {
		return &ValidationError{Name: "last_login_at", err: errors.New(`ent: missing required field "AccountUser.last_login_at"`)}
	}
	if _, ok := auc.mutation.LastLoginIPAt(); !ok {
		return &ValidationError{Name: "last_login_ip_at", err: errors.New(`ent: missing required field "AccountUser.last_login_ip_at"`)}
	}
	if _, ok := auc.mutation.LoginTimes(); !ok {
		return &ValidationError{Name: "login_times", err: errors.New(`ent: missing required field "AccountUser.login_times"`)}
	}
	if _, ok := auc.mutation.Status(); !ok {
		return &ValidationError{Name: "status", err: errors.New(`ent: missing required field "AccountUser.status"`)}
	}
	return nil
}

func (auc *AccountUserCreate) sqlSave(ctx context.Context) (*AccountUser, error) {
	if err := auc.check(); err != nil {
		return nil, err
	}
	_node, _spec := auc.createSpec()
	if err := sqlgraph.CreateNode(ctx, auc.driver, _spec); err != nil {
		if sqlgraph.IsConstraintError(err) {
			err = &ConstraintError{msg: err.Error(), wrap: err}
		}
		return nil, err
	}
	if _spec.ID.Value != _node.ID {
		id := _spec.ID.Value.(int64)
		_node.ID = uint32(id)
	}
	auc.mutation.id = &_node.ID
	auc.mutation.done = true
	return _node, nil
}

func (auc *AccountUserCreate) createSpec() (*AccountUser, *sqlgraph.CreateSpec) {
	var (
		_node = &AccountUser{config: auc.config}
		_spec = sqlgraph.NewCreateSpec(accountuser.Table, sqlgraph.NewFieldSpec(accountuser.FieldID, field.TypeUint32))
	)
	_spec.OnConflict = auc.conflict
	if id, ok := auc.mutation.ID(); ok {
		_node.ID = id
		_spec.ID.Value = id
	}
	if value, ok := auc.mutation.Username(); ok {
		_spec.SetField(accountuser.FieldUsername, field.TypeString, value)
		_node.Username = &value
	}
	if value, ok := auc.mutation.Phone(); ok {
		_spec.SetField(accountuser.FieldPhone, field.TypeString, value)
		_node.Phone = &value
	}
	if value, ok := auc.mutation.Email(); ok {
		_spec.SetField(accountuser.FieldEmail, field.TypeString, value)
		_node.Email = &value
	}
	if value, ok := auc.mutation.Password(); ok {
		_spec.SetField(accountuser.FieldPassword, field.TypeString, value)
		_node.Password = &value
	}
	if value, ok := auc.mutation.CreateAt(); ok {
		_spec.SetField(accountuser.FieldCreateAt, field.TypeInt64, value)
		_node.CreateAt = value
	}
	if value, ok := auc.mutation.CreateIPAt(); ok {
		_spec.SetField(accountuser.FieldCreateIPAt, field.TypeString, value)
		_node.CreateIPAt = value
	}
	if value, ok := auc.mutation.LastLoginAt(); ok {
		_spec.SetField(accountuser.FieldLastLoginAt, field.TypeInt64, value)
		_node.LastLoginAt = value
	}
	if value, ok := auc.mutation.LastLoginIPAt(); ok {
		_spec.SetField(accountuser.FieldLastLoginIPAt, field.TypeString, value)
		_node.LastLoginIPAt = value
	}
	if value, ok := auc.mutation.LoginTimes(); ok {
		_spec.SetField(accountuser.FieldLoginTimes, field.TypeInt64, value)
		_node.LoginTimes = value
	}
	if value, ok := auc.mutation.Status(); ok {
		_spec.SetField(accountuser.FieldStatus, field.TypeInt8, value)
		_node.Status = value
	}
	return _node, _spec
}

// OnConflict allows configuring the `ON CONFLICT` / `ON DUPLICATE KEY` clause
// of the `INSERT` statement. For example:
//
//	client.AccountUser.Create().
//		SetUsername(v).
//		OnConflict(
//			// Update the row with the new values
//			// the was proposed for insertion.
//			sql.ResolveWithNewValues(),
//		).
//		// Override some of the fields with custom
//		// update values.
//		Update(func(u *ent.AccountUserUpsert) {
//			SetUsername(v+v).
//		}).
//		Exec(ctx)
func (auc *AccountUserCreate) OnConflict(opts ...sql.ConflictOption) *AccountUserUpsertOne {
	auc.conflict = opts
	return &AccountUserUpsertOne{
		create: auc,
	}
}

// OnConflictColumns calls `OnConflict` and configures the columns
// as conflict target. Using this option is equivalent to using:
//
//	client.AccountUser.Create().
//		OnConflict(sql.ConflictColumns(columns...)).
//		Exec(ctx)
func (auc *AccountUserCreate) OnConflictColumns(columns ...string) *AccountUserUpsertOne {
	auc.conflict = append(auc.conflict, sql.ConflictColumns(columns...))
	return &AccountUserUpsertOne{
		create: auc,
	}
}

type (
	// AccountUserUpsertOne is the builder for "upsert"-ing
	//  one AccountUser node.
	AccountUserUpsertOne struct {
		create *AccountUserCreate
	}

	// AccountUserUpsert is the "OnConflict" setter.
	AccountUserUpsert struct {
		*sql.UpdateSet
	}
)

// SetUsername sets the "username" field.
func (u *AccountUserUpsert) SetUsername(v string) *AccountUserUpsert {
	u.Set(accountuser.FieldUsername, v)
	return u
}

// UpdateUsername sets the "username" field to the value that was provided on create.
func (u *AccountUserUpsert) UpdateUsername() *AccountUserUpsert {
	u.SetExcluded(accountuser.FieldUsername)
	return u
}

// ClearUsername clears the value of the "username" field.
func (u *AccountUserUpsert) ClearUsername() *AccountUserUpsert {
	u.SetNull(accountuser.FieldUsername)
	return u
}

// SetPhone sets the "phone" field.
func (u *AccountUserUpsert) SetPhone(v string) *AccountUserUpsert {
	u.Set(accountuser.FieldPhone, v)
	return u
}

// UpdatePhone sets the "phone" field to the value that was provided on create.
func (u *AccountUserUpsert) UpdatePhone() *AccountUserUpsert {
	u.SetExcluded(accountuser.FieldPhone)
	return u
}

// ClearPhone clears the value of the "phone" field.
func (u *AccountUserUpsert) ClearPhone() *AccountUserUpsert {
	u.SetNull(accountuser.FieldPhone)
	return u
}

// SetEmail sets the "email" field.
func (u *AccountUserUpsert) SetEmail(v string) *AccountUserUpsert {
	u.Set(accountuser.FieldEmail, v)
	return u
}

// UpdateEmail sets the "email" field to the value that was provided on create.
func (u *AccountUserUpsert) UpdateEmail() *AccountUserUpsert {
	u.SetExcluded(accountuser.FieldEmail)
	return u
}

// ClearEmail clears the value of the "email" field.
func (u *AccountUserUpsert) ClearEmail() *AccountUserUpsert {
	u.SetNull(accountuser.FieldEmail)
	return u
}

// SetPassword sets the "password" field.
func (u *AccountUserUpsert) SetPassword(v string) *AccountUserUpsert {
	u.Set(accountuser.FieldPassword, v)
	return u
}

// UpdatePassword sets the "password" field to the value that was provided on create.
func (u *AccountUserUpsert) UpdatePassword() *AccountUserUpsert {
	u.SetExcluded(accountuser.FieldPassword)
	return u
}

// ClearPassword clears the value of the "password" field.
func (u *AccountUserUpsert) ClearPassword() *AccountUserUpsert {
	u.SetNull(accountuser.FieldPassword)
	return u
}

// SetCreateAt sets the "create_at" field.
func (u *AccountUserUpsert) SetCreateAt(v int64) *AccountUserUpsert {
	u.Set(accountuser.FieldCreateAt, v)
	return u
}

// UpdateCreateAt sets the "create_at" field to the value that was provided on create.
func (u *AccountUserUpsert) UpdateCreateAt() *AccountUserUpsert {
	u.SetExcluded(accountuser.FieldCreateAt)
	return u
}

// AddCreateAt adds v to the "create_at" field.
func (u *AccountUserUpsert) AddCreateAt(v int64) *AccountUserUpsert {
	u.Add(accountuser.FieldCreateAt, v)
	return u
}

// SetCreateIPAt sets the "create_ip_at" field.
func (u *AccountUserUpsert) SetCreateIPAt(v string) *AccountUserUpsert {
	u.Set(accountuser.FieldCreateIPAt, v)
	return u
}

// UpdateCreateIPAt sets the "create_ip_at" field to the value that was provided on create.
func (u *AccountUserUpsert) UpdateCreateIPAt() *AccountUserUpsert {
	u.SetExcluded(accountuser.FieldCreateIPAt)
	return u
}

// SetLastLoginAt sets the "last_login_at" field.
func (u *AccountUserUpsert) SetLastLoginAt(v int64) *AccountUserUpsert {
	u.Set(accountuser.FieldLastLoginAt, v)
	return u
}

// UpdateLastLoginAt sets the "last_login_at" field to the value that was provided on create.
func (u *AccountUserUpsert) UpdateLastLoginAt() *AccountUserUpsert {
	u.SetExcluded(accountuser.FieldLastLoginAt)
	return u
}

// AddLastLoginAt adds v to the "last_login_at" field.
func (u *AccountUserUpsert) AddLastLoginAt(v int64) *AccountUserUpsert {
	u.Add(accountuser.FieldLastLoginAt, v)
	return u
}

// SetLastLoginIPAt sets the "last_login_ip_at" field.
func (u *AccountUserUpsert) SetLastLoginIPAt(v string) *AccountUserUpsert {
	u.Set(accountuser.FieldLastLoginIPAt, v)
	return u
}

// UpdateLastLoginIPAt sets the "last_login_ip_at" field to the value that was provided on create.
func (u *AccountUserUpsert) UpdateLastLoginIPAt() *AccountUserUpsert {
	u.SetExcluded(accountuser.FieldLastLoginIPAt)
	return u
}

// SetLoginTimes sets the "login_times" field.
func (u *AccountUserUpsert) SetLoginTimes(v int64) *AccountUserUpsert {
	u.Set(accountuser.FieldLoginTimes, v)
	return u
}

// UpdateLoginTimes sets the "login_times" field to the value that was provided on create.
func (u *AccountUserUpsert) UpdateLoginTimes() *AccountUserUpsert {
	u.SetExcluded(accountuser.FieldLoginTimes)
	return u
}

// AddLoginTimes adds v to the "login_times" field.
func (u *AccountUserUpsert) AddLoginTimes(v int64) *AccountUserUpsert {
	u.Add(accountuser.FieldLoginTimes, v)
	return u
}

// SetStatus sets the "status" field.
func (u *AccountUserUpsert) SetStatus(v int8) *AccountUserUpsert {
	u.Set(accountuser.FieldStatus, v)
	return u
}

// UpdateStatus sets the "status" field to the value that was provided on create.
func (u *AccountUserUpsert) UpdateStatus() *AccountUserUpsert {
	u.SetExcluded(accountuser.FieldStatus)
	return u
}

// AddStatus adds v to the "status" field.
func (u *AccountUserUpsert) AddStatus(v int8) *AccountUserUpsert {
	u.Add(accountuser.FieldStatus, v)
	return u
}

// UpdateNewValues updates the mutable fields using the new values that were set on create except the ID field.
// Using this option is equivalent to using:
//
//	client.AccountUser.Create().
//		OnConflict(
//			sql.ResolveWithNewValues(),
//			sql.ResolveWith(func(u *sql.UpdateSet) {
//				u.SetIgnore(accountuser.FieldID)
//			}),
//		).
//		Exec(ctx)
func (u *AccountUserUpsertOne) UpdateNewValues() *AccountUserUpsertOne {
	u.create.conflict = append(u.create.conflict, sql.ResolveWithNewValues())
	u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(s *sql.UpdateSet) {
		if _, exists := u.create.mutation.ID(); exists {
			s.SetIgnore(accountuser.FieldID)
		}
	}))
	return u
}

// Ignore sets each column to itself in case of conflict.
// Using this option is equivalent to using:
//
//	client.AccountUser.Create().
//	    OnConflict(sql.ResolveWithIgnore()).
//	    Exec(ctx)
func (u *AccountUserUpsertOne) Ignore() *AccountUserUpsertOne {
	u.create.conflict = append(u.create.conflict, sql.ResolveWithIgnore())
	return u
}

// DoNothing configures the conflict_action to `DO NOTHING`.
// Supported only by SQLite and PostgreSQL.
func (u *AccountUserUpsertOne) DoNothing() *AccountUserUpsertOne {
	u.create.conflict = append(u.create.conflict, sql.DoNothing())
	return u
}

// Update allows overriding fields `UPDATE` values. See the AccountUserCreate.OnConflict
// documentation for more info.
func (u *AccountUserUpsertOne) Update(set func(*AccountUserUpsert)) *AccountUserUpsertOne {
	u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(update *sql.UpdateSet) {
		set(&AccountUserUpsert{UpdateSet: update})
	}))
	return u
}

// SetUsername sets the "username" field.
func (u *AccountUserUpsertOne) SetUsername(v string) *AccountUserUpsertOne {
	return u.Update(func(s *AccountUserUpsert) {
		s.SetUsername(v)
	})
}

// UpdateUsername sets the "username" field to the value that was provided on create.
func (u *AccountUserUpsertOne) UpdateUsername() *AccountUserUpsertOne {
	return u.Update(func(s *AccountUserUpsert) {
		s.UpdateUsername()
	})
}

// ClearUsername clears the value of the "username" field.
func (u *AccountUserUpsertOne) ClearUsername() *AccountUserUpsertOne {
	return u.Update(func(s *AccountUserUpsert) {
		s.ClearUsername()
	})
}

// SetPhone sets the "phone" field.
func (u *AccountUserUpsertOne) SetPhone(v string) *AccountUserUpsertOne {
	return u.Update(func(s *AccountUserUpsert) {
		s.SetPhone(v)
	})
}

// UpdatePhone sets the "phone" field to the value that was provided on create.
func (u *AccountUserUpsertOne) UpdatePhone() *AccountUserUpsertOne {
	return u.Update(func(s *AccountUserUpsert) {
		s.UpdatePhone()
	})
}

// ClearPhone clears the value of the "phone" field.
func (u *AccountUserUpsertOne) ClearPhone() *AccountUserUpsertOne {
	return u.Update(func(s *AccountUserUpsert) {
		s.ClearPhone()
	})
}

// SetEmail sets the "email" field.
func (u *AccountUserUpsertOne) SetEmail(v string) *AccountUserUpsertOne {
	return u.Update(func(s *AccountUserUpsert) {
		s.SetEmail(v)
	})
}

// UpdateEmail sets the "email" field to the value that was provided on create.
func (u *AccountUserUpsertOne) UpdateEmail() *AccountUserUpsertOne {
	return u.Update(func(s *AccountUserUpsert) {
		s.UpdateEmail()
	})
}

// ClearEmail clears the value of the "email" field.
func (u *AccountUserUpsertOne) ClearEmail() *AccountUserUpsertOne {
	return u.Update(func(s *AccountUserUpsert) {
		s.ClearEmail()
	})
}

// SetPassword sets the "password" field.
func (u *AccountUserUpsertOne) SetPassword(v string) *AccountUserUpsertOne {
	return u.Update(func(s *AccountUserUpsert) {
		s.SetPassword(v)
	})
}

// UpdatePassword sets the "password" field to the value that was provided on create.
func (u *AccountUserUpsertOne) UpdatePassword() *AccountUserUpsertOne {
	return u.Update(func(s *AccountUserUpsert) {
		s.UpdatePassword()
	})
}

// ClearPassword clears the value of the "password" field.
func (u *AccountUserUpsertOne) ClearPassword() *AccountUserUpsertOne {
	return u.Update(func(s *AccountUserUpsert) {
		s.ClearPassword()
	})
}

// SetCreateAt sets the "create_at" field.
func (u *AccountUserUpsertOne) SetCreateAt(v int64) *AccountUserUpsertOne {
	return u.Update(func(s *AccountUserUpsert) {
		s.SetCreateAt(v)
	})
}

// AddCreateAt adds v to the "create_at" field.
func (u *AccountUserUpsertOne) AddCreateAt(v int64) *AccountUserUpsertOne {
	return u.Update(func(s *AccountUserUpsert) {
		s.AddCreateAt(v)
	})
}

// UpdateCreateAt sets the "create_at" field to the value that was provided on create.
func (u *AccountUserUpsertOne) UpdateCreateAt() *AccountUserUpsertOne {
	return u.Update(func(s *AccountUserUpsert) {
		s.UpdateCreateAt()
	})
}

// SetCreateIPAt sets the "create_ip_at" field.
func (u *AccountUserUpsertOne) SetCreateIPAt(v string) *AccountUserUpsertOne {
	return u.Update(func(s *AccountUserUpsert) {
		s.SetCreateIPAt(v)
	})
}

// UpdateCreateIPAt sets the "create_ip_at" field to the value that was provided on create.
func (u *AccountUserUpsertOne) UpdateCreateIPAt() *AccountUserUpsertOne {
	return u.Update(func(s *AccountUserUpsert) {
		s.UpdateCreateIPAt()
	})
}

// SetLastLoginAt sets the "last_login_at" field.
func (u *AccountUserUpsertOne) SetLastLoginAt(v int64) *AccountUserUpsertOne {
	return u.Update(func(s *AccountUserUpsert) {
		s.SetLastLoginAt(v)
	})
}

// AddLastLoginAt adds v to the "last_login_at" field.
func (u *AccountUserUpsertOne) AddLastLoginAt(v int64) *AccountUserUpsertOne {
	return u.Update(func(s *AccountUserUpsert) {
		s.AddLastLoginAt(v)
	})
}

// UpdateLastLoginAt sets the "last_login_at" field to the value that was provided on create.
func (u *AccountUserUpsertOne) UpdateLastLoginAt() *AccountUserUpsertOne {
	return u.Update(func(s *AccountUserUpsert) {
		s.UpdateLastLoginAt()
	})
}

// SetLastLoginIPAt sets the "last_login_ip_at" field.
func (u *AccountUserUpsertOne) SetLastLoginIPAt(v string) *AccountUserUpsertOne {
	return u.Update(func(s *AccountUserUpsert) {
		s.SetLastLoginIPAt(v)
	})
}

// UpdateLastLoginIPAt sets the "last_login_ip_at" field to the value that was provided on create.
func (u *AccountUserUpsertOne) UpdateLastLoginIPAt() *AccountUserUpsertOne {
	return u.Update(func(s *AccountUserUpsert) {
		s.UpdateLastLoginIPAt()
	})
}

// SetLoginTimes sets the "login_times" field.
func (u *AccountUserUpsertOne) SetLoginTimes(v int64) *AccountUserUpsertOne {
	return u.Update(func(s *AccountUserUpsert) {
		s.SetLoginTimes(v)
	})
}

// AddLoginTimes adds v to the "login_times" field.
func (u *AccountUserUpsertOne) AddLoginTimes(v int64) *AccountUserUpsertOne {
	return u.Update(func(s *AccountUserUpsert) {
		s.AddLoginTimes(v)
	})
}

// UpdateLoginTimes sets the "login_times" field to the value that was provided on create.
func (u *AccountUserUpsertOne) UpdateLoginTimes() *AccountUserUpsertOne {
	return u.Update(func(s *AccountUserUpsert) {
		s.UpdateLoginTimes()
	})
}

// SetStatus sets the "status" field.
func (u *AccountUserUpsertOne) SetStatus(v int8) *AccountUserUpsertOne {
	return u.Update(func(s *AccountUserUpsert) {
		s.SetStatus(v)
	})
}

// AddStatus adds v to the "status" field.
func (u *AccountUserUpsertOne) AddStatus(v int8) *AccountUserUpsertOne {
	return u.Update(func(s *AccountUserUpsert) {
		s.AddStatus(v)
	})
}

// UpdateStatus sets the "status" field to the value that was provided on create.
func (u *AccountUserUpsertOne) UpdateStatus() *AccountUserUpsertOne {
	return u.Update(func(s *AccountUserUpsert) {
		s.UpdateStatus()
	})
}

// Exec executes the query.
func (u *AccountUserUpsertOne) Exec(ctx context.Context) error {
	if len(u.create.conflict) == 0 {
		return errors.New("ent: missing options for AccountUserCreate.OnConflict")
	}
	return u.create.Exec(ctx)
}

// ExecX is like Exec, but panics if an error occurs.
func (u *AccountUserUpsertOne) ExecX(ctx context.Context) {
	if err := u.create.Exec(ctx); err != nil {
		panic(err)
	}
}

// Exec executes the UPSERT query and returns the inserted/updated ID.
func (u *AccountUserUpsertOne) ID(ctx context.Context) (id uint32, err error) {
	node, err := u.create.Save(ctx)
	if err != nil {
		return id, err
	}
	return node.ID, nil
}

// IDX is like ID, but panics if an error occurs.
func (u *AccountUserUpsertOne) IDX(ctx context.Context) uint32 {
	id, err := u.ID(ctx)
	if err != nil {
		panic(err)
	}
	return id
}

// AccountUserCreateBulk is the builder for creating many AccountUser entities in bulk.
type AccountUserCreateBulk struct {
	config
	builders []*AccountUserCreate
	conflict []sql.ConflictOption
}

// Save creates the AccountUser entities in the database.
func (aucb *AccountUserCreateBulk) Save(ctx context.Context) ([]*AccountUser, error) {
	specs := make([]*sqlgraph.CreateSpec, len(aucb.builders))
	nodes := make([]*AccountUser, len(aucb.builders))
	mutators := make([]Mutator, len(aucb.builders))
	for i := range aucb.builders {
		func(i int, root context.Context) {
			builder := aucb.builders[i]
			builder.defaults()
			var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
				mutation, ok := m.(*AccountUserMutation)
				if !ok {
					return nil, fmt.Errorf("unexpected mutation type %T", m)
				}
				if err := builder.check(); err != nil {
					return nil, err
				}
				builder.mutation = mutation
				nodes[i], specs[i] = builder.createSpec()
				var err error
				if i < len(mutators)-1 {
					_, err = mutators[i+1].Mutate(root, aucb.builders[i+1].mutation)
				} else {
					spec := &sqlgraph.BatchCreateSpec{Nodes: specs}
					spec.OnConflict = aucb.conflict
					// Invoke the actual operation on the latest mutation in the chain.
					if err = sqlgraph.BatchCreate(ctx, aucb.driver, spec); err != nil {
						if sqlgraph.IsConstraintError(err) {
							err = &ConstraintError{msg: err.Error(), wrap: err}
						}
					}
				}
				if err != nil {
					return nil, err
				}
				mutation.id = &nodes[i].ID
				if specs[i].ID.Value != nil && nodes[i].ID == 0 {
					id := specs[i].ID.Value.(int64)
					nodes[i].ID = uint32(id)
				}
				mutation.done = true
				return nodes[i], nil
			})
			for i := len(builder.hooks) - 1; i >= 0; i-- {
				mut = builder.hooks[i](mut)
			}
			mutators[i] = mut
		}(i, ctx)
	}
	if len(mutators) > 0 {
		if _, err := mutators[0].Mutate(ctx, aucb.builders[0].mutation); err != nil {
			return nil, err
		}
	}
	return nodes, nil
}

// SaveX is like Save, but panics if an error occurs.
func (aucb *AccountUserCreateBulk) SaveX(ctx context.Context) []*AccountUser {
	v, err := aucb.Save(ctx)
	if err != nil {
		panic(err)
	}
	return v
}

// Exec executes the query.
func (aucb *AccountUserCreateBulk) Exec(ctx context.Context) error {
	_, err := aucb.Save(ctx)
	return err
}

// ExecX is like Exec, but panics if an error occurs.
func (aucb *AccountUserCreateBulk) ExecX(ctx context.Context) {
	if err := aucb.Exec(ctx); err != nil {
		panic(err)
	}
}

// OnConflict allows configuring the `ON CONFLICT` / `ON DUPLICATE KEY` clause
// of the `INSERT` statement. For example:
//
//	client.AccountUser.CreateBulk(builders...).
//		OnConflict(
//			// Update the row with the new values
//			// the was proposed for insertion.
//			sql.ResolveWithNewValues(),
//		).
//		// Override some of the fields with custom
//		// update values.
//		Update(func(u *ent.AccountUserUpsert) {
//			SetUsername(v+v).
//		}).
//		Exec(ctx)
func (aucb *AccountUserCreateBulk) OnConflict(opts ...sql.ConflictOption) *AccountUserUpsertBulk {
	aucb.conflict = opts
	return &AccountUserUpsertBulk{
		create: aucb,
	}
}

// OnConflictColumns calls `OnConflict` and configures the columns
// as conflict target. Using this option is equivalent to using:
//
//	client.AccountUser.Create().
//		OnConflict(sql.ConflictColumns(columns...)).
//		Exec(ctx)
func (aucb *AccountUserCreateBulk) OnConflictColumns(columns ...string) *AccountUserUpsertBulk {
	aucb.conflict = append(aucb.conflict, sql.ConflictColumns(columns...))
	return &AccountUserUpsertBulk{
		create: aucb,
	}
}

// AccountUserUpsertBulk is the builder for "upsert"-ing
// a bulk of AccountUser nodes.
type AccountUserUpsertBulk struct {
	create *AccountUserCreateBulk
}

// UpdateNewValues updates the mutable fields using the new values that
// were set on create. Using this option is equivalent to using:
//
//	client.AccountUser.Create().
//		OnConflict(
//			sql.ResolveWithNewValues(),
//			sql.ResolveWith(func(u *sql.UpdateSet) {
//				u.SetIgnore(accountuser.FieldID)
//			}),
//		).
//		Exec(ctx)
func (u *AccountUserUpsertBulk) UpdateNewValues() *AccountUserUpsertBulk {
	u.create.conflict = append(u.create.conflict, sql.ResolveWithNewValues())
	u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(s *sql.UpdateSet) {
		for _, b := range u.create.builders {
			if _, exists := b.mutation.ID(); exists {
				s.SetIgnore(accountuser.FieldID)
			}
		}
	}))
	return u
}

// Ignore sets each column to itself in case of conflict.
// Using this option is equivalent to using:
//
//	client.AccountUser.Create().
//		OnConflict(sql.ResolveWithIgnore()).
//		Exec(ctx)
func (u *AccountUserUpsertBulk) Ignore() *AccountUserUpsertBulk {
	u.create.conflict = append(u.create.conflict, sql.ResolveWithIgnore())
	return u
}

// DoNothing configures the conflict_action to `DO NOTHING`.
// Supported only by SQLite and PostgreSQL.
func (u *AccountUserUpsertBulk) DoNothing() *AccountUserUpsertBulk {
	u.create.conflict = append(u.create.conflict, sql.DoNothing())
	return u
}

// Update allows overriding fields `UPDATE` values. See the AccountUserCreateBulk.OnConflict
// documentation for more info.
func (u *AccountUserUpsertBulk) Update(set func(*AccountUserUpsert)) *AccountUserUpsertBulk {
	u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(update *sql.UpdateSet) {
		set(&AccountUserUpsert{UpdateSet: update})
	}))
	return u
}

// SetUsername sets the "username" field.
func (u *AccountUserUpsertBulk) SetUsername(v string) *AccountUserUpsertBulk {
	return u.Update(func(s *AccountUserUpsert) {
		s.SetUsername(v)
	})
}

// UpdateUsername sets the "username" field to the value that was provided on create.
func (u *AccountUserUpsertBulk) UpdateUsername() *AccountUserUpsertBulk {
	return u.Update(func(s *AccountUserUpsert) {
		s.UpdateUsername()
	})
}

// ClearUsername clears the value of the "username" field.
func (u *AccountUserUpsertBulk) ClearUsername() *AccountUserUpsertBulk {
	return u.Update(func(s *AccountUserUpsert) {
		s.ClearUsername()
	})
}

// SetPhone sets the "phone" field.
func (u *AccountUserUpsertBulk) SetPhone(v string) *AccountUserUpsertBulk {
	return u.Update(func(s *AccountUserUpsert) {
		s.SetPhone(v)
	})
}

// UpdatePhone sets the "phone" field to the value that was provided on create.
func (u *AccountUserUpsertBulk) UpdatePhone() *AccountUserUpsertBulk {
	return u.Update(func(s *AccountUserUpsert) {
		s.UpdatePhone()
	})
}

// ClearPhone clears the value of the "phone" field.
func (u *AccountUserUpsertBulk) ClearPhone() *AccountUserUpsertBulk {
	return u.Update(func(s *AccountUserUpsert) {
		s.ClearPhone()
	})
}

// SetEmail sets the "email" field.
func (u *AccountUserUpsertBulk) SetEmail(v string) *AccountUserUpsertBulk {
	return u.Update(func(s *AccountUserUpsert) {
		s.SetEmail(v)
	})
}

// UpdateEmail sets the "email" field to the value that was provided on create.
func (u *AccountUserUpsertBulk) UpdateEmail() *AccountUserUpsertBulk {
	return u.Update(func(s *AccountUserUpsert) {
		s.UpdateEmail()
	})
}

// ClearEmail clears the value of the "email" field.
func (u *AccountUserUpsertBulk) ClearEmail() *AccountUserUpsertBulk {
	return u.Update(func(s *AccountUserUpsert) {
		s.ClearEmail()
	})
}

// SetPassword sets the "password" field.
func (u *AccountUserUpsertBulk) SetPassword(v string) *AccountUserUpsertBulk {
	return u.Update(func(s *AccountUserUpsert) {
		s.SetPassword(v)
	})
}

// UpdatePassword sets the "password" field to the value that was provided on create.
func (u *AccountUserUpsertBulk) UpdatePassword() *AccountUserUpsertBulk {
	return u.Update(func(s *AccountUserUpsert) {
		s.UpdatePassword()
	})
}

// ClearPassword clears the value of the "password" field.
func (u *AccountUserUpsertBulk) ClearPassword() *AccountUserUpsertBulk {
	return u.Update(func(s *AccountUserUpsert) {
		s.ClearPassword()
	})
}

// SetCreateAt sets the "create_at" field.
func (u *AccountUserUpsertBulk) SetCreateAt(v int64) *AccountUserUpsertBulk {
	return u.Update(func(s *AccountUserUpsert) {
		s.SetCreateAt(v)
	})
}

// AddCreateAt adds v to the "create_at" field.
func (u *AccountUserUpsertBulk) AddCreateAt(v int64) *AccountUserUpsertBulk {
	return u.Update(func(s *AccountUserUpsert) {
		s.AddCreateAt(v)
	})
}

// UpdateCreateAt sets the "create_at" field to the value that was provided on create.
func (u *AccountUserUpsertBulk) UpdateCreateAt() *AccountUserUpsertBulk {
	return u.Update(func(s *AccountUserUpsert) {
		s.UpdateCreateAt()
	})
}

// SetCreateIPAt sets the "create_ip_at" field.
func (u *AccountUserUpsertBulk) SetCreateIPAt(v string) *AccountUserUpsertBulk {
	return u.Update(func(s *AccountUserUpsert) {
		s.SetCreateIPAt(v)
	})
}

// UpdateCreateIPAt sets the "create_ip_at" field to the value that was provided on create.
func (u *AccountUserUpsertBulk) UpdateCreateIPAt() *AccountUserUpsertBulk {
	return u.Update(func(s *AccountUserUpsert) {
		s.UpdateCreateIPAt()
	})
}

// SetLastLoginAt sets the "last_login_at" field.
func (u *AccountUserUpsertBulk) SetLastLoginAt(v int64) *AccountUserUpsertBulk {
	return u.Update(func(s *AccountUserUpsert) {
		s.SetLastLoginAt(v)
	})
}

// AddLastLoginAt adds v to the "last_login_at" field.
func (u *AccountUserUpsertBulk) AddLastLoginAt(v int64) *AccountUserUpsertBulk {
	return u.Update(func(s *AccountUserUpsert) {
		s.AddLastLoginAt(v)
	})
}

// UpdateLastLoginAt sets the "last_login_at" field to the value that was provided on create.
func (u *AccountUserUpsertBulk) UpdateLastLoginAt() *AccountUserUpsertBulk {
	return u.Update(func(s *AccountUserUpsert) {
		s.UpdateLastLoginAt()
	})
}

// SetLastLoginIPAt sets the "last_login_ip_at" field.
func (u *AccountUserUpsertBulk) SetLastLoginIPAt(v string) *AccountUserUpsertBulk {
	return u.Update(func(s *AccountUserUpsert) {
		s.SetLastLoginIPAt(v)
	})
}

// UpdateLastLoginIPAt sets the "last_login_ip_at" field to the value that was provided on create.
func (u *AccountUserUpsertBulk) UpdateLastLoginIPAt() *AccountUserUpsertBulk {
	return u.Update(func(s *AccountUserUpsert) {
		s.UpdateLastLoginIPAt()
	})
}

// SetLoginTimes sets the "login_times" field.
func (u *AccountUserUpsertBulk) SetLoginTimes(v int64) *AccountUserUpsertBulk {
	return u.Update(func(s *AccountUserUpsert) {
		s.SetLoginTimes(v)
	})
}

// AddLoginTimes adds v to the "login_times" field.
func (u *AccountUserUpsertBulk) AddLoginTimes(v int64) *AccountUserUpsertBulk {
	return u.Update(func(s *AccountUserUpsert) {
		s.AddLoginTimes(v)
	})
}

// UpdateLoginTimes sets the "login_times" field to the value that was provided on create.
func (u *AccountUserUpsertBulk) UpdateLoginTimes() *AccountUserUpsertBulk {
	return u.Update(func(s *AccountUserUpsert) {
		s.UpdateLoginTimes()
	})
}

// SetStatus sets the "status" field.
func (u *AccountUserUpsertBulk) SetStatus(v int8) *AccountUserUpsertBulk {
	return u.Update(func(s *AccountUserUpsert) {
		s.SetStatus(v)
	})
}

// AddStatus adds v to the "status" field.
func (u *AccountUserUpsertBulk) AddStatus(v int8) *AccountUserUpsertBulk {
	return u.Update(func(s *AccountUserUpsert) {
		s.AddStatus(v)
	})
}

// UpdateStatus sets the "status" field to the value that was provided on create.
func (u *AccountUserUpsertBulk) UpdateStatus() *AccountUserUpsertBulk {
	return u.Update(func(s *AccountUserUpsert) {
		s.UpdateStatus()
	})
}

// Exec executes the query.
func (u *AccountUserUpsertBulk) Exec(ctx context.Context) error {
	for i, b := range u.create.builders {
		if len(b.conflict) != 0 {
			return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the AccountUserCreateBulk instead", i)
		}
	}
	if len(u.create.conflict) == 0 {
		return errors.New("ent: missing options for AccountUserCreateBulk.OnConflict")
	}
	return u.create.Exec(ctx)
}

// ExecX is like Exec, but panics if an error occurs.
func (u *AccountUserUpsertBulk) ExecX(ctx context.Context) {
	if err := u.create.Exec(ctx); err != nil {
		panic(err)
	}
}