flowdeployment_update.go

// Code generated by entc, 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/BeanWei/li/li-engine/contrib/liflow/ent/flowdefinition"
	"github.com/BeanWei/li/li-engine/contrib/liflow/ent/flowdeployment"
	"github.com/BeanWei/li/li-engine/contrib/liflow/ent/flowinstance"
	"github.com/BeanWei/li/li-engine/contrib/liflow/ent/predicate"
	"github.com/BeanWei/li/li-engine/contrib/liflow/ent/schema"
)

// FlowDeploymentUpdate is the builder for updating FlowDeployment entities.
type FlowDeploymentUpdate struct {
	config
	hooks    []Hook
	mutation *FlowDeploymentMutation
}

// Where appends a list predicates to the FlowDeploymentUpdate builder.
func (fdu *FlowDeploymentUpdate) Where(ps ...predicate.FlowDeployment) *FlowDeploymentUpdate {
	fdu.mutation.Where(ps...)
	return fdu
}

// SetUpdatedAt sets the "updated_at" field.
func (fdu *FlowDeploymentUpdate) SetUpdatedAt(i int64) *FlowDeploymentUpdate {
	fdu.mutation.ResetUpdatedAt()
	fdu.mutation.SetUpdatedAt(i)
	return fdu
}

// AddUpdatedAt adds i to the "updated_at" field.
func (fdu *FlowDeploymentUpdate) AddUpdatedAt(i int64) *FlowDeploymentUpdate {
	fdu.mutation.AddUpdatedAt(i)
	return fdu
}

// SetDeletedAt sets the "deleted_at" field.
func (fdu *FlowDeploymentUpdate) SetDeletedAt(i int64) *FlowDeploymentUpdate {
	fdu.mutation.ResetDeletedAt()
	fdu.mutation.SetDeletedAt(i)
	return fdu
}

// SetNillableDeletedAt sets the "deleted_at" field if the given value is not nil.
func (fdu *FlowDeploymentUpdate) SetNillableDeletedAt(i *int64) *FlowDeploymentUpdate {
	if i != nil {
		fdu.SetDeletedAt(*i)
	}
	return fdu
}

// AddDeletedAt adds i to the "deleted_at" field.
func (fdu *FlowDeploymentUpdate) AddDeletedAt(i int64) *FlowDeploymentUpdate {
	fdu.mutation.AddDeletedAt(i)
	return fdu
}

// ClearDeletedAt clears the value of the "deleted_at" field.
func (fdu *FlowDeploymentUpdate) ClearDeletedAt() *FlowDeploymentUpdate {
	fdu.mutation.ClearDeletedAt()
	return fdu
}

// SetFlowDefinitionID sets the "flow_definition_id" field.
func (fdu *FlowDeploymentUpdate) SetFlowDefinitionID(s string) *FlowDeploymentUpdate {
	fdu.mutation.SetFlowDefinitionID(s)
	return fdu
}

// SetName sets the "name" field.
func (fdu *FlowDeploymentUpdate) SetName(s string) *FlowDeploymentUpdate {
	fdu.mutation.SetName(s)
	return fdu
}

// SetStatus sets the "status" field.
func (fdu *FlowDeploymentUpdate) SetStatus(i int8) *FlowDeploymentUpdate {
	fdu.mutation.ResetStatus()
	fdu.mutation.SetStatus(i)
	return fdu
}

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

// AddStatus adds i to the "status" field.
func (fdu *FlowDeploymentUpdate) AddStatus(i int8) *FlowDeploymentUpdate {
	fdu.mutation.AddStatus(i)
	return fdu
}

// SetModel sets the "model" field.
func (fdu *FlowDeploymentUpdate) SetModel(sm schema.FlowModel) *FlowDeploymentUpdate {
	fdu.mutation.SetModel(sm)
	return fdu
}

// SetRemark sets the "remark" field.
func (fdu *FlowDeploymentUpdate) SetRemark(s string) *FlowDeploymentUpdate {
	fdu.mutation.SetRemark(s)
	return fdu
}

