From f28bc7226fa8d3cd1ba32bb2465556ffced68ad5 Mon Sep 17 00:00:00 2001 From: Rogee Date: Fri, 23 May 2025 23:50:26 +0800 Subject: [PATCH] feat: update func --- backend/app/model/medias.funcs.gen.go | 22 ++++++++++++---------- backend/app/model/medias.go | 13 +++++++++++++ backend/app/model/orders.funcs.gen.go | 24 +++++++++++++----------- backend/app/model/orders.go | 15 +++++++++++++++ backend/app/model/posts.funcs.gen.go | 24 +++++++++++++----------- backend/app/model/posts.go | 15 +++++++++++++++ backend/app/model/users.funcs.gen.go | 24 +++++++++++++----------- backend/app/model/users.go | 15 +++++++++++++++ 8 files changed, 109 insertions(+), 43 deletions(-) diff --git a/backend/app/model/medias.funcs.gen.go b/backend/app/model/medias.funcs.gen.go index 8f0f9cb..6b1ee58 100644 --- a/backend/app/model/medias.funcs.gen.go +++ b/backend/app/model/medias.funcs.gen.go @@ -82,18 +82,20 @@ func (m *Medias) BatchForceDelete(ctx context.Context, ids []int64) error { return nil } -func (m *Medias) Update(ctx context.Context) error { - stmt := table.Medias.UPDATE(table.Medias.MutableColumns.Except(mediasUpdateExcludeColumns...)).SET(m).WHERE(table.Medias.ID.EQ(Int(m.ID))).RETURNING(table.Medias.AllColumns) - m.log().WithField("func", "Update").Info(stmt.DebugSql()) +// func (m *Medias) Update(ctx context.Context) error { +// - if err := stmt.QueryContext(ctx, db, m); err != nil { - m.log().WithField("func", "Update").Errorf("error updating Medias item: %v", err) - return err - } +// stmt := table.Medias.UPDATE(table.Medias.MutableColumns.Except(mediasUpdateExcludeColumns...)).SET(m).WHERE(table.Medias.ID.EQ(Int(m.ID))).RETURNING(table.Medias.AllColumns) +// m.log().WithField("func", "Update").Info(stmt.DebugSql()) - m.log().WithField("func", "Update").Infof("Medias item updated successfully") - return nil -} +// if err := stmt.QueryContext(ctx, db, m); err != nil { +// m.log().WithField("func","Update").Errorf("error updating Medias item: %v", err) +// return err +// } + +// m.log().WithField("func", "Update").Infof("Medias item updated successfully") +// return nil +// } // GetByCond func (m *Medias) GetByCond(ctx context.Context, conds ...Cond) (*Medias, error) { diff --git a/backend/app/model/medias.go b/backend/app/model/medias.go index 3e4a14f..55de1a0 100644 --- a/backend/app/model/medias.go +++ b/backend/app/model/medias.go @@ -148,3 +148,16 @@ func (m *Medias) GetRelations(ctx context.Context, hash string) ([]*Medias, erro return &media }), nil } + +func (m *Medias) Update(ctx context.Context) error { + stmt := table.Medias.UPDATE(table.Medias.MutableColumns.Except(table.Medias.CreatedAt)).SET(m).WHERE(table.Medias.ID.EQ(Int(m.ID))).RETURNING(table.Medias.AllColumns) + m.log().WithField("func", "Update").Info(stmt.DebugSql()) + + if err := stmt.QueryContext(ctx, db, m); err != nil { + m.log().WithField("func", "Update").Errorf("error updating Medias item: %v", err) + return err + } + + m.log().WithField("func", "Update").Infof("Medias item updated successfully") + return nil +} diff --git a/backend/app/model/orders.funcs.gen.go b/backend/app/model/orders.funcs.gen.go index 80f355c..5c8f47d 100644 --- a/backend/app/model/orders.funcs.gen.go +++ b/backend/app/model/orders.funcs.gen.go @@ -83,20 +83,22 @@ func (m *Orders) BatchForceDelete(ctx context.Context, ids []int64) error { return nil } -func (m *Orders) Update(ctx context.Context) error { - m.UpdatedAt = time.Now() +// func (m *Orders) Update(ctx context.Context) error { +// +// m.UpdatedAt = time.Now() +// - stmt := table.Orders.UPDATE(table.Orders.MutableColumns.Except(ordersUpdateExcludeColumns...)).SET(m).WHERE(table.Orders.ID.EQ(Int(m.ID))).RETURNING(table.Orders.AllColumns) - m.log().WithField("func", "Update").Info(stmt.DebugSql()) +// stmt := table.Orders.UPDATE(table.Orders.MutableColumns.Except(ordersUpdateExcludeColumns...)).SET(m).WHERE(table.Orders.ID.EQ(Int(m.ID))).RETURNING(table.Orders.AllColumns) +// m.log().WithField("func", "Update").Info(stmt.DebugSql()) - if err := stmt.QueryContext(ctx, db, m); err != nil { - m.log().WithField("func", "Update").Errorf("error updating Orders item: %v", err) - return err - } +// if err := stmt.QueryContext(ctx, db, m); err != nil { +// m.log().WithField("func","Update").Errorf("error updating Orders item: %v", err) +// return err +// } - m.log().WithField("func", "Update").Infof("Orders item updated successfully") - return nil -} +// m.log().WithField("func", "Update").Infof("Orders item updated successfully") +// return nil +// } // GetByCond func (m *Orders) GetByCond(ctx context.Context, conds ...Cond) (*Orders, error) { diff --git a/backend/app/model/orders.go b/backend/app/model/orders.go index 7382cfe..433ed0e 100644 --- a/backend/app/model/orders.go +++ b/backend/app/model/orders.go @@ -23,6 +23,21 @@ var ordersUpdateExcludeColumns = []Column{ table.Orders.UserID, } +func (m *Orders) Update(ctx context.Context) error { + m.UpdatedAt = time.Now() + + stmt := table.Orders.UPDATE(table.Orders.MutableColumns.Except(table.Orders.OrderNo, table.Orders.Price, table.Orders.Discount, table.Orders.SubOrderNo, table.Orders.PostID, table.Orders.UserID)).SET(m).WHERE(table.Orders.ID.EQ(Int(m.ID))).RETURNING(table.Orders.AllColumns) + m.log().WithField("func", "Update").Info(stmt.DebugSql()) + + if err := stmt.QueryContext(ctx, db, m); err != nil { + m.log().WithField("func", "Update").Errorf("error updating Orders item: %v", err) + return err + } + + m.log().WithField("func", "Update").Infof("Orders item updated successfully") + return nil +} + // BuildConditionWithKey builds the WHERE clause for order queries func (m *Orders) BuildConditionWithKey(orderNumber *string, userID *int64) BoolExpression { tbl := table.Orders diff --git a/backend/app/model/posts.funcs.gen.go b/backend/app/model/posts.funcs.gen.go index 72f869d..77448e9 100644 --- a/backend/app/model/posts.funcs.gen.go +++ b/backend/app/model/posts.funcs.gen.go @@ -119,20 +119,22 @@ func (m *Posts) BatchForceDelete(ctx context.Context, ids []int64) error { return nil } -func (m *Posts) Update(ctx context.Context) error { - m.UpdatedAt = time.Now() +// func (m *Posts) Update(ctx context.Context) error { +// +// m.UpdatedAt = time.Now() +// - stmt := table.Posts.UPDATE(table.Posts.MutableColumns.Except(postsUpdateExcludeColumns...)).SET(m).WHERE(table.Posts.ID.EQ(Int(m.ID))).RETURNING(table.Posts.AllColumns) - m.log().WithField("func", "Update").Info(stmt.DebugSql()) +// stmt := table.Posts.UPDATE(table.Posts.MutableColumns.Except(postsUpdateExcludeColumns...)).SET(m).WHERE(table.Posts.ID.EQ(Int(m.ID))).RETURNING(table.Posts.AllColumns) +// m.log().WithField("func", "Update").Info(stmt.DebugSql()) - if err := stmt.QueryContext(ctx, db, m); err != nil { - m.log().WithField("func", "Update").Errorf("error updating Posts item: %v", err) - return err - } +// if err := stmt.QueryContext(ctx, db, m); err != nil { +// m.log().WithField("func","Update").Errorf("error updating Posts item: %v", err) +// return err +// } - m.log().WithField("func", "Update").Infof("Posts item updated successfully") - return nil -} +// m.log().WithField("func", "Update").Infof("Posts item updated successfully") +// return nil +// } // GetByCond func (m *Posts) GetByCond(ctx context.Context, conds ...Cond) (*Posts, error) { diff --git a/backend/app/model/posts.go b/backend/app/model/posts.go index 8205ec3..af4fa93 100644 --- a/backend/app/model/posts.go +++ b/backend/app/model/posts.go @@ -19,6 +19,21 @@ var postsUpdateExcludeColumns = []Column{ table.Posts.Likes, } +func (m *Posts) Update(ctx context.Context) error { + m.UpdatedAt = time.Now() + + stmt := table.Posts.UPDATE(table.Posts.MutableColumns.Except(table.Posts.CreatedAt, table.Posts.DeletedAt, table.Posts.Views, table.Posts.Likes)).SET(m).WHERE(table.Posts.ID.EQ(Int(m.ID))).RETURNING(table.Posts.AllColumns) + m.log().WithField("func", "Update").Info(stmt.DebugSql()) + + if err := stmt.QueryContext(ctx, db, m); err != nil { + m.log().WithField("func", "Update").Errorf("error updating Posts item: %v", err) + return err + } + + m.log().WithField("func", "Update").Infof("Posts item updated successfully") + return nil +} + func (m *Posts) CondStatus(s fields.PostStatus) Cond { return func(cond BoolExpression) BoolExpression { return cond.AND(table.Posts.Status.EQ(Int(int64(s)))) diff --git a/backend/app/model/users.funcs.gen.go b/backend/app/model/users.funcs.gen.go index 7dc2902..ce80bc9 100644 --- a/backend/app/model/users.funcs.gen.go +++ b/backend/app/model/users.funcs.gen.go @@ -119,20 +119,22 @@ func (m *Users) BatchForceDelete(ctx context.Context, ids []int64) error { return nil } -func (m *Users) Update(ctx context.Context) error { - m.UpdatedAt = time.Now() +// func (m *Users) Update(ctx context.Context) error { +// +// m.UpdatedAt = time.Now() +// - stmt := table.Users.UPDATE(table.Users.MutableColumns.Except(usersUpdateExcludeColumns...)).SET(m).WHERE(table.Users.ID.EQ(Int(m.ID))).RETURNING(table.Users.AllColumns) - m.log().WithField("func", "Update").Info(stmt.DebugSql()) +// stmt := table.Users.UPDATE(table.Users.MutableColumns.Except(usersUpdateExcludeColumns...)).SET(m).WHERE(table.Users.ID.EQ(Int(m.ID))).RETURNING(table.Users.AllColumns) +// m.log().WithField("func", "Update").Info(stmt.DebugSql()) - if err := stmt.QueryContext(ctx, db, m); err != nil { - m.log().WithField("func", "Update").Errorf("error updating Users item: %v", err) - return err - } +// if err := stmt.QueryContext(ctx, db, m); err != nil { +// m.log().WithField("func","Update").Errorf("error updating Users item: %v", err) +// return err +// } - m.log().WithField("func", "Update").Infof("Users item updated successfully") - return nil -} +// m.log().WithField("func", "Update").Infof("Users item updated successfully") +// return nil +// } // GetByCond func (m *Users) GetByCond(ctx context.Context, conds ...Cond) (*Users, error) { diff --git a/backend/app/model/users.go b/backend/app/model/users.go index 52f9661..4af0f85 100644 --- a/backend/app/model/users.go +++ b/backend/app/model/users.go @@ -21,6 +21,21 @@ var usersUpdateExcludeColumns = []Column{ table.Users.DeletedAt, } +func (m *Users) Update(ctx context.Context) error { + m.UpdatedAt = time.Now() + + stmt := table.Users.UPDATE(table.Users.MutableColumns.Except(table.Users.OpenID, table.Users.Balance, table.Users.CreatedAt, table.Users.DeletedAt)).SET(m).WHERE(table.Users.ID.EQ(Int(m.ID))).RETURNING(table.Users.AllColumns) + m.log().WithField("func", "Update").Info(stmt.DebugSql()) + + if err := stmt.QueryContext(ctx, db, m); err != nil { + m.log().WithField("func", "Update").Errorf("error updating Users item: %v", err) + return err + } + + m.log().WithField("func", "Update").Infof("Users item updated successfully") + return nil +} + // BuildConditionWithKey builds the WHERE clause for user queries func (m *Users) BuildConditionWithKey(key *string) BoolExpression { tbl := table.Users