person_update.go

// Code generated by ent, DO NOT EDIT.

package data

import (
	"context"
	"errors"
	"fmt"
	"time"

	"entgo.io/ent/dialect/sql"
	"entgo.io/ent/dialect/sql/sqlgraph"
	"entgo.io/ent/schema/field"
	"github.com/avptp/brain/internal/generated/data/authentication"
	"github.com/avptp/brain/internal/generated/data/authorization"
	"github.com/avptp/brain/internal/generated/data/person"
	"github.com/avptp/brain/internal/generated/data/predicate"
	"github.com/google/uuid"
)

// PersonUpdate is the builder for updating Person entities.
type PersonUpdate struct {
	config
	hooks    []Hook
	mutation *PersonMutation
}

// Where appends a list predicates to the PersonUpdate builder.
func (pu *PersonUpdate) Where(ps ...predicate.Person) *PersonUpdate {
	pu.mutation.Where(ps...)
	return pu
}

// SetStripeID sets the "stripe_id" field.
func (pu *PersonUpdate) SetStripeID(s string) *PersonUpdate {
	pu.mutation.SetStripeID(s)
	return pu
}

// SetNillableStripeID sets the "stripe_id" field if the given value is not nil.
func (pu *PersonUpdate) SetNillableStripeID(s *string) *PersonUpdate {
	if s != nil {
		pu.SetStripeID(*s)
	}
	return pu
}

// ClearStripeID clears the value of the "stripe_id" field.
func (pu *PersonUpdate) ClearStripeID() *PersonUpdate {
	pu.mutation.ClearStripeID()
	return pu
}

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

// SetEmailVerifiedAt sets the "email_verified_at" field.
func (pu *PersonUpdate) SetEmailVerifiedAt(t time.Time) *PersonUpdate {
	pu.mutation.SetEmailVerifiedAt(t)
	return pu
}

// SetNillableEmailVerifiedAt sets the "email_verified_at" field if the given value is not nil.
func (pu *PersonUpdate) SetNillableEmailVerifiedAt(t *time.Time) *PersonUpdate {
	if t != nil {
		pu.SetEmailVerifiedAt(*t)
	}
	return pu
}

// ClearEmailVerifiedAt clears the value of the "email_verified_at" field.
func (pu *PersonUpdate) ClearEmailVerifiedAt() *PersonUpdate {
	pu.mutation.ClearEmailVerifiedAt()
	return pu
}

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

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

// ClearPhone clears the value of the "phone" field.
func (pu *PersonUpdate) ClearPhone() *PersonUpdate {
	pu.mutation.ClearPhone()
	return pu
}

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

// SetTaxID sets the "tax_id" field.
func (pu *PersonUpdate) SetTaxID(s string) *PersonUpdate {
	pu.mutation.SetTaxID(s)
	return pu
}

// SetFirstName sets the "first_name" field.
func (pu *PersonUpdate) SetFirstName(s string) *PersonUpdate {
	pu.mutation.SetFirstName(s)
	return pu
}

// SetLastName sets the "last_name" field.
func (pu *PersonUpdate) SetLastName(s string) *PersonUpdate {
	pu.mutation.SetLastName(s)
	return pu
}

// SetNillableLastName sets the "last_name" field if the given value is not nil.
func (pu *PersonUpdate) SetNillableLastName(s *string) *PersonUpdate {
	if s != nil {
		pu.SetLastName(*s)
	}
	return pu
}

// ClearLastName clears the value of the "last_name" field.
func (pu *PersonUpdate) ClearLastName() *PersonUpdate {
	pu.mutation.ClearLastName()
	return pu
}

// SetLanguage sets the "language" field.
func (pu *PersonUpdate) SetLanguage(s string) *PersonUpdate {
	pu.mutation.SetLanguage(s)
	return pu
}

// SetBirthdate sets the "birthdate" field.
func (pu *PersonUpdate) SetBirthdate(t time.Time) *PersonUpdate {
	pu.mutation.SetBirthdate(t)
	return pu
}

// SetNillableBirthdate sets the "birthdate" field if the given value is not nil.
func (pu *PersonUpdate) SetNillableBirthdate(t *time.Time) *PersonUpdate {
	if t != nil {
		pu.SetBirthdate(*t)
	}
	return pu
}

// ClearBirthdate clears the value of the "birthdate" field.
func (pu *PersonUpdate) ClearBirthdate() *PersonUpdate {
	pu.mutation.ClearBirthdate()
	return pu
}

// SetGender sets the "gender" field.
func (pu *PersonUpdate) SetGender(pe person.Gender) *PersonUpdate {
	pu.mutation.SetGender(pe)
	return pu
}

// SetNillableGender sets the "gender" field if the given value is not nil.
func (pu *PersonUpdate) SetNillableGender(pe *person.Gender) *PersonUpdate {
	if pe != nil {
		pu.SetGender(*pe)
	}
	return pu
}

// ClearGender clears the value of the "gender" field.
func (pu *PersonUpdate) ClearGender() *PersonUpdate {
	pu.mutation.ClearGender()
	return pu
}

// SetAddress sets the "address" field.
func (pu *PersonUpdate) SetAddress(s string) *PersonUpdate {
	pu.mutation.SetAddress(s)
	return pu
}

// SetNillableAddress sets the "address" field if the given value is not nil.
func (pu *PersonUpdate) SetNillableAddress(s *string) *PersonUpdate {
	if s != nil {
		pu.SetAddress(*s)
	}
	return pu
}

