You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1018 lines
29 KiB
1018 lines
29 KiB
// Code generated by ent, DO NOT EDIT.
|
|
|
|
package ent
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"time"
|
|
|
|
"entgo.io/ent/dialect/sql"
|
|
"entgo.io/ent/dialect/sql/sqlgraph"
|
|
"entgo.io/ent/schema/field"
|
|
"github.com/cloudreve/Cloudreve/v4/ent/entity"
|
|
"github.com/cloudreve/Cloudreve/v4/ent/file"
|
|
"github.com/cloudreve/Cloudreve/v4/ent/predicate"
|
|
"github.com/cloudreve/Cloudreve/v4/ent/storagepolicy"
|
|
"github.com/cloudreve/Cloudreve/v4/ent/user"
|
|
"github.com/cloudreve/Cloudreve/v4/inventory/types"
|
|
"github.com/gofrs/uuid"
|
|
)
|
|
|
|
// EntityUpdate is the builder for updating Entity entities.
|
|
type EntityUpdate struct {
|
|
config
|
|
hooks []Hook
|
|
mutation *EntityMutation
|
|
}
|
|
|
|
// Where appends a list predicates to the EntityUpdate builder.
|
|
func (eu *EntityUpdate) Where(ps ...predicate.Entity) *EntityUpdate {
|
|
eu.mutation.Where(ps...)
|
|
return eu
|
|
}
|
|
|
|
// SetUpdatedAt sets the "updated_at" field.
|
|
func (eu *EntityUpdate) SetUpdatedAt(t time.Time) *EntityUpdate {
|
|
eu.mutation.SetUpdatedAt(t)
|
|
return eu
|
|
}
|
|
|
|
// SetDeletedAt sets the "deleted_at" field.
|
|
func (eu *EntityUpdate) SetDeletedAt(t time.Time) *EntityUpdate {
|
|
eu.mutation.SetDeletedAt(t)
|
|
return eu
|
|
}
|
|
|
|
// SetNillableDeletedAt sets the "deleted_at" field if the given value is not nil.
|
|
func (eu *EntityUpdate) SetNillableDeletedAt(t *time.Time) *EntityUpdate {
|
|
if t != nil {
|
|
eu.SetDeletedAt(*t)
|
|
}
|
|
return eu
|
|
}
|
|
|
|
// ClearDeletedAt clears the value of the "deleted_at" field.
|
|
func (eu *EntityUpdate) ClearDeletedAt() *EntityUpdate {
|
|
eu.mutation.ClearDeletedAt()
|
|
return eu
|
|
}
|
|
|
|
// SetType sets the "type" field.
|
|
func (eu *EntityUpdate) SetType(i int) *EntityUpdate {
|
|
eu.mutation.ResetType()
|
|
eu.mutation.SetType(i)
|
|
return eu
|
|
}
|
|
|
|
// SetNillableType sets the "type" field if the given value is not nil.
|
|
func (eu *EntityUpdate) SetNillableType(i *int) *EntityUpdate {
|
|
if i != nil {
|
|
eu.SetType(*i)
|
|
}
|
|
return eu
|
|
}
|
|
|
|
// AddType adds i to the "type" field.
|
|
func (eu *EntityUpdate) AddType(i int) *EntityUpdate {
|
|
eu.mutation.AddType(i)
|
|
return eu
|
|
}
|
|
|
|
// SetSource sets the "source" field.
|
|
func (eu *EntityUpdate) SetSource(s string) *EntityUpdate {
|
|
eu.mutation.SetSource(s)
|
|
return eu
|
|
}
|
|
|
|
// SetNillableSource sets the "source" field if the given value is not nil.
|
|
func (eu *EntityUpdate) SetNillableSource(s *string) *EntityUpdate {
|
|
if s != nil {
|
|
eu.SetSource(*s)
|
|
}
|
|
return eu
|
|
}
|
|
|
|
// SetSize sets the "size" field.
|
|
func (eu *EntityUpdate) SetSize(i int64) *EntityUpdate {
|
|
eu.mutation.ResetSize()
|
|
eu.mutation.SetSize(i)
|
|
return eu
|
|
}
|
|
|
|
// SetNillableSize sets the "size" field if the given value is not nil.
|
|
func (eu *EntityUpdate) SetNillableSize(i *int64) *EntityUpdate {
|
|
if i != nil {
|
|
eu.SetSize(*i)
|
|
}
|
|
return eu
|
|
}
|
|
|
|
// AddSize adds i to the "size" field.
|
|
func (eu *EntityUpdate) AddSize(i int64) *EntityUpdate {
|
|
eu.mutation.AddSize(i)
|
|
return eu
|
|
}
|
|
|
|
// SetReferenceCount sets the "reference_count" field.
|
|
func (eu *EntityUpdate) SetReferenceCount(i int) *EntityUpdate {
|
|
eu.mutation.ResetReferenceCount()
|
|
eu.mutation.SetReferenceCount(i)
|
|
return eu
|
|
}
|
|
|
|
// SetNillableReferenceCount sets the "reference_count" field if the given value is not nil.
|
|
func (eu *EntityUpdate) SetNillableReferenceCount(i *int) *EntityUpdate {
|
|
if i != nil {
|
|
eu.SetReferenceCount(*i)
|
|
}
|
|
return eu
|
|
}
|
|
|
|
// AddReferenceCount adds i to the "reference_count" field.
|
|
func (eu *EntityUpdate) AddReferenceCount(i int) *EntityUpdate {
|
|
eu.mutation.AddReferenceCount(i)
|
|
return eu
|
|
}
|
|
|
|
// SetStoragePolicyEntities sets the "storage_policy_entities" field.
|
|
func (eu *EntityUpdate) SetStoragePolicyEntities(i int) *EntityUpdate {
|
|
eu.mutation.SetStoragePolicyEntities(i)
|
|
return eu
|
|
}
|
|
|
|
// SetNillableStoragePolicyEntities sets the "storage_policy_entities" field if the given value is not nil.
|
|
func (eu *EntityUpdate) SetNillableStoragePolicyEntities(i *int) *EntityUpdate {
|
|
if i != nil {
|
|
eu.SetStoragePolicyEntities(*i)
|
|
}
|
|
return eu
|
|
}
|
|
|
|
// SetCreatedBy sets the "created_by" field.
|
|
func (eu *EntityUpdate) SetCreatedBy(i int) *EntityUpdate {
|
|
eu.mutation.SetCreatedBy(i)
|
|
return eu
|
|
}
|
|
|
|
// SetNillableCreatedBy sets the "created_by" field if the given value is not nil.
|
|
func (eu *EntityUpdate) SetNillableCreatedBy(i *int) *EntityUpdate {
|
|
if i != nil {
|
|
eu.SetCreatedBy(*i)
|
|
}
|
|
return eu
|
|
}
|
|
|
|
// ClearCreatedBy clears the value of the "created_by" field.
|
|
func (eu *EntityUpdate) ClearCreatedBy() *EntityUpdate {
|
|
eu.mutation.ClearCreatedBy()
|
|
return eu
|
|
}
|
|
|
|
// SetUploadSessionID sets the "upload_session_id" field.
|
|
func (eu *EntityUpdate) SetUploadSessionID(u uuid.UUID) *EntityUpdate {
|
|
eu.mutation.SetUploadSessionID(u)
|
|
return eu
|
|
}
|
|
|
|
// SetNillableUploadSessionID sets the "upload_session_id" field if the given value is not nil.
|
|
func (eu *EntityUpdate) SetNillableUploadSessionID(u *uuid.UUID) *EntityUpdate {
|
|
if u != nil {
|
|
eu.SetUploadSessionID(*u)
|
|
}
|
|
return eu
|
|
}
|
|
|
|
// ClearUploadSessionID clears the value of the "upload_session_id" field.
|
|
func (eu *EntityUpdate) ClearUploadSessionID() *EntityUpdate {
|
|
eu.mutation.ClearUploadSessionID()
|
|
return eu
|
|
}
|
|
|
|
// SetRecycleOptions sets the "recycle_options" field.
|
|
func (eu *EntityUpdate) SetRecycleOptions(tro *types.EntityRecycleOption) *EntityUpdate {
|
|
eu.mutation.SetRecycleOptions(tro)
|
|
return eu
|
|
}
|
|
|
|
// ClearRecycleOptions clears the value of the "recycle_options" field.
|
|
func (eu *EntityUpdate) ClearRecycleOptions() *EntityUpdate {
|
|
eu.mutation.ClearRecycleOptions()
|
|
return eu
|
|
}
|
|
|
|
// AddFileIDs adds the "file" edge to the File entity by IDs.
|
|
func (eu *EntityUpdate) AddFileIDs(ids ...int) *EntityUpdate {
|
|
eu.mutation.AddFileIDs(ids...)
|
|
return eu
|
|
}
|
|
|
|
// AddFile adds the "file" edges to the File entity.
|
|
func (eu *EntityUpdate) AddFile(f ...*File) *EntityUpdate {
|
|
ids := make([]int, len(f))
|
|
for i := range f {
|
|
ids[i] = f[i].ID
|
|
}
|
|
return eu.AddFileIDs(ids...)
|
|
}
|
|
|
|
// SetUserID sets the "user" edge to the User entity by ID.
|
|
func (eu *EntityUpdate) SetUserID(id int) *EntityUpdate {
|
|
eu.mutation.SetUserID(id)
|
|
return eu
|
|
}
|
|
|
|
// SetNillableUserID sets the "user" edge to the User entity by ID if the given value is not nil.
|
|
func (eu *EntityUpdate) SetNillableUserID(id *int) *EntityUpdate {
|
|
if id != nil {
|
|
eu = eu.SetUserID(*id)
|
|
}
|
|
return eu
|
|
}
|
|
|
|
// SetUser sets the "user" edge to the User entity.
|
|
func (eu *EntityUpdate) SetUser(u *User) *EntityUpdate {
|
|
return eu.SetUserID(u.ID)
|
|
}
|
|
|
|
// SetStoragePolicyID sets the "storage_policy" edge to the StoragePolicy entity by ID.
|
|
func (eu *EntityUpdate) SetStoragePolicyID(id int) *EntityUpdate {
|
|
eu.mutation.SetStoragePolicyID(id)
|
|
return eu
|
|
}
|
|
|
|
// SetStoragePolicy sets the "storage_policy" edge to the StoragePolicy entity.
|
|
func (eu *EntityUpdate) SetStoragePolicy(s *StoragePolicy) *EntityUpdate {
|
|
return eu.SetStoragePolicyID(s.ID)
|
|
}
|
|
|
|
// Mutation returns the EntityMutation object of the builder.
|
|
func (eu *EntityUpdate) Mutation() *EntityMutation {
|
|
return eu.mutation
|
|
}
|
|
|
|
// ClearFile clears all "file" edges to the File entity.
|
|
func (eu *EntityUpdate) ClearFile() *EntityUpdate {
|
|
eu.mutation.ClearFile()
|
|
return eu
|
|
}
|
|
|
|
// RemoveFileIDs removes the "file" edge to File entities by IDs.
|
|
func (eu *EntityUpdate) RemoveFileIDs(ids ...int) *EntityUpdate {
|
|
eu.mutation.RemoveFileIDs(ids...)
|
|
return eu
|
|
}
|
|
|
|
// RemoveFile removes "file" edges to File entities.
|
|
func (eu *EntityUpdate) RemoveFile(f ...*File) *EntityUpdate {
|
|
ids := make([]int, len(f))
|
|
for i := range f {
|
|
ids[i] = f[i].ID
|
|
}
|
|
return eu.RemoveFileIDs(ids...)
|
|
}
|
|
|
|
// ClearUser clears the "user" edge to the User entity.
|
|
func (eu *EntityUpdate) ClearUser() *EntityUpdate {
|
|
eu.mutation.ClearUser()
|
|
return eu
|
|
}
|
|
|
|
// ClearStoragePolicy clears the "storage_policy" edge to the StoragePolicy entity.
|
|
func (eu *EntityUpdate) ClearStoragePolicy() *EntityUpdate {
|
|
eu.mutation.ClearStoragePolicy()
|
|
return eu
|
|
}
|
|
|
|
// Save executes the query and returns the number of nodes affected by the update operation.
|
|
func (eu *EntityUpdate) Save(ctx context.Context) (int, error) {
|
|
if err := eu.defaults(); err != nil {
|
|
return 0, err
|
|
}
|
|
return withHooks(ctx, eu.sqlSave, eu.mutation, eu.hooks)
|
|
}
|
|
|
|
// SaveX is like Save, but panics if an error occurs.
|
|
func (eu *EntityUpdate) SaveX(ctx context.Context) int {
|
|
affected, err := eu.Save(ctx)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
return affected
|
|
}
|
|
|
|
// Exec executes the query.
|
|
func (eu *EntityUpdate) Exec(ctx context.Context) error {
|
|
_, err := eu.Save(ctx)
|
|
return err
|
|
}
|
|
|
|
// ExecX is like Exec, but panics if an error occurs.
|
|
func (eu *EntityUpdate) ExecX(ctx context.Context) {
|
|
if err := eu.Exec(ctx); err != nil {
|
|
panic(err)
|
|
}
|
|
}
|
|
|
|
// defaults sets the default values of the builder before save.
|
|
func (eu *EntityUpdate) defaults() error {
|
|
if _, ok := eu.mutation.UpdatedAt(); !ok {
|
|
if entity.UpdateDefaultUpdatedAt == nil {
|
|
return fmt.Errorf("ent: uninitialized entity.UpdateDefaultUpdatedAt (forgotten import ent/runtime?)")
|
|
}
|
|
v := entity.UpdateDefaultUpdatedAt()
|
|
eu.mutation.SetUpdatedAt(v)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// check runs all checks and user-defined validators on the builder.
|
|
func (eu *EntityUpdate) check() error {
|
|
if _, ok := eu.mutation.StoragePolicyID(); eu.mutation.StoragePolicyCleared() && !ok {
|
|
return errors.New(`ent: clearing a required unique edge "Entity.storage_policy"`)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (eu *EntityUpdate) sqlSave(ctx context.Context) (n int, err error) {
|
|
if err := eu.check(); err != nil {
|
|
return n, err
|
|
}
|
|
_spec := sqlgraph.NewUpdateSpec(entity.Table, entity.Columns, sqlgraph.NewFieldSpec(entity.FieldID, field.TypeInt))
|
|
if ps := eu.mutation.predicates; len(ps) > 0 {
|
|
_spec.Predicate = func(selector *sql.Selector) {
|
|
for i := range ps {
|
|
ps[i](selector)
|
|
}
|
|
}
|
|
}
|
|
if value, ok := eu.mutation.UpdatedAt(); ok {
|
|
_spec.SetField(entity.FieldUpdatedAt, field.TypeTime, value)
|
|
}
|
|
if value, ok := eu.mutation.DeletedAt(); ok {
|
|
_spec.SetField(entity.FieldDeletedAt, field.TypeTime, value)
|
|
}
|
|
if eu.mutation.DeletedAtCleared() {
|
|
_spec.ClearField(entity.FieldDeletedAt, field.TypeTime)
|
|
}
|
|
if value, ok := eu.mutation.GetType(); ok {
|
|
_spec.SetField(entity.FieldType, field.TypeInt, value)
|
|
}
|
|
if value, ok := eu.mutation.AddedType(); ok {
|
|
_spec.AddField(entity.FieldType, field.TypeInt, value)
|
|
}
|
|
if value, ok := eu.mutation.Source(); ok {
|
|
_spec.SetField(entity.FieldSource, field.TypeString, value)
|
|
}
|
|
if value, ok := eu.mutation.Size(); ok {
|
|
_spec.SetField(entity.FieldSize, field.TypeInt64, value)
|
|
}
|
|
if value, ok := eu.mutation.AddedSize(); ok {
|
|
_spec.AddField(entity.FieldSize, field.TypeInt64, value)
|
|
}
|
|
if value, ok := eu.mutation.ReferenceCount(); ok {
|
|
_spec.SetField(entity.FieldReferenceCount, field.TypeInt, value)
|
|
}
|
|
if value, ok := eu.mutation.AddedReferenceCount(); ok {
|
|
_spec.AddField(entity.FieldReferenceCount, field.TypeInt, value)
|
|
}
|
|
if value, ok := eu.mutation.UploadSessionID(); ok {
|
|
_spec.SetField(entity.FieldUploadSessionID, field.TypeUUID, value)
|
|
}
|
|
if eu.mutation.UploadSessionIDCleared() {
|
|
_spec.ClearField(entity.FieldUploadSessionID, field.TypeUUID)
|
|
}
|
|
if value, ok := eu.mutation.RecycleOptions(); ok {
|
|
_spec.SetField(entity.FieldRecycleOptions, field.TypeJSON, value)
|
|
}
|
|
if eu.mutation.RecycleOptionsCleared() {
|
|
_spec.ClearField(entity.FieldRecycleOptions, field.TypeJSON)
|
|
}
|
|
if eu.mutation.FileCleared() {
|
|
edge := &sqlgraph.EdgeSpec{
|
|
Rel: sqlgraph.M2M,
|
|
Inverse: true,
|
|
Table: entity.FileTable,
|
|
Columns: entity.FilePrimaryKey,
|
|
Bidi: false,
|
|
Target: &sqlgraph.EdgeTarget{
|
|
IDSpec: sqlgraph.NewFieldSpec(file.FieldID, field.TypeInt),
|
|
},
|
|
}
|
|
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
|
|
}
|
|
if nodes := eu.mutation.RemovedFileIDs(); len(nodes) > 0 && !eu.mutation.FileCleared() {
|
|
edge := &sqlgraph.EdgeSpec{
|
|
Rel: sqlgraph.M2M,
|
|
Inverse: true,
|
|
Table: entity.FileTable,
|
|
Columns: entity.FilePrimaryKey,
|
|
Bidi: false,
|
|
Target: &sqlgraph.EdgeTarget{
|
|
IDSpec: sqlgraph.NewFieldSpec(file.FieldID, field.TypeInt),
|
|
},
|
|
}
|
|
for _, k := range nodes {
|
|
edge.Target.Nodes = append(edge.Target.Nodes, k)
|
|
}
|
|
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
|
|
}
|
|
if nodes := eu.mutation.FileIDs(); len(nodes) > 0 {
|
|
edge := &sqlgraph.EdgeSpec{
|
|
Rel: sqlgraph.M2M,
|
|
Inverse: true,
|
|
Table: entity.FileTable,
|
|
Columns: entity.FilePrimaryKey,
|
|
Bidi: false,
|
|
Target: &sqlgraph.EdgeTarget{
|
|
IDSpec: sqlgraph.NewFieldSpec(file.FieldID, field.TypeInt),
|
|
},
|
|
}
|
|
for _, k := range nodes {
|
|
edge.Target.Nodes = append(edge.Target.Nodes, k)
|
|
}
|
|
_spec.Edges.Add = append(_spec.Edges.Add, edge)
|
|
}
|
|
if eu.mutation.UserCleared() {
|
|
edge := &sqlgraph.EdgeSpec{
|
|
Rel: sqlgraph.M2O,
|
|
Inverse: true,
|
|
Table: entity.UserTable,
|
|
Columns: []string{entity.UserColumn},
|
|
Bidi: false,
|
|
Target: &sqlgraph.EdgeTarget{
|
|
IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt),
|
|
},
|
|
}
|
|
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
|
|
}
|
|
if nodes := eu.mutation.UserIDs(); len(nodes) > 0 {
|
|
edge := &sqlgraph.EdgeSpec{
|
|
Rel: sqlgraph.M2O,
|
|
Inverse: true,
|
|
Table: entity.UserTable,
|
|
Columns: []string{entity.UserColumn},
|
|
Bidi: false,
|
|
Target: &sqlgraph.EdgeTarget{
|
|
IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt),
|
|
},
|
|
}
|
|
for _, k := range nodes {
|
|
edge.Target.Nodes = append(edge.Target.Nodes, k)
|
|
}
|
|
_spec.Edges.Add = append(_spec.Edges.Add, edge)
|
|
}
|
|
if eu.mutation.StoragePolicyCleared() {
|
|
edge := &sqlgraph.EdgeSpec{
|
|
Rel: sqlgraph.M2O,
|
|
Inverse: true,
|
|
Table: entity.StoragePolicyTable,
|
|
Columns: []string{entity.StoragePolicyColumn},
|
|
Bidi: false,
|
|
Target: &sqlgraph.EdgeTarget{
|
|
IDSpec: sqlgraph.NewFieldSpec(storagepolicy.FieldID, field.TypeInt),
|
|
},
|
|
}
|
|
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
|
|
}
|
|
if nodes := eu.mutation.StoragePolicyIDs(); len(nodes) > 0 {
|
|
edge := &sqlgraph.EdgeSpec{
|
|
Rel: sqlgraph.M2O,
|
|
Inverse: true,
|
|
Table: entity.StoragePolicyTable,
|
|
Columns: []string{entity.StoragePolicyColumn},
|
|
Bidi: false,
|
|
Target: &sqlgraph.EdgeTarget{
|
|
IDSpec: sqlgraph.NewFieldSpec(storagepolicy.FieldID, field.TypeInt),
|
|
},
|
|
}
|
|
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, eu.driver, _spec); err != nil {
|
|
if _, ok := err.(*sqlgraph.NotFoundError); ok {
|
|
err = &NotFoundError{entity.Label}
|
|
} else if sqlgraph.IsConstraintError(err) {
|
|
err = &ConstraintError{msg: err.Error(), wrap: err}
|
|
}
|
|
return 0, err
|
|
}
|
|
eu.mutation.done = true
|
|
return n, nil
|
|
}
|
|
|
|
// EntityUpdateOne is the builder for updating a single Entity entity.
|
|
type EntityUpdateOne struct {
|
|
config
|
|
fields []string
|
|
hooks []Hook
|
|
mutation *EntityMutation
|
|
}
|
|
|
|
// SetUpdatedAt sets the "updated_at" field.
|
|
func (euo *EntityUpdateOne) SetUpdatedAt(t time.Time) *EntityUpdateOne {
|
|
euo.mutation.SetUpdatedAt(t)
|
|
return euo
|
|
}
|
|
|
|
// SetDeletedAt sets the "deleted_at" field.
|
|
func (euo *EntityUpdateOne) SetDeletedAt(t time.Time) *EntityUpdateOne {
|
|
euo.mutation.SetDeletedAt(t)
|
|
return euo
|
|
}
|
|
|
|
// SetNillableDeletedAt sets the "deleted_at" field if the given value is not nil.
|
|
func (euo *EntityUpdateOne) SetNillableDeletedAt(t *time.Time) *EntityUpdateOne {
|
|
if t != nil {
|
|
euo.SetDeletedAt(*t)
|
|
}
|
|
return euo
|
|
}
|
|
|
|
// ClearDeletedAt clears the value of the "deleted_at" field.
|
|
func (euo *EntityUpdateOne) ClearDeletedAt() *EntityUpdateOne {
|
|
euo.mutation.ClearDeletedAt()
|
|
return euo
|
|
}
|
|
|
|
// SetType sets the "type" field.
|
|
func (euo *EntityUpdateOne) SetType(i int) *EntityUpdateOne {
|
|
euo.mutation.ResetType()
|
|
euo.mutation.SetType(i)
|
|
return euo
|
|
}
|
|
|
|
// SetNillableType sets the "type" field if the given value is not nil.
|
|
func (euo *EntityUpdateOne) SetNillableType(i *int) *EntityUpdateOne {
|
|
if i != nil {
|
|
euo.SetType(*i)
|
|
}
|
|
return euo
|
|
}
|
|
|
|
// AddType adds i to the "type" field.
|
|
func (euo *EntityUpdateOne) AddType(i int) *EntityUpdateOne {
|
|
euo.mutation.AddType(i)
|
|
return euo
|
|
}
|
|
|
|
// SetSource sets the "source" field.
|
|
func (euo *EntityUpdateOne) SetSource(s string) *EntityUpdateOne {
|
|
euo.mutation.SetSource(s)
|
|
return euo
|
|
}
|
|
|
|
// SetNillableSource sets the "source" field if the given value is not nil.
|
|
func (euo *EntityUpdateOne) SetNillableSource(s *string) *EntityUpdateOne {
|
|
if s != nil {
|
|
euo.SetSource(*s)
|
|
}
|
|
return euo
|
|
}
|
|
|
|
// SetSize sets the "size" field.
|
|
func (euo *EntityUpdateOne) SetSize(i int64) *EntityUpdateOne {
|
|
euo.mutation.ResetSize()
|
|
euo.mutation.SetSize(i)
|
|
return euo
|
|
}
|
|
|
|
// SetNillableSize sets the "size" field if the given value is not nil.
|
|
func (euo *EntityUpdateOne) SetNillableSize(i *int64) *EntityUpdateOne {
|
|
if i != nil {
|
|
euo.SetSize(*i)
|
|
}
|
|
return euo
|
|
}
|
|
|
|
// AddSize adds i to the "size" field.
|
|
func (euo *EntityUpdateOne) AddSize(i int64) *EntityUpdateOne {
|
|
euo.mutation.AddSize(i)
|
|
return euo
|
|
}
|
|
|
|
// SetReferenceCount sets the "reference_count" field.
|
|
func (euo *EntityUpdateOne) SetReferenceCount(i int) *EntityUpdateOne {
|
|
euo.mutation.ResetReferenceCount()
|
|
euo.mutation.SetReferenceCount(i)
|
|
return euo
|
|
}
|
|
|
|
// SetNillableReferenceCount sets the "reference_count" field if the given value is not nil.
|
|
func (euo *EntityUpdateOne) SetNillableReferenceCount(i *int) *EntityUpdateOne {
|
|
if i != nil {
|
|
euo.SetReferenceCount(*i)
|
|
}
|
|
return euo
|
|
}
|
|
|
|
// AddReferenceCount adds i to the "reference_count" field.
|
|
func (euo *EntityUpdateOne) AddReferenceCount(i int) *EntityUpdateOne {
|
|
euo.mutation.AddReferenceCount(i)
|
|
return euo
|
|
}
|
|
|
|
// SetStoragePolicyEntities sets the "storage_policy_entities" field.
|
|
func (euo *EntityUpdateOne) SetStoragePolicyEntities(i int) *EntityUpdateOne {
|
|
euo.mutation.SetStoragePolicyEntities(i)
|
|
return euo
|
|
}
|
|
|
|
// SetNillableStoragePolicyEntities sets the "storage_policy_entities" field if the given value is not nil.
|
|
func (euo *EntityUpdateOne) SetNillableStoragePolicyEntities(i *int) *EntityUpdateOne {
|
|
if i != nil {
|
|
euo.SetStoragePolicyEntities(*i)
|
|
}
|
|
return euo
|
|
}
|
|
|
|
// SetCreatedBy sets the "created_by" field.
|
|
func (euo *EntityUpdateOne) SetCreatedBy(i int) *EntityUpdateOne {
|
|
euo.mutation.SetCreatedBy(i)
|
|
return euo
|
|
}
|
|
|
|
// SetNillableCreatedBy sets the "created_by" field if the given value is not nil.
|
|
func (euo *EntityUpdateOne) SetNillableCreatedBy(i *int) *EntityUpdateOne {
|
|
if i != nil {
|
|
euo.SetCreatedBy(*i)
|
|
}
|
|
return euo
|
|
}
|
|
|
|
// ClearCreatedBy clears the value of the "created_by" field.
|
|
func (euo *EntityUpdateOne) ClearCreatedBy() *EntityUpdateOne {
|
|
euo.mutation.ClearCreatedBy()
|
|
return euo
|
|
}
|
|
|
|
// SetUploadSessionID sets the "upload_session_id" field.
|
|
func (euo *EntityUpdateOne) SetUploadSessionID(u uuid.UUID) *EntityUpdateOne {
|
|
euo.mutation.SetUploadSessionID(u)
|
|
return euo
|
|
}
|
|
|
|
// SetNillableUploadSessionID sets the "upload_session_id" field if the given value is not nil.
|
|
func (euo *EntityUpdateOne) SetNillableUploadSessionID(u *uuid.UUID) *EntityUpdateOne {
|
|
if u != nil {
|
|
euo.SetUploadSessionID(*u)
|
|
}
|
|
return euo
|
|
}
|
|
|
|
// ClearUploadSessionID clears the value of the "upload_session_id" field.
|
|
func (euo *EntityUpdateOne) ClearUploadSessionID() *EntityUpdateOne {
|
|
euo.mutation.ClearUploadSessionID()
|
|
return euo
|
|
}
|
|
|
|
// SetRecycleOptions sets the "recycle_options" field.
|
|
func (euo *EntityUpdateOne) SetRecycleOptions(tro *types.EntityRecycleOption) *EntityUpdateOne {
|
|
euo.mutation.SetRecycleOptions(tro)
|
|
return euo
|
|
}
|
|
|
|
// ClearRecycleOptions clears the value of the "recycle_options" field.
|
|
func (euo *EntityUpdateOne) ClearRecycleOptions() *EntityUpdateOne {
|
|
euo.mutation.ClearRecycleOptions()
|
|
return euo
|
|
}
|
|
|
|
// AddFileIDs adds the "file" edge to the File entity by IDs.
|
|
func (euo *EntityUpdateOne) AddFileIDs(ids ...int) *EntityUpdateOne {
|
|
euo.mutation.AddFileIDs(ids...)
|
|
return euo
|
|
}
|
|
|
|
// AddFile adds the "file" edges to the File entity.
|
|
func (euo *EntityUpdateOne) AddFile(f ...*File) *EntityUpdateOne {
|
|
ids := make([]int, len(f))
|
|
for i := range f {
|
|
ids[i] = f[i].ID
|
|
}
|
|
return euo.AddFileIDs(ids...)
|
|
}
|
|
|
|
// SetUserID sets the "user" edge to the User entity by ID.
|
|
func (euo *EntityUpdateOne) SetUserID(id int) *EntityUpdateOne {
|
|
euo.mutation.SetUserID(id)
|
|
return euo
|
|
}
|
|
|
|
// SetNillableUserID sets the "user" edge to the User entity by ID if the given value is not nil.
|
|
func (euo *EntityUpdateOne) SetNillableUserID(id *int) *EntityUpdateOne {
|
|
if id != nil {
|
|
euo = euo.SetUserID(*id)
|
|
}
|
|
return euo
|
|
}
|
|
|
|
// SetUser sets the "user" edge to the User entity.
|
|
func (euo *EntityUpdateOne) SetUser(u *User) *EntityUpdateOne {
|
|
return euo.SetUserID(u.ID)
|
|
}
|
|
|
|
// SetStoragePolicyID sets the "storage_policy" edge to the StoragePolicy entity by ID.
|
|
func (euo *EntityUpdateOne) SetStoragePolicyID(id int) *EntityUpdateOne {
|
|
euo.mutation.SetStoragePolicyID(id)
|
|
return euo
|
|
}
|
|
|
|
// SetStoragePolicy sets the "storage_policy" edge to the StoragePolicy entity.
|
|
func (euo *EntityUpdateOne) SetStoragePolicy(s *StoragePolicy) *EntityUpdateOne {
|
|
return euo.SetStoragePolicyID(s.ID)
|
|
}
|
|
|
|
// Mutation returns the EntityMutation object of the builder.
|
|
func (euo *EntityUpdateOne) Mutation() *EntityMutation {
|
|
return euo.mutation
|
|
}
|
|
|
|
// ClearFile clears all "file" edges to the File entity.
|
|
func (euo *EntityUpdateOne) ClearFile() *EntityUpdateOne {
|
|
euo.mutation.ClearFile()
|
|
return euo
|
|
}
|
|
|
|
// RemoveFileIDs removes the "file" edge to File entities by IDs.
|
|
func (euo *EntityUpdateOne) RemoveFileIDs(ids ...int) *EntityUpdateOne {
|
|
euo.mutation.RemoveFileIDs(ids...)
|
|
return euo
|
|
}
|
|
|
|
// RemoveFile removes "file" edges to File entities.
|
|
func (euo *EntityUpdateOne) RemoveFile(f ...*File) *EntityUpdateOne {
|
|
ids := make([]int, len(f))
|
|
for i := range f {
|
|
ids[i] = f[i].ID
|
|
}
|
|
return euo.RemoveFileIDs(ids...)
|
|
}
|
|
|
|
// ClearUser clears the "user" edge to the User entity.
|
|
func (euo *EntityUpdateOne) ClearUser() *EntityUpdateOne {
|
|
euo.mutation.ClearUser()
|
|
return euo
|
|
}
|
|
|
|
// ClearStoragePolicy clears the "storage_policy" edge to the StoragePolicy entity.
|
|
func (euo *EntityUpdateOne) ClearStoragePolicy() *EntityUpdateOne {
|
|
euo.mutation.ClearStoragePolicy()
|
|
return euo
|
|
}
|
|
|
|
// Where appends a list predicates to the EntityUpdate builder.
|
|
func (euo *EntityUpdateOne) Where(ps ...predicate.Entity) *EntityUpdateOne {
|
|
euo.mutation.Where(ps...)
|
|
return euo
|
|
}
|
|
|
|
// Select allows selecting one or more fields (columns) of the returned entity.
|
|
// The default is selecting all fields defined in the entity schema.
|
|
func (euo *EntityUpdateOne) Select(field string, fields ...string) *EntityUpdateOne {
|
|
euo.fields = append([]string{field}, fields...)
|
|
return euo
|
|
}
|
|
|
|
// Save executes the query and returns the updated Entity entity.
|
|
func (euo *EntityUpdateOne) Save(ctx context.Context) (*Entity, error) {
|
|
if err := euo.defaults(); err != nil {
|
|
return nil, err
|
|
}
|
|
return withHooks(ctx, euo.sqlSave, euo.mutation, euo.hooks)
|
|
}
|
|
|
|
// SaveX is like Save, but panics if an error occurs.
|
|
func (euo *EntityUpdateOne) SaveX(ctx context.Context) *Entity {
|
|
node, err := euo.Save(ctx)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
return node
|
|
}
|
|
|
|
// Exec executes the query on the entity.
|
|
func (euo *EntityUpdateOne) Exec(ctx context.Context) error {
|
|
_, err := euo.Save(ctx)
|
|
return err
|
|
}
|
|
|
|
// ExecX is like Exec, but panics if an error occurs.
|
|
func (euo *EntityUpdateOne) ExecX(ctx context.Context) {
|
|
if err := euo.Exec(ctx); err != nil {
|
|
panic(err)
|
|
}
|
|
}
|
|
|
|
// defaults sets the default values of the builder before save.
|
|
func (euo *EntityUpdateOne) defaults() error {
|
|
if _, ok := euo.mutation.UpdatedAt(); !ok {
|
|
if entity.UpdateDefaultUpdatedAt == nil {
|
|
return fmt.Errorf("ent: uninitialized entity.UpdateDefaultUpdatedAt (forgotten import ent/runtime?)")
|
|
}
|
|
v := entity.UpdateDefaultUpdatedAt()
|
|
euo.mutation.SetUpdatedAt(v)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// check runs all checks and user-defined validators on the builder.
|
|
func (euo *EntityUpdateOne) check() error {
|
|
if _, ok := euo.mutation.StoragePolicyID(); euo.mutation.StoragePolicyCleared() && !ok {
|
|
return errors.New(`ent: clearing a required unique edge "Entity.storage_policy"`)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (euo *EntityUpdateOne) sqlSave(ctx context.Context) (_node *Entity, err error) {
|
|
if err := euo.check(); err != nil {
|
|
return _node, err
|
|
}
|
|
_spec := sqlgraph.NewUpdateSpec(entity.Table, entity.Columns, sqlgraph.NewFieldSpec(entity.FieldID, field.TypeInt))
|
|
id, ok := euo.mutation.ID()
|
|
if !ok {
|
|
return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "Entity.id" for update`)}
|
|
}
|
|
_spec.Node.ID.Value = id
|
|
if fields := euo.fields; len(fields) > 0 {
|
|
_spec.Node.Columns = make([]string, 0, len(fields))
|
|
_spec.Node.Columns = append(_spec.Node.Columns, entity.FieldID)
|
|
for _, f := range fields {
|
|
if !entity.ValidColumn(f) {
|
|
return nil, &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
|
|
}
|
|
if f != entity.FieldID {
|
|
_spec.Node.Columns = append(_spec.Node.Columns, f)
|
|
}
|
|
}
|
|
}
|
|
if ps := euo.mutation.predicates; len(ps) > 0 {
|
|
_spec.Predicate = func(selector *sql.Selector) {
|
|
for i := range ps {
|
|
ps[i](selector)
|
|
}
|
|
}
|
|
}
|
|
if value, ok := euo.mutation.UpdatedAt(); ok {
|
|
_spec.SetField(entity.FieldUpdatedAt, field.TypeTime, value)
|
|
}
|
|
if value, ok := euo.mutation.DeletedAt(); ok {
|
|
_spec.SetField(entity.FieldDeletedAt, field.TypeTime, value)
|
|
}
|
|
if euo.mutation.DeletedAtCleared() {
|
|
_spec.ClearField(entity.FieldDeletedAt, field.TypeTime)
|
|
}
|
|
if value, ok := euo.mutation.GetType(); ok {
|
|
_spec.SetField(entity.FieldType, field.TypeInt, value)
|
|
}
|
|
if value, ok := euo.mutation.AddedType(); ok {
|
|
_spec.AddField(entity.FieldType, field.TypeInt, value)
|
|
}
|
|
if value, ok := euo.mutation.Source(); ok {
|
|
_spec.SetField(entity.FieldSource, field.TypeString, value)
|
|
}
|
|
if value, ok := euo.mutation.Size(); ok {
|
|
_spec.SetField(entity.FieldSize, field.TypeInt64, value)
|
|
}
|
|
if value, ok := euo.mutation.AddedSize(); ok {
|
|
_spec.AddField(entity.FieldSize, field.TypeInt64, value)
|
|
}
|
|
if value, ok := euo.mutation.ReferenceCount(); ok {
|
|
_spec.SetField(entity.FieldReferenceCount, field.TypeInt, value)
|
|
}
|
|
if value, ok := euo.mutation.AddedReferenceCount(); ok {
|
|
_spec.AddField(entity.FieldReferenceCount, field.TypeInt, value)
|
|
}
|
|
if value, ok := euo.mutation.UploadSessionID(); ok {
|
|
_spec.SetField(entity.FieldUploadSessionID, field.TypeUUID, value)
|
|
}
|
|
if euo.mutation.UploadSessionIDCleared() {
|
|
_spec.ClearField(entity.FieldUploadSessionID, field.TypeUUID)
|
|
}
|
|
if value, ok := euo.mutation.RecycleOptions(); ok {
|
|
_spec.SetField(entity.FieldRecycleOptions, field.TypeJSON, value)
|
|
}
|
|
if euo.mutation.RecycleOptionsCleared() {
|
|
_spec.ClearField(entity.FieldRecycleOptions, field.TypeJSON)
|
|
}
|
|
if euo.mutation.FileCleared() {
|
|
edge := &sqlgraph.EdgeSpec{
|
|
Rel: sqlgraph.M2M,
|
|
Inverse: true,
|
|
Table: entity.FileTable,
|
|
Columns: entity.FilePrimaryKey,
|
|
Bidi: false,
|
|
Target: &sqlgraph.EdgeTarget{
|
|
IDSpec: sqlgraph.NewFieldSpec(file.FieldID, field.TypeInt),
|
|
},
|
|
}
|
|
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
|
|
}
|
|
if nodes := euo.mutation.RemovedFileIDs(); len(nodes) > 0 && !euo.mutation.FileCleared() {
|
|
edge := &sqlgraph.EdgeSpec{
|
|
Rel: sqlgraph.M2M,
|
|
Inverse: true,
|
|
Table: entity.FileTable,
|
|
Columns: entity.FilePrimaryKey,
|
|
Bidi: false,
|
|
Target: &sqlgraph.EdgeTarget{
|
|
IDSpec: sqlgraph.NewFieldSpec(file.FieldID, field.TypeInt),
|
|
},
|
|
}
|
|
for _, k := range nodes {
|
|
edge.Target.Nodes = append(edge.Target.Nodes, k)
|
|
}
|
|
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
|
|
}
|
|
if nodes := euo.mutation.FileIDs(); len(nodes) > 0 {
|
|
edge := &sqlgraph.EdgeSpec{
|
|
Rel: sqlgraph.M2M,
|
|
Inverse: true,
|
|
Table: entity.FileTable,
|
|
Columns: entity.FilePrimaryKey,
|
|
Bidi: false,
|
|
Target: &sqlgraph.EdgeTarget{
|
|
IDSpec: sqlgraph.NewFieldSpec(file.FieldID, field.TypeInt),
|
|
},
|
|
}
|
|
for _, k := range nodes {
|
|
edge.Target.Nodes = append(edge.Target.Nodes, k)
|
|
}
|
|
_spec.Edges.Add = append(_spec.Edges.Add, edge)
|
|
}
|
|
if euo.mutation.UserCleared() {
|
|
edge := &sqlgraph.EdgeSpec{
|
|
Rel: sqlgraph.M2O,
|
|
Inverse: true,
|
|
Table: entity.UserTable,
|
|
Columns: []string{entity.UserColumn},
|
|
Bidi: false,
|
|
Target: &sqlgraph.EdgeTarget{
|
|
IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt),
|
|
},
|
|
}
|
|
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
|
|
}
|
|
if nodes := euo.mutation.UserIDs(); len(nodes) > 0 {
|
|
edge := &sqlgraph.EdgeSpec{
|
|
Rel: sqlgraph.M2O,
|
|
Inverse: true,
|
|
Table: entity.UserTable,
|
|
Columns: []string{entity.UserColumn},
|
|
Bidi: false,
|
|
Target: &sqlgraph.EdgeTarget{
|
|
IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt),
|
|
},
|
|
}
|
|
for _, k := range nodes {
|
|
edge.Target.Nodes = append(edge.Target.Nodes, k)
|
|
}
|
|
_spec.Edges.Add = append(_spec.Edges.Add, edge)
|
|
}
|
|
if euo.mutation.StoragePolicyCleared() {
|
|
edge := &sqlgraph.EdgeSpec{
|
|
Rel: sqlgraph.M2O,
|
|
Inverse: true,
|
|
Table: entity.StoragePolicyTable,
|
|
Columns: []string{entity.StoragePolicyColumn},
|
|
Bidi: false,
|
|
Target: &sqlgraph.EdgeTarget{
|
|
IDSpec: sqlgraph.NewFieldSpec(storagepolicy.FieldID, field.TypeInt),
|
|
},
|
|
}
|
|
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
|
|
}
|
|
if nodes := euo.mutation.StoragePolicyIDs(); len(nodes) > 0 {
|
|
edge := &sqlgraph.EdgeSpec{
|
|
Rel: sqlgraph.M2O,
|
|
Inverse: true,
|
|
Table: entity.StoragePolicyTable,
|
|
Columns: []string{entity.StoragePolicyColumn},
|
|
Bidi: false,
|
|
Target: &sqlgraph.EdgeTarget{
|
|
IDSpec: sqlgraph.NewFieldSpec(storagepolicy.FieldID, field.TypeInt),
|
|
},
|
|
}
|
|
for _, k := range nodes {
|
|
edge.Target.Nodes = append(edge.Target.Nodes, k)
|
|
}
|
|
_spec.Edges.Add = append(_spec.Edges.Add, edge)
|
|
}
|
|
_node = &Entity{config: euo.config}
|
|
_spec.Assign = _node.assignValues
|
|
_spec.ScanValues = _node.scanValues
|
|
if err = sqlgraph.UpdateNode(ctx, euo.driver, _spec); err != nil {
|
|
if _, ok := err.(*sqlgraph.NotFoundError); ok {
|
|
err = &NotFoundError{entity.Label}
|
|
} else if sqlgraph.IsConstraintError(err) {
|
|
err = &ConstraintError{msg: err.Error(), wrap: err}
|
|
}
|
|
return nil, err
|
|
}
|
|
euo.mutation.done = true
|
|
return _node, nil
|
|
}
|