// SetNillableRemark sets the "remark" field if the given value is not nil.
func (fdu *FlowDeploymentUpdate) SetNillableRemark(s *string) *FlowDeploymentUpdate {
	if s != nil {
		fdu.SetRemark(*s)
	}
	return fdu
}

// ClearRemark clears the value of the "remark" field.
func (fdu *FlowDeploymentUpdate) ClearRemark() *FlowDeploymentUpdate {
	fdu.mutation.ClearRemark()
	return fdu
}

// SetFlowDefinition sets the "flow_definition" edge to the FlowDefinition entity.
func (fdu *FlowDeploymentUpdate) SetFlowDefinition(f *FlowDefinition) *FlowDeploymentUpdate {
	return fdu.SetFlowDefinitionID(f.ID)
}

// AddFlowInstanceIDs adds the "flow_instances" edge to the FlowInstance entity by IDs.
func (fdu *FlowDeploymentUpdate) AddFlowInstanceIDs(ids ...string) *FlowDeploymentUpdate {
	fdu.mutation.AddFlowInstanceIDs(ids...)
	return fdu
}

// AddFlowInstances adds the "flow_instances" edges to the FlowInstance entity.
func (fdu *FlowDeploymentUpdate) AddFlowInstances(f ...*FlowInstance) *FlowDeploymentUpdate {
	ids := make([]string, len(f))
	for i := range f {
		ids[i] = f[i].ID
	}
	return fdu.AddFlowInstanceIDs(ids...)
}

// Mutation returns the FlowDeploymentMutation object of the builder.
func (fdu *FlowDeploymentUpdate) Mutation() *FlowDeploymentMutation {
	return fdu.mutation
}

// ClearFlowDefinition clears the "flow_definition" edge to the FlowDefinition entity.
func (fdu *FlowDeploymentUpdate) ClearFlowDefinition() *FlowDeploymentUpdate {
	fdu.mutation.ClearFlowDefinition()
	return fdu
}

// ClearFlowInstances clears all "flow_instances" edges to the FlowInstance entity.
func (fdu *FlowDeploymentUpdate) ClearFlowInstances() *FlowDeploymentUpdate {
	fdu.mutation.ClearFlowInstances()
	return fdu
}

// RemoveFlowInstanceIDs removes the "flow_instances" edge to FlowInstance entities by IDs.
func (fdu *FlowDeploymentUpdate) RemoveFlowInstanceIDs(ids ...string) *FlowDeploymentUpdate {
	fdu.mutation.RemoveFlowInstanceIDs(ids...)
	return fdu
}

// RemoveFlowInstances removes "flow_instances" edges to FlowInstance entities.
func (fdu *FlowDeploymentUpdate) RemoveFlowInstances(f ...*FlowInstance) *FlowDeploymentUpdate {
	ids := make([]string, len(f))
	for i := range f {
		ids[i] = f[i].ID
	}
	return fdu.RemoveFlowInstanceIDs(ids...)
}

// Save executes the query and returns the number of nodes affected by the update operation.
func (fdu *FlowDeploymentUpdate) Save(ctx context.Context) (int, error) {
	var (
		err      error
		affected int
	)
	fdu.defaults()
	if len(fdu.hooks) == 0 {
		if err = fdu.check(); err != nil {
			return 0, err
		}
		affected, err = fdu.sqlSave(ctx)
	} else {
		var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
			mutation, ok := m.(*FlowDeploymentMutation)
			if !ok {
				return nil, fmt.Errorf("unexpected mutation type %T", m)
			}
			if err = fdu.check(); err != nil {
				return 0, err
			}
			fdu.mutation = mutation
			affected, err = fdu.sqlSave(ctx)
			mutation.done = true
			return affected, err
		})
		for i := len(fdu.hooks) - 1; i >= 0; i-- {
			if fdu.hooks[i] == nil {
				return 0, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)")
			}
			mut = fdu.hooks[i](mut)
		}
		if _, err := mut.Mutate(ctx, fdu.mutation); err != nil {
			return 0, err
		}
	}
	return affected, err
}

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

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

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