// ClearAddress clears the value of the "address" field.
func (pu *PersonUpdate) ClearAddress() *PersonUpdate {
	pu.mutation.ClearAddress()
	return pu
}

// SetPostalCode sets the "postal_code" field.
func (pu *PersonUpdate) SetPostalCode(s string) *PersonUpdate {
	pu.mutation.SetPostalCode(s)
	return pu
}

// SetNillablePostalCode sets the "postal_code" field if the given value is not nil.
func (pu *PersonUpdate) SetNillablePostalCode(s *string) *PersonUpdate {
	if s != nil {
		pu.SetPostalCode(*s)
	}
	return pu
}

// ClearPostalCode clears the value of the "postal_code" field.
func (pu *PersonUpdate) ClearPostalCode() *PersonUpdate {
	pu.mutation.ClearPostalCode()
	return pu
}

// SetCity sets the "city" field.
func (pu *PersonUpdate) SetCity(s string) *PersonUpdate {
	pu.mutation.SetCity(s)
	return pu
}

// SetNillableCity sets the "city" field if the given value is not nil.
func (pu *PersonUpdate) SetNillableCity(s *string) *PersonUpdate {
	if s != nil {
		pu.SetCity(*s)
	}
	return pu
}

// ClearCity clears the value of the "city" field.
func (pu *PersonUpdate) ClearCity() *PersonUpdate {
	pu.mutation.ClearCity()
	return pu
}

// SetCountry sets the "country" field.
func (pu *PersonUpdate) SetCountry(s string) *PersonUpdate {
	pu.mutation.SetCountry(s)
	return pu
}

// SetNillableCountry sets the "country" field if the given value is not nil.
func (pu *PersonUpdate) SetNillableCountry(s *string) *PersonUpdate {
	if s != nil {
		pu.SetCountry(*s)
	}
	return pu
}

// ClearCountry clears the value of the "country" field.
func (pu *PersonUpdate) ClearCountry() *PersonUpdate {
	pu.mutation.ClearCountry()
	return pu
}

// SetSubscribed sets the "subscribed" field.
func (pu *PersonUpdate) SetSubscribed(b bool) *PersonUpdate {
	pu.mutation.SetSubscribed(b)
	return pu
}

// SetNillableSubscribed sets the "subscribed" field if the given value is not nil.
func (pu *PersonUpdate) SetNillableSubscribed(b *bool) *PersonUpdate {
	if b != nil {
		pu.SetSubscribed(*b)
	}
	return pu
}

// SetUpdatedAt sets the "updated_at" field.
func (pu *PersonUpdate) SetUpdatedAt(t time.Time) *PersonUpdate {
	pu.mutation.SetUpdatedAt(t)
	return pu
}

// AddAuthenticationIDs adds the "authentications" edge to the Authentication entity by IDs.
func (pu *PersonUpdate) AddAuthenticationIDs(ids ...uuid.UUID) *PersonUpdate {
	pu.mutation.AddAuthenticationIDs(ids...)
	return pu
}

// AddAuthentications adds the "authentications" edges to the Authentication entity.
func (pu *PersonUpdate) AddAuthentications(a ...*Authentication) *PersonUpdate {
	ids := make([]uuid.UUID, len(a))
	for i := range a {
		ids[i] = a[i].ID
	}
	return pu.AddAuthenticationIDs(ids...)
}

// AddAuthorizationIDs adds the "authorizations" edge to the Authorization entity by IDs.
func (pu *PersonUpdate) AddAuthorizationIDs(ids ...uuid.UUID) *PersonUpdate {
	pu.mutation.AddAuthorizationIDs(ids...)
	return pu
}

// AddAuthorizations adds the "authorizations" edges to the Authorization entity.
func (pu *PersonUpdate) AddAuthorizations(a ...*Authorization) *PersonUpdate {
	ids := make([]uuid.UUID, len(a))
	for i := range a {
		ids[i] = a[i].ID
	}
	return pu.AddAuthorizationIDs(ids...)
}

// Mutation returns the PersonMutation object of the builder.
func (pu *PersonUpdate) Mutation() *PersonMutation {
	return pu.mutation
}

// ClearAuthentications clears all "authentications" edges to the Authentication entity.
func (pu *PersonUpdate) ClearAuthentications() *PersonUpdate {
	pu.mutation.ClearAuthentications()
	return pu
}

// RemoveAuthenticationIDs removes the "authentications" edge to Authentication entities by IDs.
func (pu *PersonUpdate) RemoveAuthenticationIDs(ids ...uuid.UUID) *PersonUpdate {
	pu.mutation.RemoveAuthenticationIDs(ids...)
	return pu
}

// RemoveAuthentications removes "authentications" edges to Authentication entities.
func (pu *PersonUpdate) RemoveAuthentications(a ...*Authentication) *PersonUpdate {
	ids := make([]uuid.UUID, len(a))
	for i := range a {
		ids[i] = a[i].ID
	}
	return pu.RemoveAuthenticationIDs(ids...)
}

// ClearAuthorizations clears all "authorizations" edges to the Authorization entity.
func (pu *PersonUpdate) ClearAuthorizations() *PersonUpdate {
	pu.mutation.ClearAuthorizations()
	return pu
}

// RemoveAuthorizationIDs removes the "authorizations" edge to Authorization entities by IDs.
func (pu *PersonUpdate) RemoveAuthorizationIDs(ids ...uuid.UUID) *PersonUpdate {
	pu.mutation.RemoveAuthorizationIDs(ids...)
	return pu
}

// RemoveAuthorizations removes "authorizations" edges to Authorization entities.
func (pu *PersonUpdate) RemoveAuthorizations(a ...*Authorization) *PersonUpdate {
	ids := make([]uuid.UUID, len(a))
	for i := range a {
		ids[i] = a[i].ID
	}
	return pu.RemoveAuthorizationIDs(ids...)
}

// Save executes the query and returns the number of nodes affected by the update operation.
func (pu *PersonUpdate) Save(ctx context.Context) (int, error) {
	if err := pu.defaults(); err != nil {
		return 0, err
	}
	return withHooks(ctx, pu.sqlSave, pu.mutation, pu.hooks)
}

// SaveX is like Save, but panics if an error occurs.
func (pu *PersonUpdate) SaveX(ctx context.Context) int {
	affected, err := pu.Save(ctx)
	if err != nil {
		panic(err)
	}
	return affected
}

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

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

// defaults sets the default values of the builder before save.
func (pu *PersonUpdate) defaults() error {
	if _, ok := pu.mutation.UpdatedAt(); !ok {
		if person.UpdateDefaultUpdatedAt == nil {
			return fmt.Errorf("data: uninitialized person.UpdateDefaultUpdatedAt (forgotten import data/runtime?)")
		}
		v := person.UpdateDefaultUpdatedAt()
		pu.mutation.SetUpdatedAt(v)
	}
	return nil
}

// check runs all checks and user-defined validators on the builder.
func (pu *PersonUpdate) check() error {
	if v, ok := pu.mutation.Email(); ok {
		if err := person.EmailValidator(v); err != nil {
			return &ValidationError{Name: "email", err: fmt.Errorf(`data: validator failed for field "Person.email": %w`, err)}
		}
	}
	if v, ok := pu.mutation.Phone(); ok {
		if err := person.PhoneValidator(v); err != nil {
			return &ValidationError{Name: "phone", err: fmt.Errorf(`data: validator failed for field "Person.phone": %w`, err)}
		}
	}
	if v, ok := pu.mutation.TaxID(); ok {
		if err := person.TaxIDValidator(v); err != nil {
			return &ValidationError{Name: "tax_id", err: fmt.Errorf(`data: validator failed for field "Person.tax_id": %w`, err)}
		}
	}
	if v, ok := pu.mutation.FirstName(); ok {
		if err := person.FirstNameValidator(v); err != nil {
			return &ValidationError{Name: "first_name", err: fmt.Errorf(`data: validator failed for field "Person.first_name": %w`, err)}
		}
	}
	if v, ok := pu.mutation.LastName(); ok {
		if err := person.LastNameValidator(v); err != nil {
			return &ValidationError{Name: "last_name", err: fmt.Errorf(`data: validator failed for field "Person.last_name": %w`, err)}
		}
	}
	if v, ok := pu.mutation.Gender(); ok {
		if err := person.GenderValidator(v); err != nil {
			return &ValidationError{Name: "gender", err: fmt.Errorf(`data: validator failed for field "Person.gender": %w`, err)}
		}
	}
	if v, ok := pu.mutation.Address(); ok {
		if err := person.AddressValidator(v); err != nil {
			return &ValidationError{Name: "address", err: fmt.Errorf(`data: validator failed for field "Person.address": %w`, err)}
		}
	}
	if v, ok := pu.mutation.PostalCode(); ok {
		if err := person.PostalCodeValidator(v); err != nil {
			return &ValidationError{Name: "postal_code", err: fmt.Errorf(`data: validator failed for field "Person.postal_code": %w`, err)}
		}
	}
	if v, ok := pu.mutation.City(); ok {
		if err := person.CityValidator(v); err != nil {
			return &ValidationError{Name: "city", err: fmt.Errorf(`data: validator failed for field "Person.city": %w`, err)}
		}
	}
	if v, ok := pu.mutation.Country(); ok {
		if err := person.CountryValidator(v); err != nil {
			return &ValidationError{Name: "country", err: fmt.Errorf(`data: validator failed for field "Person.country": %w`, err)}
		}
	}
	return nil
}