// defaults sets the default values of the builder before save.
func (fdu *FlowDeploymentUpdate) defaults() {
	if _, ok := fdu.mutation.UpdatedAt(); !ok {
		v := flowdeployment.UpdateDefaultUpdatedAt()
		fdu.mutation.SetUpdatedAt(v)
	}
}

// check runs all checks and user-defined validators on the builder.
func (fdu *FlowDeploymentUpdate) check() error {
	if v, ok := fdu.mutation.FlowDefinitionID(); ok {
		if err := flowdeployment.FlowDefinitionIDValidator(v); err != nil {
			return &ValidationError{Name: "flow_definition_id", err: fmt.Errorf(`ent: validator failed for field "FlowDeployment.flow_definition_id": %w`, err)}
		}
	}
	if v, ok := fdu.mutation.Name(); ok {
		if err := flowdeployment.NameValidator(v); err != nil {
			return &ValidationError{Name: "name", err: fmt.Errorf(`ent: validator failed for field "FlowDeployment.name": %w`, err)}
		}
	}
	if _, ok := fdu.mutation.FlowDefinitionID(); fdu.mutation.FlowDefinitionCleared() && !ok {
		return errors.New(`ent: clearing a required unique edge "FlowDeployment.flow_definition"`)
	}
	return nil
}

func (fdu *FlowDeploymentUpdate) sqlSave(ctx context.Context) (n int, err error) {
	_spec := &sqlgraph.UpdateSpec{
		Node: &sqlgraph.NodeSpec{
			Table:   flowdeployment.Table,
			Columns: flowdeployment.Columns,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeString,
				Column: flowdeployment.FieldID,
			},
		},
	}
	if ps := fdu.mutation.predicates; len(ps) > 0 {
		_spec.Predicate = func(selector *sql.Selector) {
			for i := range ps {
				ps[i](selector)
			}
		}
	}
	if value, ok := fdu.mutation.UpdatedAt(); ok {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeInt64,
			Value:  value,
			Column: flowdeployment.FieldUpdatedAt,
		})
	}
	if value, ok := fdu.mutation.AddedUpdatedAt(); ok {
		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
			Type:   field.TypeInt64,
			Value:  value,
			Column: flowdeployment.FieldUpdatedAt,
		})
	}
	if value, ok := fdu.mutation.DeletedAt(); ok {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeInt64,
			Value:  value,
			Column: flowdeployment.FieldDeletedAt,
		})
	}
	if value, ok := fdu.mutation.AddedDeletedAt(); ok {
		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
			Type:   field.TypeInt64,
			Value:  value,
			Column: flowdeployment.FieldDeletedAt,
		})
	}
	if fdu.mutation.DeletedAtCleared() {
		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
			Type:   field.TypeInt64,
			Column: flowdeployment.FieldDeletedAt,
		})
	}
	if value, ok := fdu.mutation.Name(); ok {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeString,
			Value:  value,
			Column: flowdeployment.FieldName,
		})
	}
	if value, ok := fdu.mutation.Status(); ok {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeInt8,
			Value:  value,
			Column: flowdeployment.FieldStatus,
		})
	}
	if value, ok := fdu.mutation.AddedStatus(); ok {
		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
			Type:   field.TypeInt8,
			Value:  value,
			Column: flowdeployment.FieldStatus,
		})
	}
	if value, ok := fdu.mutation.Model(); ok {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeJSON,
			Value:  value,
			Column: flowdeployment.FieldModel,
		})
	}
	if value, ok := fdu.mutation.Remark(); ok {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeString,
			Value:  value,
			Column: flowdeployment.FieldRemark,
		})
	}
	if fdu.mutation.RemarkCleared() {
		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
			Type:   field.TypeString,
			Column: flowdeployment.FieldRemark,
		})
	}
	if fdu.mutation.FlowDefinitionCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: true,
			Table:   flowdeployment.FlowDefinitionTable,
			Columns: []string{flowdeployment.FlowDefinitionColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: &sqlgraph.FieldSpec{
					Type:   field.TypeString,
					Column: flowdefinition.FieldID,
				},
			},
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := fdu.mutation.FlowDefinitionIDs(); len(nodes) > 0 {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: true,
			Table:   flowdeployment.FlowDefinitionTable,
			Columns: []string{flowdeployment.FlowDefinitionColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: &sqlgraph.FieldSpec{
					Type:   field.TypeString,
					Column: flowdefinition.FieldID,
				},
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Add = append(_spec.Edges.Add, edge)
	}
	if fdu.mutation.FlowInstancesCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   flowdeployment.FlowInstancesTable,
			Columns: []string{flowdeployment.FlowInstancesColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: &sqlgraph.FieldSpec{
					Type:   field.TypeString,
					Column: flowinstance.FieldID,
				},
			},
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := fdu.mutation.RemovedFlowInstancesIDs(); len(nodes) > 0 && !fdu.mutation.FlowInstancesCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   flowdeployment.FlowInstancesTable,
			Columns: []string{flowdeployment.FlowInstancesColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: &sqlgraph.FieldSpec{
					Type:   field.TypeString,
					Column: flowinstance.FieldID,
				},
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := fdu.mutation.FlowInstancesIDs(); len(nodes) > 0 {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   flowdeployment.FlowInstancesTable,
			Columns: []string{flowdeployment.FlowInstancesColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: &sqlgraph.FieldSpec{
					Type:   field.TypeString,
					Column: flowinstance.FieldID,
				},
			},
		}
		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, fdu.driver, _spec); err != nil {
		if _, ok := err.(*sqlgraph.NotFoundError); ok {
			err = &NotFoundError{flowdeployment.Label}
		} else if sqlgraph.IsConstraintError(err) {
			err = &ConstraintError{err.Error(), err}
		}
		return 0, err
	}
	return n, nil
}