func (pu *PersonUpdate) sqlSave(ctx context.Context) (n int, err error) {
	if err := pu.check(); err != nil {
		return n, err
	}
	_spec := sqlgraph.NewUpdateSpec(person.Table, person.Columns, sqlgraph.NewFieldSpec(person.FieldID, field.TypeUUID))
	if ps := pu.mutation.predicates; len(ps) > 0 {
		_spec.Predicate = func(selector *sql.Selector) {
			for i := range ps {
				ps[i](selector)
			}
		}
	}
	if value, ok := pu.mutation.StripeID(); ok {
		_spec.SetField(person.FieldStripeID, field.TypeString, value)
	}
	if pu.mutation.StripeIDCleared() {
		_spec.ClearField(person.FieldStripeID, field.TypeString)
	}
	if value, ok := pu.mutation.Email(); ok {
		_spec.SetField(person.FieldEmail, field.TypeString, value)
	}
	if value, ok := pu.mutation.EmailVerifiedAt(); ok {
		_spec.SetField(person.FieldEmailVerifiedAt, field.TypeTime, value)
	}
	if pu.mutation.EmailVerifiedAtCleared() {
		_spec.ClearField(person.FieldEmailVerifiedAt, field.TypeTime)
	}
	if value, ok := pu.mutation.Phone(); ok {
		_spec.SetField(person.FieldPhone, field.TypeString, value)
	}
	if pu.mutation.PhoneCleared() {
		_spec.ClearField(person.FieldPhone, field.TypeString)
	}
	if value, ok := pu.mutation.Password(); ok {
		_spec.SetField(person.FieldPassword, field.TypeString, value)
	}
	if value, ok := pu.mutation.TaxID(); ok {
		_spec.SetField(person.FieldTaxID, field.TypeString, value)
	}
	if value, ok := pu.mutation.FirstName(); ok {
		_spec.SetField(person.FieldFirstName, field.TypeString, value)
	}
	if value, ok := pu.mutation.LastName(); ok {
		_spec.SetField(person.FieldLastName, field.TypeString, value)
	}
	if pu.mutation.LastNameCleared() {
		_spec.ClearField(person.FieldLastName, field.TypeString)
	}
	if value, ok := pu.mutation.Language(); ok {
		_spec.SetField(person.FieldLanguage, field.TypeString, value)
	}
	if value, ok := pu.mutation.Birthdate(); ok {
		_spec.SetField(person.FieldBirthdate, field.TypeTime, value)
	}
	if pu.mutation.BirthdateCleared() {
		_spec.ClearField(person.FieldBirthdate, field.TypeTime)
	}
	if value, ok := pu.mutation.Gender(); ok {
		_spec.SetField(person.FieldGender, field.TypeEnum, value)
	}
	if pu.mutation.GenderCleared() {
		_spec.ClearField(person.FieldGender, field.TypeEnum)
	}
	if value, ok := pu.mutation.Address(); ok {
		_spec.SetField(person.FieldAddress, field.TypeString, value)
	}
	if pu.mutation.AddressCleared() {
		_spec.ClearField(person.FieldAddress, field.TypeString)
	}
	if value, ok := pu.mutation.PostalCode(); ok {
		_spec.SetField(person.FieldPostalCode, field.TypeString, value)
	}
	if pu.mutation.PostalCodeCleared() {
		_spec.ClearField(person.FieldPostalCode, field.TypeString)
	}
	if value, ok := pu.mutation.City(); ok {
		_spec.SetField(person.FieldCity, field.TypeString, value)
	}
	if pu.mutation.CityCleared() {
		_spec.ClearField(person.FieldCity, field.TypeString)
	}
	if value, ok := pu.mutation.Country(); ok {
		_spec.SetField(person.FieldCountry, field.TypeString, value)
	}
	if pu.mutation.CountryCleared() {
		_spec.ClearField(person.FieldCountry, field.TypeString)
	}
	if value, ok := pu.mutation.Subscribed(); ok {
		_spec.SetField(person.FieldSubscribed, field.TypeBool, value)
	}
	if value, ok := pu.mutation.UpdatedAt(); ok {
		_spec.SetField(person.FieldUpdatedAt, field.TypeTime, value)
	}
	if pu.mutation.AuthenticationsCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   person.AuthenticationsTable,
			Columns: []string{person.AuthenticationsColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(authentication.FieldID, field.TypeUUID),
			},
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := pu.mutation.RemovedAuthenticationsIDs(); len(nodes) > 0 && !pu.mutation.AuthenticationsCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   person.AuthenticationsTable,
			Columns: []string{person.AuthenticationsColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(authentication.FieldID, field.TypeUUID),
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := pu.mutation.AuthenticationsIDs(); len(nodes) > 0 {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   person.AuthenticationsTable,
			Columns: []string{person.AuthenticationsColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(authentication.FieldID, field.TypeUUID),
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Add = append(_spec.Edges.Add, edge)
	}
	if pu.mutation.AuthorizationsCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   person.AuthorizationsTable,
			Columns: []string{person.AuthorizationsColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(authorization.FieldID, field.TypeUUID),
			},
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := pu.mutation.RemovedAuthorizationsIDs(); len(nodes) > 0 && !pu.mutation.AuthorizationsCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   person.AuthorizationsTable,
			Columns: []string{person.AuthorizationsColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(authorization.FieldID, field.TypeUUID),
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := pu.mutation.AuthorizationsIDs(); len(nodes) > 0 {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   person.AuthorizationsTable,
			Columns: []string{person.AuthorizationsColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(authorization.FieldID, field.TypeUUID),
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Add = append(_spec.Edges.Add, edge)
	}
	if n, err = sqlgraph.UpdateNodes(ctx, pu.driver, _spec); err != nil {
		if _, ok := err.(*sqlgraph.NotFoundError); ok {
			err = &NotFoundError{person.Label}
		} else if sqlgraph.IsConstraintError(err) {
			err = &ConstraintError{msg: err.Error(), wrap: err}
		}
		return 0, err
	}
	pu.mutation.done = true
	return n, nil
}

// PersonUpdateOne is the builder for updating a single Person entity.
type PersonUpdateOne struct {
	config
	fields   []string
	hooks    []Hook
	mutation *PersonMutation
}

// SetStripeID sets the "stripe_id" field.
func (puo *PersonUpdateOne) SetStripeID(s string) *PersonUpdateOne {
	puo.mutation.SetStripeID(s)
	return puo
}

// SetNillableStripeID sets the "stripe_id" field if the given value is not nil.
func (puo *PersonUpdateOne) SetNillableStripeID(s *string) *PersonUpdateOne {
	if s != nil {
		puo.SetStripeID(*s)
	}
	return puo
}

// ClearStripeID clears the value of the "stripe_id" field.
func (puo *PersonUpdateOne) ClearStripeID() *PersonUpdateOne {
	puo.mutation.ClearStripeID()
	return puo
}

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

// SetEmailVerifiedAt sets the "email_verified_at" field.
func (puo *PersonUpdateOne) SetEmailVerifiedAt(t time.Time) *PersonUpdateOne {
	puo.mutation.SetEmailVerifiedAt(t)
	return puo
}

// SetNillableEmailVerifiedAt sets the "email_verified_at" field if the given value is not nil.
func (puo *PersonUpdateOne) SetNillableEmailVerifiedAt(t *time.Time) *PersonUpdateOne {
	if t != nil {
		puo.SetEmailVerifiedAt(*t)
	}
	return puo
}

// ClearEmailVerifiedAt clears the value of the "email_verified_at" field.
func (puo *PersonUpdateOne) ClearEmailVerifiedAt() *PersonUpdateOne {
	puo.mutation.ClearEmailVerifiedAt()
	return puo
}

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

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

// ClearPhone clears the value of the "phone" field.
func (puo *PersonUpdateOne) ClearPhone() *PersonUpdateOne {
	puo.mutation.ClearPhone()
	return puo
}

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

// SetTaxID sets the "tax_id" field.
func (puo *PersonUpdateOne) SetTaxID(s string) *PersonUpdateOne {
	puo.mutation.SetTaxID(s)
	return puo
}

// SetFirstName sets the "first_name" field.
func (puo *PersonUpdateOne) SetFirstName(s string) *PersonUpdateOne {
	puo.mutation.SetFirstName(s)
	return puo
}

// SetLastName sets the "last_name" field.
func (puo *PersonUpdateOne) SetLastName(s string) *PersonUpdateOne {
	puo.mutation.SetLastName(s)
	return puo
}

// SetNillableLastName sets the "last_name" field if the given value is not nil.
func (puo *PersonUpdateOne) SetNillableLastName(s *string) *PersonUpdateOne {
	if s != nil {
		puo.SetLastName(*s)
	}
	return puo
}

// ClearLastName clears the value of the "last_name" field.
func (puo *PersonUpdateOne) ClearLastName() *PersonUpdateOne {
	puo.mutation.ClearLastName()
	return puo
}

// SetLanguage sets the "language" field.
func (puo *PersonUpdateOne) SetLanguage(s string) *PersonUpdateOne {
	puo.mutation.SetLanguage(s)
	return puo
}

// SetBirthdate sets the "birthdate" field.
func (puo *PersonUpdateOne) SetBirthdate(t time.Time) *PersonUpdateOne {
	puo.mutation.SetBirthdate(t)
	return puo
}

// SetNillableBirthdate sets the "birthdate" field if the given value is not nil.
func (puo *PersonUpdateOne) SetNillableBirthdate(t *time.Time) *PersonUpdateOne {
	if t != nil {
		puo.SetBirthdate(*t)
	}
	return puo
}

// ClearBirthdate clears the value of the "birthdate" field.
func (puo *PersonUpdateOne) ClearBirthdate() *PersonUpdateOne {
	puo.mutation.ClearBirthdate()
	return puo
}

// SetGender sets the "gender" field.
func (puo *PersonUpdateOne) SetGender(pe person.Gender) *PersonUpdateOne {
	puo.mutation.SetGender(pe)
	return puo
}

// SetNillableGender sets the "gender" field if the given value is not nil.
func (puo *PersonUpdateOne) SetNillableGender(pe *person.Gender) *PersonUpdateOne {
	if pe != nil {
		puo.SetGender(*pe)
	}
	return puo
}

// ClearGender clears the value of the "gender" field.
func (puo *PersonUpdateOne) ClearGender() *PersonUpdateOne {
	puo.mutation.ClearGender()
	return puo
}

// SetAddress sets the "address" field.
func (puo *PersonUpdateOne) SetAddress(s string) *PersonUpdateOne {
	puo.mutation.SetAddress(s)
	return puo
}

// SetNillableAddress sets the "address" field if the given value is not nil.
func (puo *PersonUpdateOne) SetNillableAddress(s *string) *PersonUpdateOne {
	if s != nil {
		puo.SetAddress(*s)
	}
	return puo
}

// ClearAddress clears the value of the "address" field.
func (puo *PersonUpdateOne) ClearAddress() *PersonUpdateOne {
	puo.mutation.ClearAddress()
	return puo
}

// SetPostalCode sets the "postal_code" field.
func (puo *PersonUpdateOne) SetPostalCode(s string) *PersonUpdateOne {
	puo.mutation.SetPostalCode(s)
	return puo
}

// SetNillablePostalCode sets the "postal_code" field if the given value is not nil.
func (puo *PersonUpdateOne) SetNillablePostalCode(s *string) *PersonUpdateOne {
	if s != nil {
		puo.SetPostalCode(*s)
	}
	return puo
}

// ClearPostalCode clears the value of the "postal_code" field.
func (puo *PersonUpdateOne) ClearPostalCode() *PersonUpdateOne {
	puo.mutation.ClearPostalCode()
	return puo
}

// SetCity sets the "city" field.
func (puo *PersonUpdateOne) SetCity(s string) *PersonUpdateOne {
	puo.mutation.SetCity(s)
	return puo
}

// SetNillableCity sets the "city" field if the given value is not nil.
func (puo *PersonUpdateOne) SetNillableCity(s *string) *PersonUpdateOne {
	if s != nil {
		puo.SetCity(*s)
	}
	return puo
}

// ClearCity clears the value of the "city" field.
func (puo *PersonUpdateOne) ClearCity() *PersonUpdateOne {
	puo.mutation.ClearCity()
	return puo
}

// SetCountry sets the "country" field.
func (puo *PersonUpdateOne) SetCountry(s string) *PersonUpdateOne {
	puo.mutation.SetCountry(s)
	return puo
}

// SetNillableCountry sets the "country" field if the given value is not nil.
func (puo *PersonUpdateOne) SetNillableCountry(s *string) *PersonUpdateOne {
	if s != nil {
		puo.SetCountry(*s)
	}
	return puo
}

// ClearCountry clears the value of the "country" field.
func (puo *PersonUpdateOne) ClearCountry() *PersonUpdateOne {
	puo.mutation.ClearCountry()
	return puo
}

// SetSubscribed sets the "subscribed" field.
func (puo *PersonUpdateOne) SetSubscribed(b bool) *PersonUpdateOne {
	puo.mutation.SetSubscribed(b)
	return puo
}

// SetNillableSubscribed sets the "subscribed" field if the given value is not nil.
func (puo *PersonUpdateOne) SetNillableSubscribed(b *bool) *PersonUpdateOne {
	if b != nil {
		puo.SetSubscribed(*b)
	}
	return puo
}

// SetUpdatedAt sets the "updated_at" field.
func (puo *PersonUpdateOne) SetUpdatedAt(t time.Time) *PersonUpdateOne {
	puo.mutation.SetUpdatedAt(t)
	return puo
}

// AddAuthenticationIDs adds the "authentications" edge to the Authentication entity by IDs.
func (puo *PersonUpdateOne) AddAuthenticationIDs(ids ...uuid.UUID) *PersonUpdateOne {
	puo.mutation.AddAuthenticationIDs(ids...)
	return puo
}

// AddAuthentications adds the "authentications" edges to the Authentication entity.
func (puo *PersonUpdateOne) AddAuthentications(a ...*Authentication) *PersonUpdateOne {
	ids := make([]uuid.UUID, len(a))
	for i := range a {
		ids[i] = a[i].ID
	}
	return puo.AddAuthenticationIDs(ids...)
}

// AddAuthorizationIDs adds the "authorizations" edge to the Authorization entity by IDs.
func (puo *PersonUpdateOne) AddAuthorizationIDs(ids ...uuid.UUID) *PersonUpdateOne {
	puo.mutation.AddAuthorizationIDs(ids...)
	return puo
}

// AddAuthorizations adds the "authorizations" edges to the Authorization entity.
func (puo *PersonUpdateOne) AddAuthorizations(a ...*Authorization) *PersonUpdateOne {
	ids := make([]uuid.UUID, len(a))
	for i := range a {
		ids[i] = a[i].ID
	}
	return puo.AddAuthorizationIDs(ids...)
}

// Mutation returns the PersonMutation object of the builder.
func (puo *PersonUpdateOne) Mutation() *PersonMutation {
	return puo.mutation
}

// ClearAuthentications clears all "authentications" edges to the Authentication entity.
func (puo *PersonUpdateOne) ClearAuthentications() *PersonUpdateOne {
	puo.mutation.ClearAuthentications()
	return puo
}

// RemoveAuthenticationIDs removes the "authentications" edge to Authentication entities by IDs.
func (puo *PersonUpdateOne) RemoveAuthenticationIDs(ids ...uuid.UUID) *PersonUpdateOne {
	puo.mutation.RemoveAuthenticationIDs(ids...)
	return puo
}

// RemoveAuthentications removes "authentications" edges to Authentication entities.
func (puo *PersonUpdateOne) RemoveAuthentications(a ...*Authentication) *PersonUpdateOne {
	ids := make([]uuid.UUID, len(a))
	for i := range a {
		ids[i] = a[i].ID
	}
	return puo.RemoveAuthenticationIDs(ids...)
}

// ClearAuthorizations clears all "authorizations" edges to the Authorization entity.
func (puo *PersonUpdateOne) ClearAuthorizations() *PersonUpdateOne {
	puo.mutation.ClearAuthorizations()
	return puo
}

// RemoveAuthorizationIDs removes the "authorizations" edge to Authorization entities by IDs.
func (puo *PersonUpdateOne) RemoveAuthorizationIDs(ids ...uuid.UUID) *PersonUpdateOne {
	puo.mutation.RemoveAuthorizationIDs(ids...)
	return puo
}

// RemoveAuthorizations removes "authorizations" edges to Authorization entities.
func (puo *PersonUpdateOne) RemoveAuthorizations(a ...*Authorization) *PersonUpdateOne {
	ids := make([]uuid.UUID, len(a))
	for i := range a {
		ids[i] = a[i].ID
	}
	return puo.RemoveAuthorizationIDs(ids...)
}

// Where appends a list predicates to the PersonUpdate builder.
func (puo *PersonUpdateOne) Where(ps ...predicate.Person) *PersonUpdateOne {
	puo.mutation.Where(ps...)
	return puo
}

// Select allows selecting one or more fields (columns) of the returned entity.
// The default is selecting all fields defined in the entity schema.
func (puo *PersonUpdateOne) Select(field string, fields ...string) *PersonUpdateOne {
	puo.fields = append([]string{field}, fields...)
	return puo
}

// Save executes the query and returns the updated Person entity.
func (puo *PersonUpdateOne) Save(ctx context.Context) (*Person, error) {
	if err := puo.defaults(); err != nil {
		return nil, err
	}
	return withHooks(ctx, puo.sqlSave, puo.mutation, puo.hooks)
}

// SaveX is like Save, but panics if an error occurs.
func (puo *PersonUpdateOne) SaveX(ctx context.Context) *Person {
	node, err := puo.Save(ctx)
	if err != nil {
		panic(err)
	}
	return node
}

// Exec executes the query on the entity.
func (puo *PersonUpdateOne) Exec(ctx context.Context) error {
	_, err := puo.Save(ctx)
	return err
}

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

// defaults sets the default values of the builder before save.
func (puo *PersonUpdateOne) defaults() error {
	if _, ok := puo.mutation.UpdatedAt(); !ok {
		if person.UpdateDefaultUpdatedAt == nil {
			return fmt.Errorf("data: uninitialized person.UpdateDefaultUpdatedAt (forgotten import data/runtime?)")
		}
		v := person.UpdateDefaultUpdatedAt()
		puo.mutation.SetUpdatedAt(v)
	}
	return nil
}

// check runs all checks and user-defined validators on the builder.
func (puo *PersonUpdateOne) check() error {
	if v, ok := puo.mutation.Email(); ok {
		if err := person.EmailValidator(v); err != nil {
			return &ValidationError{Name: "email", err: fmt.Errorf(`data: validator failed for field "Person.email": %w`, err)}
		}
	}
	if v, ok := puo.mutation.Phone(); ok {
		if err := person.PhoneValidator(v); err != nil {
			return &ValidationError{Name: "phone", err: fmt.Errorf(`data: validator failed for field "Person.phone": %w`, err)}
		}
	}
	if v, ok := puo.mutation.TaxID(); ok {
		if err := person.TaxIDValidator(v); err != nil {
			return &ValidationError{Name: "tax_id", err: fmt.Errorf(`data: validator failed for field "Person.tax_id": %w`, err)}
		}
	}
	if v, ok := puo.mutation.FirstName(); ok {
		if err := person.FirstNameValidator(v); err != nil {
			return &ValidationError{Name: "first_name", err: fmt.Errorf(`data: validator failed for field "Person.first_name": %w`, err)}
		}
	}
	if v, ok := puo.mutation.LastName(); ok {
		if err := person.LastNameValidator(v); err != nil {
			return &ValidationError{Name: "last_name", err: fmt.Errorf(`data: validator failed for field "Person.last_name": %w`, err)}
		}
	}
	if v, ok := puo.mutation.Gender(); ok {
		if err := person.GenderValidator(v); err != nil {
			return &ValidationError{Name: "gender", err: fmt.Errorf(`data: validator failed for field "Person.gender": %w`, err)}
		}
	}
	if v, ok := puo.mutation.Address(); ok {
		if err := person.AddressValidator(v); err != nil {
			return &ValidationError{Name: "address", err: fmt.Errorf(`data: validator failed for field "Person.address": %w`, err)}
		}
	}
	if v, ok := puo.mutation.PostalCode(); ok {
		if err := person.PostalCodeValidator(v); err != nil {
			return &ValidationError{Name: "postal_code", err: fmt.Errorf(`data: validator failed for field "Person.postal_code": %w`, err)}
		}
	}
	if v, ok := puo.mutation.City(); ok {
		if err := person.CityValidator(v); err != nil {
			return &ValidationError{Name: "city", err: fmt.Errorf(`data: validator failed for field "Person.city": %w`, err)}
		}
	}
	if v, ok := puo.mutation.Country(); ok {
		if err := person.CountryValidator(v); err != nil {
			return &ValidationError{Name: "country", err: fmt.Errorf(`data: validator failed for field "Person.country": %w`, err)}
		}
	}
	return nil
}

func (puo *PersonUpdateOne) sqlSave(ctx context.Context) (_node *Person, err error) {
	if err := puo.check(); err != nil {
		return _node, err
	}
	_spec := sqlgraph.NewUpdateSpec(person.Table, person.Columns, sqlgraph.NewFieldSpec(person.FieldID, field.TypeUUID))
	id, ok := puo.mutation.ID()
	if !ok {
		return nil, &ValidationError{Name: "id", err: errors.New(`data: missing "Person.id" for update`)}
	}
	_spec.Node.ID.Value = id
	if fields := puo.fields; len(fields) > 0 {
		_spec.Node.Columns = make([]string, 0, len(fields))
		_spec.Node.Columns = append(_spec.Node.Columns, person.FieldID)
		for _, f := range fields {
			if !person.ValidColumn(f) {
				return nil, &ValidationError{Name: f, err: fmt.Errorf("data: invalid field %q for query", f)}
			}
			if f != person.FieldID {
				_spec.Node.Columns = append(_spec.Node.Columns, f)
			}
		}
	}
	if ps := puo.mutation.predicates; len(ps) > 0 {
		_spec.Predicate = func(selector *sql.Selector) {
			for i := range ps {
				ps[i](selector)
			}
		}
	}
	if value, ok := puo.mutation.StripeID(); ok {
		_spec.SetField(person.FieldStripeID, field.TypeString, value)
	}
	if puo.mutation.StripeIDCleared() {
		_spec.ClearField(person.FieldStripeID, field.TypeString)
	}
	if value, ok := puo.mutation.Email(); ok {
		_spec.SetField(person.FieldEmail, field.TypeString, value)
	}
	if value, ok := puo.mutation.EmailVerifiedAt(); ok {
		_spec.SetField(person.FieldEmailVerifiedAt, field.TypeTime, value)
	}
	if puo.mutation.EmailVerifiedAtCleared() {
		_spec.ClearField(person.FieldEmailVerifiedAt, field.TypeTime)
	}
	if value, ok := puo.mutation.Phone(); ok {
		_spec.SetField(person.FieldPhone, field.TypeString, value)
	}
	if puo.mutation.PhoneCleared() {
		_spec.ClearField(person.FieldPhone, field.TypeString)
	}
	if value, ok := puo.mutation.Password(); ok {
		_spec.SetField(person.FieldPassword, field.TypeString, value)
	}
	if value, ok := puo.mutation.TaxID(); ok {
		_spec.SetField(person.FieldTaxID, field.TypeString, value)
	}
	if value, ok := puo.mutation.FirstName(); ok {
		_spec.SetField(person.FieldFirstName, field.TypeString, value)
	}
	if value, ok := puo.mutation.LastName(); ok {
		_spec.SetField(person.FieldLastName, field.TypeString, value)
	}
	if puo.mutation.LastNameCleared() {
		_spec.ClearField(person.FieldLastName, field.TypeString)
	}
	if value, ok := puo.mutation.Language(); ok {
		_spec.SetField(person.FieldLanguage, field.TypeString, value)
	}
	if value, ok := puo.mutation.Birthdate(); ok {
		_spec.SetField(person.FieldBirthdate, field.TypeTime, value)
	}
	if puo.mutation.BirthdateCleared() {
		_spec.ClearField(person.FieldBirthdate, field.TypeTime)
	}
	if value, ok := puo.mutation.Gender(); ok {
		_spec.SetField(person.FieldGender, field.TypeEnum, value)
	}
	if puo.mutation.GenderCleared() {
		_spec.ClearField(person.FieldGender, field.TypeEnum)
	}
	if value, ok := puo.mutation.Address(); ok {
		_spec.SetField(person.FieldAddress, field.TypeString, value)
	}
	if puo.mutation.AddressCleared() {
		_spec.ClearField(person.FieldAddress, field.TypeString)
	}
	if value, ok := puo.mutation.PostalCode(); ok {
		_spec.SetField(person.FieldPostalCode, field.TypeString, value)
	}
	if puo.mutation.PostalCodeCleared() {
		_spec.ClearField(person.FieldPostalCode, field.TypeString)
	}
	if value, ok := puo.mutation.City(); ok {
		_spec.SetField(person.FieldCity, field.TypeString, value)
	}
	if puo.mutation.CityCleared() {
		_spec.ClearField(person.FieldCity, field.TypeString)
	}
	if value, ok := puo.mutation.Country(); ok {
		_spec.SetField(person.FieldCountry, field.TypeString, value)
	}
	if puo.mutation.CountryCleared() {
		_spec.ClearField(person.FieldCountry, field.TypeString)
	}
	if value, ok := puo.mutation.Subscribed(); ok {
		_spec.SetField(person.FieldSubscribed, field.TypeBool, value)
	}
	if value, ok := puo.mutation.UpdatedAt(); ok {
		_spec.SetField(person.FieldUpdatedAt, field.TypeTime, value)
	}
	if puo.mutation.AuthenticationsCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   person.AuthenticationsTable,
			Columns: []string{person.AuthenticationsColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(authentication.FieldID, field.TypeUUID),
			},
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := puo.mutation.RemovedAuthenticationsIDs(); len(nodes) > 0 && !puo.mutation.AuthenticationsCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   person.AuthenticationsTable,
			Columns: []string{person.AuthenticationsColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(authentication.FieldID, field.TypeUUID),
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := puo.mutation.AuthenticationsIDs(); len(nodes) > 0 {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   person.AuthenticationsTable,
			Columns: []string{person.AuthenticationsColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(authentication.FieldID, field.TypeUUID),
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Add = append(_spec.Edges.Add, edge)
	}
	if puo.mutation.AuthorizationsCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   person.AuthorizationsTable,
			Columns: []string{person.AuthorizationsColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(authorization.FieldID, field.TypeUUID),
			},
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := puo.mutation.RemovedAuthorizationsIDs(); len(nodes) > 0 && !puo.mutation.AuthorizationsCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   person.AuthorizationsTable,
			Columns: []string{person.AuthorizationsColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(authorization.FieldID, field.TypeUUID),
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := puo.mutation.AuthorizationsIDs(); len(nodes) > 0 {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   person.AuthorizationsTable,
			Columns: []string{person.AuthorizationsColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: sqlgraph.NewFieldSpec(authorization.FieldID, field.TypeUUID),
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Add = append(_spec.Edges.Add, edge)
	}
	_node = &Person{config: puo.config}
	_spec.Assign = _node.assignValues
	_spec.ScanValues = _node.scanValues
	if err = sqlgraph.UpdateNode(ctx, puo.driver, _spec); err != nil {
		if _, ok := err.(*sqlgraph.NotFoundError); ok {
			err = &NotFoundError{person.Label}
		} else if sqlgraph.IsConstraintError(err) {
			err = &ConstraintError{msg: err.Error(), wrap: err}
		}
		return nil, err
	}
	puo.mutation.done = true
	return _node, nil
}