// FlowDeploymentUpdateOne is the builder for updating a single FlowDeployment entity.
type FlowDeploymentUpdateOne struct {
	config
	fields   []string
	hooks    []Hook
	mutation *FlowDeploymentMutation
}

// SetUpdatedAt sets the "updated_at" field.
func (fduo *FlowDeploymentUpdateOne) SetUpdatedAt(i int64) *FlowDeploymentUpdateOne {
	fduo.mutation.ResetUpdatedAt()
	fduo.mutation.SetUpdatedAt(i)
	return fduo
}

// AddUpdatedAt adds i to the "updated_at" field.
func (fduo *FlowDeploymentUpdateOne) AddUpdatedAt(i int64) *FlowDeploymentUpdateOne {
	fduo.mutation.AddUpdatedAt(i)
	return fduo
}

// SetDeletedAt sets the "deleted_at" field.
func (fduo *FlowDeploymentUpdateOne) SetDeletedAt(i int64) *FlowDeploymentUpdateOne {
	fduo.mutation.ResetDeletedAt()
	fduo.mutation.SetDeletedAt(i)
	return fduo
}

// SetNillableDeletedAt sets the "deleted_at" field if the given value is not nil.
func (fduo *FlowDeploymentUpdateOne) SetNillableDeletedAt(i *int64) *FlowDeploymentUpdateOne {
	if i != nil {
		fduo.SetDeletedAt(*i)
	}
	return fduo
}

// AddDeletedAt adds i to the "deleted_at" field.
func (fduo *FlowDeploymentUpdateOne) AddDeletedAt(i int64) *FlowDeploymentUpdateOne {
	fduo.mutation.AddDeletedAt(i)
	return fduo
}

// ClearDeletedAt clears the value of the "deleted_at" field.
func (fduo *FlowDeploymentUpdateOne) ClearDeletedAt() *FlowDeploymentUpdateOne {
	fduo.mutation.ClearDeletedAt()
	return fduo
}

// SetFlowDefinitionID sets the "flow_definition_id" field.
func (fduo *FlowDeploymentUpdateOne) SetFlowDefinitionID(s string) *FlowDeploymentUpdateOne {
	fduo.mutation.SetFlowDefinitionID(s)
	return fduo
}

// SetName sets the "name" field.
func (fduo *FlowDeploymentUpdateOne) SetName(s string) *FlowDeploymentUpdateOne {
	fduo.mutation.SetName(s)
	return fduo
}

// SetStatus sets the "status" field.
func (fduo *FlowDeploymentUpdateOne) SetStatus(i int8) *FlowDeploymentUpdateOne {
	fduo.mutation.ResetStatus()
	fduo.mutation.SetStatus(i)
	return fduo
}

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

// AddStatus adds i to the "status" field.
func (fduo *FlowDeploymentUpdateOne) AddStatus(i int8) *FlowDeploymentUpdateOne {
	fduo.mutation.AddStatus(i)
	return fduo
}

// SetModel sets the "model" field.
func (fduo *FlowDeploymentUpdateOne) SetModel(sm schema.FlowModel) *FlowDeploymentUpdateOne {
	fduo.mutation.SetModel(sm)
	return fduo
}

// SetRemark sets the "remark" field.
func (fduo *FlowDeploymentUpdateOne) SetRemark(s string) *FlowDeploymentUpdateOne {
	fduo.mutation.SetRemark(s)
	return fduo
}

// SetNillableRemark sets the "remark" field if the given value is not nil.
func (fduo *FlowDeploymentUpdateOne) SetNillableRemark(s *string) *FlowDeploymentUpdateOne {
	if s != nil {
		fduo.SetRemark(*s)
	}
	return fduo
}

// ClearRemark clears the value of the "remark" field.
func (fduo *FlowDeploymentUpdateOne) ClearRemark() *FlowDeploymentUpdateOne {
	fduo.mutation.ClearRemark()
	return fduo
}

// SetFlowDefinition sets the "flow_definition" edge to the FlowDefinition entity.
func (fduo *FlowDeploymentUpdateOne) SetFlowDefinition(f *FlowDefinition) *FlowDeploymentUpdateOne {
	return fduo.SetFlowDefinitionID(f.ID)
}

// AddFlowInstanceIDs adds the "flow_instances" edge to the FlowInstance entity by IDs.
func (fduo *FlowDeploymentUpdateOne) AddFlowInstanceIDs(ids ...string) *FlowDeploymentUpdateOne {
	fduo.mutation.AddFlowInstanceIDs(ids...)
	return fduo
}

// AddFlowInstances adds the "flow_instances" edges to the FlowInstance entity.
func (fduo *FlowDeploymentUpdateOne) AddFlowInstances(f ...*FlowInstance) *FlowDeploymentUpdateOne {
	ids := make([]string, len(f))
	for i := range f {
		ids[i] = f[i].ID
	}
	return fduo.AddFlowInstanceIDs(ids...)
}

// Mutation returns the FlowDeploymentMutation object of the builder.
func (fduo *FlowDeploymentUpdateOne) Mutation() *FlowDeploymentMutation {
	return fduo.mutation
}

// ClearFlowDefinition clears the "flow_definition" edge to the FlowDefinition entity.
func (fduo *FlowDeploymentUpdateOne) ClearFlowDefinition() *FlowDeploymentUpdateOne {
	fduo.mutation.ClearFlowDefinition()
	return fduo
}

// ClearFlowInstances clears all "flow_instances" edges to the FlowInstance entity.
func (fduo *FlowDeploymentUpdateOne) ClearFlowInstances() *FlowDeploymentUpdateOne {
	fduo.mutation.ClearFlowInstances()
	return fduo
}

// RemoveFlowInstanceIDs removes the "flow_instances" edge to FlowInstance entities by IDs.
func (fduo *FlowDeploymentUpdateOne) RemoveFlowInstanceIDs(ids ...string) *FlowDeploymentUpdateOne {
	fduo.mutation.RemoveFlowInstanceIDs(ids...)
	return fduo
}

// RemoveFlowInstances removes "flow_instances" edges to FlowInstance entities.
func (fduo *FlowDeploymentUpdateOne) RemoveFlowInstances(f ...*FlowInstance) *FlowDeploymentUpdateOne {
	ids := make([]string, len(f))
	for i := range f {
		ids[i] = f[i].ID
	}
	return fduo.RemoveFlowInstanceIDs(ids...)
}

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

// Save executes the query and returns the updated FlowDeployment entity.
func (fduo *FlowDeploymentUpdateOne) Save(ctx context.Context) (*FlowDeployment, error) {
	var (
		err  error
		node *FlowDeployment
	)
	fduo.defaults()
	if len(fduo.hooks) == 0 {
		if err = fduo.check(); err != nil {
			return nil, err
		}
		node, err = fduo.sqlSave(ctx)
	} else {
		var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
			mutation, ok := m.(*FlowDeploymentMutation)
			if !ok {
				return nil, fmt.Errorf("unexpected mutation type %T", m)
			}
			if err = fduo.check(); err != nil {
				return nil, err
			}
			fduo.mutation = mutation
			node, err = fduo.sqlSave(ctx)
			mutation.done = true
			return node, err
		})
		for i := len(fduo.hooks) - 1; i >= 0; i-- {
			if fduo.hooks[i] == nil {
				return nil, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)")
			}
			mut = fduo.hooks[i](mut)
		}
		if _, err := mut.Mutate(ctx, fduo.mutation); err != nil {
			return nil, err
		}
	}
	return node, err
}

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

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

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

// defaults sets the default values of the builder before save.
func (fduo *FlowDeploymentUpdateOne) defaults() {
	if _, ok := fduo.mutation.UpdatedAt(); !ok {
		v := flowdeployment.UpdateDefaultUpdatedAt()
		fduo.mutation.SetUpdatedAt(v)
	}
}

// check runs all checks and user-defined validators on the builder.
func (fduo *FlowDeploymentUpdateOne) check() error {
	if v, ok := fduo.mutation.FlowDefinitionID(); ok {
		if err := flowdeployment.FlowDefinitionIDValidator(v); err != nil {
			return &ValidationError{Name: "flow_definition_id", err: fmt.Errorf(`ent: validator failed for field "FlowDeployment.flow_definition_id": %w`, err)}
		}
	}
	if v, ok := fduo.mutation.Name(); ok {
		if err := flowdeployment.NameValidator(v); err != nil {
			return &ValidationError{Name: "name", err: fmt.Errorf(`ent: validator failed for field "FlowDeployment.name": %w`, err)}
		}
	}
	if _, ok := fduo.mutation.FlowDefinitionID(); fduo.mutation.FlowDefinitionCleared() && !ok {
		return errors.New(`ent: clearing a required unique edge "FlowDeployment.flow_definition"`)
	}
	return nil
}

func (fduo *FlowDeploymentUpdateOne) sqlSave(ctx context.Context) (_node *FlowDeployment, err error) {
	_spec := &sqlgraph.UpdateSpec{
		Node: &sqlgraph.NodeSpec{
			Table:   flowdeployment.Table,
			Columns: flowdeployment.Columns,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeString,
				Column: flowdeployment.FieldID,
			},
		},
	}
	id, ok := fduo.mutation.ID()
	if !ok {
		return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "FlowDeployment.id" for update`)}
	}
	_spec.Node.ID.Value = id
	if fields := fduo.fields; len(fields) > 0 {
		_spec.Node.Columns = make([]string, 0, len(fields))
		_spec.Node.Columns = append(_spec.Node.Columns, flowdeployment.FieldID)
		for _, f := range fields {
			if !flowdeployment.ValidColumn(f) {
				return nil, &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
			}
			if f != flowdeployment.FieldID {
				_spec.Node.Columns = append(_spec.Node.Columns, f)
			}
		}
	}
	if ps := fduo.mutation.predicates; len(ps) > 0 {
		_spec.Predicate = func(selector *sql.Selector) {
			for i := range ps {
				ps[i](selector)
			}
		}
	}
	if value, ok := fduo.mutation.UpdatedAt(); ok {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeInt64,
			Value:  value,
			Column: flowdeployment.FieldUpdatedAt,
		})
	}
	if value, ok := fduo.mutation.AddedUpdatedAt(); ok {
		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
			Type:   field.TypeInt64,
			Value:  value,
			Column: flowdeployment.FieldUpdatedAt,
		})
	}
	if value, ok := fduo.mutation.DeletedAt(); ok {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeInt64,
			Value:  value,
			Column: flowdeployment.FieldDeletedAt,
		})
	}
	if value, ok := fduo.mutation.AddedDeletedAt(); ok {
		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
			Type:   field.TypeInt64,
			Value:  value,
			Column: flowdeployment.FieldDeletedAt,
		})
	}
	if fduo.mutation.DeletedAtCleared() {
		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
			Type:   field.TypeInt64,
			Column: flowdeployment.FieldDeletedAt,
		})
	}
	if value, ok := fduo.mutation.Name(); ok {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeString,
			Value:  value,
			Column: flowdeployment.FieldName,
		})
	}
	if value, ok := fduo.mutation.Status(); ok {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeInt8,
			Value:  value,
			Column: flowdeployment.FieldStatus,
		})
	}
	if value, ok := fduo.mutation.AddedStatus(); ok {
		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
			Type:   field.TypeInt8,
			Value:  value,
			Column: flowdeployment.FieldStatus,
		})
	}
	if value, ok := fduo.mutation.Model(); ok {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeJSON,
			Value:  value,
			Column: flowdeployment.FieldModel,
		})
	}
	if value, ok := fduo.mutation.Remark(); ok {
		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
			Type:   field.TypeString,
			Value:  value,
			Column: flowdeployment.FieldRemark,
		})
	}
	if fduo.mutation.RemarkCleared() {
		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
			Type:   field.TypeString,
			Column: flowdeployment.FieldRemark,
		})
	}
	if fduo.mutation.FlowDefinitionCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: true,
			Table:   flowdeployment.FlowDefinitionTable,
			Columns: []string{flowdeployment.FlowDefinitionColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: &sqlgraph.FieldSpec{
					Type:   field.TypeString,
					Column: flowdefinition.FieldID,
				},
			},
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := fduo.mutation.FlowDefinitionIDs(); len(nodes) > 0 {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.M2O,
			Inverse: true,
			Table:   flowdeployment.FlowDefinitionTable,
			Columns: []string{flowdeployment.FlowDefinitionColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: &sqlgraph.FieldSpec{
					Type:   field.TypeString,
					Column: flowdefinition.FieldID,
				},
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Add = append(_spec.Edges.Add, edge)
	}
	if fduo.mutation.FlowInstancesCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   flowdeployment.FlowInstancesTable,
			Columns: []string{flowdeployment.FlowInstancesColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: &sqlgraph.FieldSpec{
					Type:   field.TypeString,
					Column: flowinstance.FieldID,
				},
			},
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := fduo.mutation.RemovedFlowInstancesIDs(); len(nodes) > 0 && !fduo.mutation.FlowInstancesCleared() {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   flowdeployment.FlowInstancesTable,
			Columns: []string{flowdeployment.FlowInstancesColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: &sqlgraph.FieldSpec{
					Type:   field.TypeString,
					Column: flowinstance.FieldID,
				},
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
	}
	if nodes := fduo.mutation.FlowInstancesIDs(); len(nodes) > 0 {
		edge := &sqlgraph.EdgeSpec{
			Rel:     sqlgraph.O2M,
			Inverse: false,
			Table:   flowdeployment.FlowInstancesTable,
			Columns: []string{flowdeployment.FlowInstancesColumn},
			Bidi:    false,
			Target: &sqlgraph.EdgeTarget{
				IDSpec: &sqlgraph.FieldSpec{
					Type:   field.TypeString,
					Column: flowinstance.FieldID,
				},
			},
		}
		for _, k := range nodes {
			edge.Target.Nodes = append(edge.Target.Nodes, k)
		}
		_spec.Edges.Add = append(_spec.Edges.Add, edge)
	}
	_node = &FlowDeployment{config: fduo.config}
	_spec.Assign = _node.assignValues
	_spec.ScanValues = _node.scanValues
	if err = sqlgraph.UpdateNode(ctx, fduo.driver, _spec); err != nil {
		if _, ok := err.(*sqlgraph.NotFoundError); ok {
			err = &NotFoundError{flowdeployment.Label}
		} else if sqlgraph.IsConstraintError(err) {
			err = &ConstraintError{err.Error(), err}
		}
		return nil, err
	}
	return _node, nil
}