From d058b7ffda8ecf36c7adcfdde265ae08c45b05fd Mon Sep 17 00:00:00 2001 From: Rogee Date: Tue, 16 Dec 2025 11:20:40 +0800 Subject: [PATCH] feat add tenant users --- backend/app/http/super/provider.gen.go | 1 - backend/app/requests/pagination.go | 8 +- backend/app/services/provider.gen.go | 15 +- backend/app/services/services.gen.go | 11 +- backend/app/services/tenant.go | 72 +++ backend/app/services/user.go | 50 +- backend/app/services/user_test.go | 106 ++++ backend/database/.transform.yaml | 6 + .../migrations/20251215113803_tenants.sql | 29 + .../20251216011456_tenant_users.sql | 20 + backend/database/models/query.gen.go | 38 +- backend/database/models/tenant_users.gen.go | 63 +++ .../database/models/tenant_users.query.gen.go | 489 +++++++++++++++++ backend/database/models/tenants.gen.go | 63 +++ backend/database/models/tenants.query.gen.go | 495 ++++++++++++++++++ backend/pkg/consts/consts.gen.go | 334 +++++++++++- backend/pkg/consts/consts.go | 12 +- 17 files changed, 1780 insertions(+), 32 deletions(-) create mode 100644 backend/app/services/tenant.go create mode 100644 backend/database/migrations/20251215113803_tenants.sql create mode 100644 backend/database/migrations/20251216011456_tenant_users.sql create mode 100644 backend/database/models/tenant_users.gen.go create mode 100644 backend/database/models/tenant_users.query.gen.go create mode 100644 backend/database/models/tenants.gen.go create mode 100644 backend/database/models/tenants.query.gen.go diff --git a/backend/app/http/super/provider.gen.go b/backend/app/http/super/provider.gen.go index 957d649..258145f 100755 --- a/backend/app/http/super/provider.gen.go +++ b/backend/app/http/super/provider.gen.go @@ -2,7 +2,6 @@ package super import ( "database/sql" - "quyun/v2/providers/app" "go.ipao.vip/atom" diff --git a/backend/app/requests/pagination.go b/backend/app/requests/pagination.go index e98528d..20f1b51 100644 --- a/backend/app/requests/pagination.go +++ b/backend/app/requests/pagination.go @@ -2,14 +2,14 @@ package requests import "github.com/samber/lo" -type Pager struct { - Pagination `json:",inline"` +type Pager[T any] struct { + Pagination ` json:",inline"` Total int64 `json:"total"` - Items any `json:"items"` + Items []T `json:"items"` } type Pagination struct { - Page int64 `json:"page" form:"page" query:"page"` + Page int64 `json:"page" form:"page" query:"page"` Limit int64 `json:"limit" form:"limit" query:"limit"` } diff --git a/backend/app/services/provider.gen.go b/backend/app/services/provider.gen.go index 6744c96..8d4757b 100755 --- a/backend/app/services/provider.gen.go +++ b/backend/app/services/provider.gen.go @@ -11,13 +11,15 @@ import ( func Provide(opts ...opt.Option) error { if err := container.Container.Provide(func( db *gorm.DB, + tenant *tenant, test *test, user *user, ) (contracts.Initial, error) { obj := &services{ - db: db, - test: test, - user: user, + db: db, + tenant: tenant, + test: test, + user: user, } if err := obj.Prepare(); err != nil { return nil, err @@ -27,6 +29,13 @@ func Provide(opts ...opt.Option) error { }, atom.GroupInitial); err != nil { return err } + if err := container.Container.Provide(func() (*tenant, error) { + obj := &tenant{} + + return obj, nil + }); err != nil { + return err + } if err := container.Container.Provide(func() (*test, error) { obj := &test{} diff --git a/backend/app/services/services.gen.go b/backend/app/services/services.gen.go index ffa55df..5b94e29 100644 --- a/backend/app/services/services.gen.go +++ b/backend/app/services/services.gen.go @@ -8,22 +8,25 @@ var _db *gorm.DB // exported CamelCase Services var ( - Test *test - User *user + Tenant *tenant + Test *test + User *user ) // @provider(model) type services struct { db *gorm.DB // define Services - test *test - user *user + tenant *tenant + test *test + user *user } func (svc *services) Prepare() error { _db = svc.db // set exported Services here + Tenant = svc.tenant Test = svc.test User = svc.user diff --git a/backend/app/services/tenant.go b/backend/app/services/tenant.go new file mode 100644 index 0000000..32aa88e --- /dev/null +++ b/backend/app/services/tenant.go @@ -0,0 +1,72 @@ +package services + +import ( + "context" + + "quyun/v2/database/models" + "quyun/v2/pkg/consts" + + "github.com/pkg/errors" +) + +// @provider +type tenant struct{} + +func (t *tenant) ContainsUserID(ctx context.Context, tenantID, userID int64) (*models.User, error) { + tbl, query := models.TenantUserQuery.QueryContext(ctx) + + _, err := query.Where(tbl.TenantID.Eq(tenantID), tbl.UserID.Eq(userID)).First() + if err != nil { + return nil, errors.Wrapf(err, "ContainsUserID failed, tenantID: %d, userID: %d", tenantID, userID) + } + + return User.FindByID(ctx, userID) +} + +// AddUser +func (t *tenant) AddUser(ctx context.Context, tenantID, userID int64) error { + tenantUser := &models.TenantUser{ + TenantID: tenantID, + UserID: userID, + } + + if err := tenantUser.Create(ctx); err != nil { + return errors.Wrapf(err, "AddUser failed, tenantID: %d, userID: %d", tenantID, userID) + } + return nil +} + +// RemoveUser +func (t *tenant) RemoveUser(ctx context.Context, tenantID, userID int64) error { + tbl, query := models.TenantUserQuery.QueryContext(ctx) + tenantUser, err := query.Where(tbl.TenantID.Eq(tenantID), tbl.UserID.Eq(userID)).First() + if err != nil { + return errors.Wrapf(err, "RemoveUser failed to find, tenantID: %d, userID: %d", tenantID, userID) + } + + _, err = tenantUser.Delete(ctx) + if err != nil { + return errors.Wrapf(err, "RemoveUser failed to delete, tenantID: %d, userID: %d", tenantID, userID) + } + return nil +} + +// SetUserRole +func (t *tenant) SetUserRole(ctx context.Context, tenantID, userID int64, role ...consts.TenantUserRole) error { + tbl, query := models.TenantUserQuery.QueryContext(ctx) + tenantUser, err := query.Where(tbl.TenantID.Eq(tenantID), tbl.UserID.Eq(userID)).First() + if err != nil { + return errors.Wrapf(err, "SetUserRole failed to find, tenantID: %d, userID: %d", tenantID, userID) + } + + tenantUser.Role = role + if _, err := tenantUser.Update(ctx); err != nil { + return errors.Wrapf(err, "SetUserRole failed to update, tenantID: %d, userID: %d", tenantID, userID) + } + return nil +} + +// Users +func (t *tenant) Users(ctx context.Context, tenantID int64) ([]*models.User, int64, error) { + return nil, 0, nil +} diff --git a/backend/app/services/user.go b/backend/app/services/user.go index d06d7bc..08517c1 100644 --- a/backend/app/services/user.go +++ b/backend/app/services/user.go @@ -3,20 +3,32 @@ package services import ( "context" + "quyun/v2/app/requests" "quyun/v2/database/models" "github.com/pkg/errors" + "go.ipao.vip/gen" ) // @provider type user struct{} +func (t *user) FindByID(ctx context.Context, userID int64) (*models.User, error) { + tbl, query := models.UserQuery.QueryContext(ctx) + + model, err := query.Where(tbl.ID.Eq(userID)).First() + if err != nil { + return nil, errors.Wrapf(err, "FindByID failed, %d", userID) + } + return model, nil +} + func (t *user) FindByUsername(ctx context.Context, username string) (*models.User, error) { tbl, query := models.UserQuery.QueryContext(ctx) model, err := query.Where(tbl.Username.Eq(username)).First() if err != nil { - return nil, errors.Wrapf(err, "FindByusername failed, %s", username) + return nil, errors.Wrapf(err, "FindByUsername failed, %s", username) } return model, nil } @@ -31,3 +43,39 @@ func (t *user) Create(ctx context.Context, user *models.User) (*models.User, err } return user, nil } + +type UserPageFilter struct { + requests.Pagination + requests.SortQueryFilter + + Username *string `query:"username"` + TenantID *int64 `query:"tenant_id"` +} + +// Page +func (t *user) Page(ctx context.Context, filter *UserPageFilter) (*requests.Pager[*models.User], error) { + tbl, query := models.UserQuery.QueryContext(ctx) + + conds := []gen.Condition{} + if filter.Username != nil { + conds = append(conds, tbl.Username.Like("%"+*filter.Username+"%")) + } + + if filter.TenantID != nil { + tuTbl, _ := models.TenantUserQuery.QueryContext(ctx) + query = query.RightJoin(tuTbl, tuTbl.UserID.EqCol(tbl.ID)) + conds = append(conds, tuTbl.TenantID.Eq(*filter.TenantID)) + } + + filter.Pagination.Format() + items, total, err := query.Where(conds...).Order(tbl.ID.Desc()).FindByPage(int(filter.Offset()), int(filter.Limit)) + if err != nil { + return nil, err + } + + return &requests.Pager[*models.User]{ + Pagination: requests.Pagination{}, + Total: total, + Items: items, + }, nil +} diff --git a/backend/app/services/user_test.go b/backend/app/services/user_test.go index a592999..cedaacb 100644 --- a/backend/app/services/user_test.go +++ b/backend/app/services/user_test.go @@ -2,6 +2,7 @@ package services import ( "database/sql" + "fmt" "testing" "quyun/v2/app/commands/testx" @@ -9,6 +10,7 @@ import ( "quyun/v2/database/models" "quyun/v2/pkg/consts" + "github.com/samber/lo" . "github.com/smartystreets/goconvey/convey" "github.com/stretchr/testify/suite" @@ -94,3 +96,107 @@ func (t *UserTestSuite) Test_FindByUsername() { }) }) } + +// Test_Page +func (t *UserTestSuite) Test_Page() { + FocusConvey("test page", t.T(), func() { + Convey("filter username", func() { + database.Truncate(t.T().Context(), t.DB, models.TableNameUser) + + username := "test-user" + m := &models.User{ + Username: username, + Password: "test-password", + Roles: types.NewArray([]consts.Role{consts.RoleUser}), + Status: consts.UserStatusPendingVerify, + } + + err := m.Create(t.T().Context()) + So(err, ShouldBeNil) + + pager, err := User.Page(t.T().Context(), &UserPageFilter{ + Username: &username, + }) + + So(err, ShouldBeNil) + So(pager.Total, ShouldEqual, 1) + }) + + FocusConvey("filter tenant users", func() { + database.Truncate( + t.T().Context(), + t.DB, + models.TableNameUser, + models.TableNameTenant, + models.TableNameTenantUser, + ) + + username := "test-user" + m := &models.User{ + Username: username, + Password: "test-password", + Roles: types.NewArray([]consts.Role{consts.RoleUser}), + Status: consts.UserStatusPendingVerify, + } + + err := m.Create(t.T().Context()) + So(err, ShouldBeNil) + + m = &models.User{ + Username: username + "02", + Password: "test-password", + Roles: types.NewArray([]consts.Role{consts.RoleUser}), + Status: consts.UserStatusPendingVerify, + } + + err = m.Create(t.T().Context()) + So(err, ShouldBeNil) + + tenantModel := &models.Tenant{ + UserID: 1, + Code: "abc", + UUID: types.NewUUIDv4(), + Name: "T01", + Status: consts.TenantStatusVerified, + } + + err = tenantModel.Create(t.T().Context()) + So(err, ShouldBeNil) + + tenantModel = &models.Tenant{ + UserID: 2, + Code: "abc01", + UUID: types.NewUUIDv4(), + Name: "T02", + Status: consts.TenantStatusVerified, + } + + err = tenantModel.Create(t.T().Context()) + So(err, ShouldBeNil) + + count := 12 + for i := 0; i < count; i++ { + m = &models.User{ + Username: fmt.Sprintf("user_%d", i), + Password: "test-password", + Roles: types.NewArray([]consts.Role{consts.RoleUser}), + Status: consts.UserStatusPendingVerify, + } + + err = m.Create(t.T().Context()) + So(err, ShouldBeNil) + + // create tenant user + err = Tenant.AddUser(t.T().Context(), int64(i%2+1), m.ID) + So(err, ShouldBeNil) + } + + pager, err := User.Page(t.T().Context(), &UserPageFilter{ + TenantID: lo.ToPtr(int64(1)), + }) + + So(err, ShouldBeNil) + So(pager.Total, ShouldEqual, 6) + }) + }) +} diff --git a/backend/database/.transform.yaml b/backend/database/.transform.yaml index 054e0f0..97db49e 100644 --- a/backend/database/.transform.yaml +++ b/backend/database/.transform.yaml @@ -13,4 +13,10 @@ field_type: users: roles: types.Array[consts.Role] status: consts.UserStatus + tenants: + uuid: types.UUID + status: consts.TenantStatus + tenant_users: + role: types.Array[consts.TenantUserRole] + status: consts.UserStatus field_relate: diff --git a/backend/database/migrations/20251215113803_tenants.sql b/backend/database/migrations/20251215113803_tenants.sql new file mode 100644 index 0000000..8039aea --- /dev/null +++ b/backend/database/migrations/20251215113803_tenants.sql @@ -0,0 +1,29 @@ +-- +goose Up +-- +goose StatementBegin +CREATE TABLE IF NOT EXISTS tenants( + id bigserial PRIMARY KEY, + user_id bigint NOT NULL, + code varchar(64) NOT NULL, + uuid uuid NOT NULL, + name varchar(128) NOT NULL DEFAULT '', + status varchar(64) NOT NULL DEFAULT '', + config jsonb NOT NULL DEFAULT '{}'::jsonb, + expired_at timestamptz, + created_at timestamptz NOT NULL DEFAULT now(), + updated_at timestamptz NOT NULL DEFAULT now() +); + +CREATE UNIQUE INDEX IF NOT EXISTS ux_tenants_code_lower ON tenants(lower(code)); + +CREATE UNIQUE INDEX IF NOT EXISTS ux_tenants_uuid ON tenants(uuid); + +-- +goose StatementEnd +-- +goose Down +-- +goose StatementBegin +DROP INDEX IF EXISTS ux_tenants_uuid; + +DROP INDEX IF EXISTS ux_tenants_code_lower; + +DROP TABLE IF EXISTS tenants; + +-- +goose StatementEnd diff --git a/backend/database/migrations/20251216011456_tenant_users.sql b/backend/database/migrations/20251216011456_tenant_users.sql new file mode 100644 index 0000000..fabf7d6 --- /dev/null +++ b/backend/database/migrations/20251216011456_tenant_users.sql @@ -0,0 +1,20 @@ +-- +goose Up +-- +goose StatementBegin +CREATE TABLE IF NOT EXISTS tenant_users( + id bigserial PRIMARY KEY, + tenant_id bigint NOT NULL, + user_id bigint NOT NULL, + role TEXT[] NOT NULL DEFAULT ARRAY['member'], + balance numeric(20, 8) NOT NULL DEFAULT 0, + status varchar(50) NOT NULL DEFAULT 'active', + created_at timestamptz NOT NULL DEFAULT NOW(), + updated_at timestamptz NOT NULL DEFAULT NOW(), + UNIQUE (tenant_id, user_id) +); + +-- +goose StatementEnd +-- +goose Down +-- +goose StatementBegin +DROP TABLE IF EXISTS tenant_users; + +-- +goose StatementEnd diff --git a/backend/database/models/query.gen.go b/backend/database/models/query.gen.go index 8fcceb0..3f687b0 100644 --- a/backend/database/models/query.gen.go +++ b/backend/database/models/query.gen.go @@ -16,34 +16,44 @@ import ( ) var ( - Q = new(Query) - UserQuery *userQuery + Q = new(Query) + TenantQuery *tenantQuery + TenantUserQuery *tenantUserQuery + UserQuery *userQuery ) func SetDefault(db *gorm.DB, opts ...gen.DOOption) { *Q = *Use(db, opts...) + TenantQuery = &Q.Tenant + TenantUserQuery = &Q.TenantUser UserQuery = &Q.User } func Use(db *gorm.DB, opts ...gen.DOOption) *Query { return &Query{ - db: db, - User: newUser(db, opts...), + db: db, + Tenant: newTenant(db, opts...), + TenantUser: newTenantUser(db, opts...), + User: newUser(db, opts...), } } type Query struct { db *gorm.DB - User userQuery + Tenant tenantQuery + TenantUser tenantUserQuery + User userQuery } func (q *Query) Available() bool { return q.db != nil } func (q *Query) clone(db *gorm.DB) *Query { return &Query{ - db: db, - User: q.User.clone(db), + db: db, + Tenant: q.Tenant.clone(db), + TenantUser: q.TenantUser.clone(db), + User: q.User.clone(db), } } @@ -57,18 +67,24 @@ func (q *Query) WriteDB() *Query { func (q *Query) ReplaceDB(db *gorm.DB) *Query { return &Query{ - db: db, - User: q.User.replaceDB(db), + db: db, + Tenant: q.Tenant.replaceDB(db), + TenantUser: q.TenantUser.replaceDB(db), + User: q.User.replaceDB(db), } } type queryCtx struct { - User *userQueryDo + Tenant *tenantQueryDo + TenantUser *tenantUserQueryDo + User *userQueryDo } func (q *Query) WithContext(ctx context.Context) *queryCtx { return &queryCtx{ - User: q.User.WithContext(ctx), + Tenant: q.Tenant.WithContext(ctx), + TenantUser: q.TenantUser.WithContext(ctx), + User: q.User.WithContext(ctx), } } diff --git a/backend/database/models/tenant_users.gen.go b/backend/database/models/tenant_users.gen.go new file mode 100644 index 0000000..b702eeb --- /dev/null +++ b/backend/database/models/tenant_users.gen.go @@ -0,0 +1,63 @@ +// Code generated by go.ipao.vip/gen. DO NOT EDIT. +// Code generated by go.ipao.vip/gen. DO NOT EDIT. +// Code generated by go.ipao.vip/gen. DO NOT EDIT. + +package models + +import ( + "context" + "time" + + "quyun/v2/pkg/consts" + + "go.ipao.vip/gen" + "go.ipao.vip/gen/types" +) + +const TableNameTenantUser = "tenant_users" + +// TenantUser mapped from table +type TenantUser struct { + ID int64 `gorm:"column:id;type:bigint;primaryKey;autoIncrement:true" json:"id"` + TenantID int64 `gorm:"column:tenant_id;type:bigint;not null" json:"tenant_id"` + UserID int64 `gorm:"column:user_id;type:bigint;not null" json:"user_id"` + Role types.Array[consts.TenantUserRole] `gorm:"column:role;type:text[];not null;default:ARRAY['member" json:"role"` + Balance float64 `gorm:"column:balance;type:numeric(20,8);not null" json:"balance"` + Status consts.UserStatus `gorm:"column:status;type:character varying(50);not null;default:active" json:"status"` + CreatedAt time.Time `gorm:"column:created_at;type:timestamp with time zone;not null;default:now()" json:"created_at"` + UpdatedAt time.Time `gorm:"column:updated_at;type:timestamp with time zone;not null;default:now()" json:"updated_at"` +} + +// Quick operations without importing query package +// Update applies changed fields to the database using the default DB. +func (m *TenantUser) Update(ctx context.Context) (gen.ResultInfo, error) { + return Q.TenantUser.WithContext(ctx).Updates(m) +} + +// Save upserts the model using the default DB. +func (m *TenantUser) Save(ctx context.Context) error { return Q.TenantUser.WithContext(ctx).Save(m) } + +// Create inserts the model using the default DB. +func (m *TenantUser) Create(ctx context.Context) error { + return Q.TenantUser.WithContext(ctx).Create(m) +} + +// Delete removes the row represented by the model using the default DB. +func (m *TenantUser) Delete(ctx context.Context) (gen.ResultInfo, error) { + return Q.TenantUser.WithContext(ctx).Delete(m) +} + +// ForceDelete permanently deletes the row (ignores soft delete) using the default DB. +func (m *TenantUser) ForceDelete(ctx context.Context) (gen.ResultInfo, error) { + return Q.TenantUser.WithContext(ctx).Unscoped().Delete(m) +} + +// Reload reloads the model from database by its primary key and overwrites current fields. +func (m *TenantUser) Reload(ctx context.Context) error { + fresh, err := Q.TenantUser.WithContext(ctx).GetByID(m.ID) + if err != nil { + return err + } + *m = *fresh + return nil +} diff --git a/backend/database/models/tenant_users.query.gen.go b/backend/database/models/tenant_users.query.gen.go new file mode 100644 index 0000000..3ed4202 --- /dev/null +++ b/backend/database/models/tenant_users.query.gen.go @@ -0,0 +1,489 @@ +// Code generated by go.ipao.vip/gen. DO NOT EDIT. +// Code generated by go.ipao.vip/gen. DO NOT EDIT. +// Code generated by go.ipao.vip/gen. DO NOT EDIT. + +package models + +import ( + "context" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "go.ipao.vip/gen" + "go.ipao.vip/gen/field" + + "gorm.io/plugin/dbresolver" +) + +func newTenantUser(db *gorm.DB, opts ...gen.DOOption) tenantUserQuery { + _tenantUserQuery := tenantUserQuery{} + + _tenantUserQuery.tenantUserQueryDo.UseDB(db, opts...) + _tenantUserQuery.tenantUserQueryDo.UseModel(&TenantUser{}) + + tableName := _tenantUserQuery.tenantUserQueryDo.TableName() + _tenantUserQuery.ALL = field.NewAsterisk(tableName) + _tenantUserQuery.ID = field.NewInt64(tableName, "id") + _tenantUserQuery.TenantID = field.NewInt64(tableName, "tenant_id") + _tenantUserQuery.UserID = field.NewInt64(tableName, "user_id") + _tenantUserQuery.Role = field.NewArray(tableName, "role") + _tenantUserQuery.Balance = field.NewFloat64(tableName, "balance") + _tenantUserQuery.Status = field.NewField(tableName, "status") + _tenantUserQuery.CreatedAt = field.NewTime(tableName, "created_at") + _tenantUserQuery.UpdatedAt = field.NewTime(tableName, "updated_at") + + _tenantUserQuery.fillFieldMap() + + return _tenantUserQuery +} + +type tenantUserQuery struct { + tenantUserQueryDo tenantUserQueryDo + + ALL field.Asterisk + ID field.Int64 + TenantID field.Int64 + UserID field.Int64 + Role field.Array + Balance field.Float64 + Status field.Field + CreatedAt field.Time + UpdatedAt field.Time + + fieldMap map[string]field.Expr +} + +func (t tenantUserQuery) Table(newTableName string) *tenantUserQuery { + t.tenantUserQueryDo.UseTable(newTableName) + return t.updateTableName(newTableName) +} + +func (t tenantUserQuery) As(alias string) *tenantUserQuery { + t.tenantUserQueryDo.DO = *(t.tenantUserQueryDo.As(alias).(*gen.DO)) + return t.updateTableName(alias) +} + +func (t *tenantUserQuery) updateTableName(table string) *tenantUserQuery { + t.ALL = field.NewAsterisk(table) + t.ID = field.NewInt64(table, "id") + t.TenantID = field.NewInt64(table, "tenant_id") + t.UserID = field.NewInt64(table, "user_id") + t.Role = field.NewArray(table, "role") + t.Balance = field.NewFloat64(table, "balance") + t.Status = field.NewField(table, "status") + t.CreatedAt = field.NewTime(table, "created_at") + t.UpdatedAt = field.NewTime(table, "updated_at") + + t.fillFieldMap() + + return t +} + +func (t *tenantUserQuery) QueryContext(ctx context.Context) (*tenantUserQuery, *tenantUserQueryDo) { + return t, t.tenantUserQueryDo.WithContext(ctx) +} + +func (t *tenantUserQuery) WithContext(ctx context.Context) *tenantUserQueryDo { + return t.tenantUserQueryDo.WithContext(ctx) +} + +func (t tenantUserQuery) TableName() string { return t.tenantUserQueryDo.TableName() } + +func (t tenantUserQuery) Alias() string { return t.tenantUserQueryDo.Alias() } + +func (t tenantUserQuery) Columns(cols ...field.Expr) gen.Columns { + return t.tenantUserQueryDo.Columns(cols...) +} + +func (t *tenantUserQuery) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := t.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (t *tenantUserQuery) fillFieldMap() { + t.fieldMap = make(map[string]field.Expr, 8) + t.fieldMap["id"] = t.ID + t.fieldMap["tenant_id"] = t.TenantID + t.fieldMap["user_id"] = t.UserID + t.fieldMap["role"] = t.Role + t.fieldMap["balance"] = t.Balance + t.fieldMap["status"] = t.Status + t.fieldMap["created_at"] = t.CreatedAt + t.fieldMap["updated_at"] = t.UpdatedAt +} + +func (t tenantUserQuery) clone(db *gorm.DB) tenantUserQuery { + t.tenantUserQueryDo.ReplaceConnPool(db.Statement.ConnPool) + return t +} + +func (t tenantUserQuery) replaceDB(db *gorm.DB) tenantUserQuery { + t.tenantUserQueryDo.ReplaceDB(db) + return t +} + +type tenantUserQueryDo struct{ gen.DO } + +func (t tenantUserQueryDo) Debug() *tenantUserQueryDo { + return t.withDO(t.DO.Debug()) +} + +func (t tenantUserQueryDo) WithContext(ctx context.Context) *tenantUserQueryDo { + return t.withDO(t.DO.WithContext(ctx)) +} + +func (t tenantUserQueryDo) ReadDB() *tenantUserQueryDo { + return t.Clauses(dbresolver.Read) +} + +func (t tenantUserQueryDo) WriteDB() *tenantUserQueryDo { + return t.Clauses(dbresolver.Write) +} + +func (t tenantUserQueryDo) Session(config *gorm.Session) *tenantUserQueryDo { + return t.withDO(t.DO.Session(config)) +} + +func (t tenantUserQueryDo) Clauses(conds ...clause.Expression) *tenantUserQueryDo { + return t.withDO(t.DO.Clauses(conds...)) +} + +func (t tenantUserQueryDo) Returning(value interface{}, columns ...string) *tenantUserQueryDo { + return t.withDO(t.DO.Returning(value, columns...)) +} + +func (t tenantUserQueryDo) Not(conds ...gen.Condition) *tenantUserQueryDo { + return t.withDO(t.DO.Not(conds...)) +} + +func (t tenantUserQueryDo) Or(conds ...gen.Condition) *tenantUserQueryDo { + return t.withDO(t.DO.Or(conds...)) +} + +func (t tenantUserQueryDo) Select(conds ...field.Expr) *tenantUserQueryDo { + return t.withDO(t.DO.Select(conds...)) +} + +func (t tenantUserQueryDo) Where(conds ...gen.Condition) *tenantUserQueryDo { + return t.withDO(t.DO.Where(conds...)) +} + +func (t tenantUserQueryDo) Order(conds ...field.Expr) *tenantUserQueryDo { + return t.withDO(t.DO.Order(conds...)) +} + +func (t tenantUserQueryDo) Distinct(cols ...field.Expr) *tenantUserQueryDo { + return t.withDO(t.DO.Distinct(cols...)) +} + +func (t tenantUserQueryDo) Omit(cols ...field.Expr) *tenantUserQueryDo { + return t.withDO(t.DO.Omit(cols...)) +} + +func (t tenantUserQueryDo) Join(table schema.Tabler, on ...field.Expr) *tenantUserQueryDo { + return t.withDO(t.DO.Join(table, on...)) +} + +func (t tenantUserQueryDo) LeftJoin(table schema.Tabler, on ...field.Expr) *tenantUserQueryDo { + return t.withDO(t.DO.LeftJoin(table, on...)) +} + +func (t tenantUserQueryDo) RightJoin(table schema.Tabler, on ...field.Expr) *tenantUserQueryDo { + return t.withDO(t.DO.RightJoin(table, on...)) +} + +func (t tenantUserQueryDo) Group(cols ...field.Expr) *tenantUserQueryDo { + return t.withDO(t.DO.Group(cols...)) +} + +func (t tenantUserQueryDo) Having(conds ...gen.Condition) *tenantUserQueryDo { + return t.withDO(t.DO.Having(conds...)) +} + +func (t tenantUserQueryDo) Limit(limit int) *tenantUserQueryDo { + return t.withDO(t.DO.Limit(limit)) +} + +func (t tenantUserQueryDo) Offset(offset int) *tenantUserQueryDo { + return t.withDO(t.DO.Offset(offset)) +} + +func (t tenantUserQueryDo) Scopes(funcs ...func(gen.Dao) gen.Dao) *tenantUserQueryDo { + return t.withDO(t.DO.Scopes(funcs...)) +} + +func (t tenantUserQueryDo) Unscoped() *tenantUserQueryDo { + return t.withDO(t.DO.Unscoped()) +} + +func (t tenantUserQueryDo) Create(values ...*TenantUser) error { + if len(values) == 0 { + return nil + } + return t.DO.Create(values) +} + +func (t tenantUserQueryDo) CreateInBatches(values []*TenantUser, batchSize int) error { + return t.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (t tenantUserQueryDo) Save(values ...*TenantUser) error { + if len(values) == 0 { + return nil + } + return t.DO.Save(values) +} + +func (t tenantUserQueryDo) First() (*TenantUser, error) { + if result, err := t.DO.First(); err != nil { + return nil, err + } else { + return result.(*TenantUser), nil + } +} + +func (t tenantUserQueryDo) Take() (*TenantUser, error) { + if result, err := t.DO.Take(); err != nil { + return nil, err + } else { + return result.(*TenantUser), nil + } +} + +func (t tenantUserQueryDo) Last() (*TenantUser, error) { + if result, err := t.DO.Last(); err != nil { + return nil, err + } else { + return result.(*TenantUser), nil + } +} + +func (t tenantUserQueryDo) Find() ([]*TenantUser, error) { + result, err := t.DO.Find() + return result.([]*TenantUser), err +} + +func (t tenantUserQueryDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*TenantUser, err error) { + buf := make([]*TenantUser, 0, batchSize) + err = t.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (t tenantUserQueryDo) FindInBatches(result *[]*TenantUser, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return t.DO.FindInBatches(result, batchSize, fc) +} + +func (t tenantUserQueryDo) Attrs(attrs ...field.AssignExpr) *tenantUserQueryDo { + return t.withDO(t.DO.Attrs(attrs...)) +} + +func (t tenantUserQueryDo) Assign(attrs ...field.AssignExpr) *tenantUserQueryDo { + return t.withDO(t.DO.Assign(attrs...)) +} + +func (t tenantUserQueryDo) Joins(fields ...field.RelationField) *tenantUserQueryDo { + for _, _f := range fields { + t = *t.withDO(t.DO.Joins(_f)) + } + return &t +} + +func (t tenantUserQueryDo) Preload(fields ...field.RelationField) *tenantUserQueryDo { + for _, _f := range fields { + t = *t.withDO(t.DO.Preload(_f)) + } + return &t +} + +func (t tenantUserQueryDo) FirstOrInit() (*TenantUser, error) { + if result, err := t.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*TenantUser), nil + } +} + +func (t tenantUserQueryDo) FirstOrCreate() (*TenantUser, error) { + if result, err := t.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*TenantUser), nil + } +} + +func (t tenantUserQueryDo) FindByPage(offset int, limit int) (result []*TenantUser, count int64, err error) { + result, err = t.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = t.Offset(-1).Limit(-1).Count() + return +} + +func (t tenantUserQueryDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = t.Count() + if err != nil { + return + } + + err = t.Offset(offset).Limit(limit).Scan(result) + return +} + +func (t tenantUserQueryDo) Scan(result interface{}) (err error) { + return t.DO.Scan(result) +} + +func (t tenantUserQueryDo) Delete(models ...*TenantUser) (result gen.ResultInfo, err error) { + return t.DO.Delete(models) +} + +// ForceDelete performs a permanent delete (ignores soft-delete) for current scope. +func (t tenantUserQueryDo) ForceDelete() (gen.ResultInfo, error) { + return t.Unscoped().Delete() +} + +// Inc increases the given column by step for current scope. +func (t tenantUserQueryDo) Inc(column field.Expr, step int64) (gen.ResultInfo, error) { + // column = column + step + e := field.NewUnsafeFieldRaw("?+?", column.RawExpr(), step) + return t.DO.UpdateColumn(column, e) +} + +// Dec decreases the given column by step for current scope. +func (t tenantUserQueryDo) Dec(column field.Expr, step int64) (gen.ResultInfo, error) { + // column = column - step + e := field.NewUnsafeFieldRaw("?-?", column.RawExpr(), step) + return t.DO.UpdateColumn(column, e) +} + +// Sum returns SUM(column) for current scope. +func (t tenantUserQueryDo) Sum(column field.Expr) (float64, error) { + var _v float64 + agg := field.NewUnsafeFieldRaw("SUM(?)", column.RawExpr()) + if err := t.Select(agg).Scan(&_v); err != nil { + return 0, err + } + return _v, nil +} + +// Avg returns AVG(column) for current scope. +func (t tenantUserQueryDo) Avg(column field.Expr) (float64, error) { + var _v float64 + agg := field.NewUnsafeFieldRaw("AVG(?)", column.RawExpr()) + if err := t.Select(agg).Scan(&_v); err != nil { + return 0, err + } + return _v, nil +} + +// Min returns MIN(column) for current scope. +func (t tenantUserQueryDo) Min(column field.Expr) (float64, error) { + var _v float64 + agg := field.NewUnsafeFieldRaw("MIN(?)", column.RawExpr()) + if err := t.Select(agg).Scan(&_v); err != nil { + return 0, err + } + return _v, nil +} + +// Max returns MAX(column) for current scope. +func (t tenantUserQueryDo) Max(column field.Expr) (float64, error) { + var _v float64 + agg := field.NewUnsafeFieldRaw("MAX(?)", column.RawExpr()) + if err := t.Select(agg).Scan(&_v); err != nil { + return 0, err + } + return _v, nil +} + +// PluckMap returns a map[key]value for selected key/value expressions within current scope. +func (t tenantUserQueryDo) PluckMap(key, val field.Expr) (map[interface{}]interface{}, error) { + do := t.Select(key, val) + rows, err := do.DO.Rows() + if err != nil { + return nil, err + } + defer rows.Close() + mm := make(map[interface{}]interface{}) + for rows.Next() { + var k interface{} + var v interface{} + if err := rows.Scan(&k, &v); err != nil { + return nil, err + } + mm[k] = v + } + return mm, rows.Err() +} + +// Exists returns true if any record matches the given conditions. +func (t tenantUserQueryDo) Exists(conds ...gen.Condition) (bool, error) { + cnt, err := t.Where(conds...).Count() + if err != nil { + return false, err + } + return cnt > 0, nil +} + +// PluckIDs returns all primary key values under current scope. +func (t tenantUserQueryDo) PluckIDs() ([]int64, error) { + ids := make([]int64, 0, 16) + pk := field.NewInt64(t.TableName(), "id") + if err := t.DO.Pluck(pk, &ids); err != nil { + return nil, err + } + return ids, nil +} + +// GetByID finds a single record by primary key. +func (t tenantUserQueryDo) GetByID(id int64) (*TenantUser, error) { + pk := field.NewInt64(t.TableName(), "id") + return t.Where(pk.Eq(id)).First() +} + +// GetByIDs finds records by primary key list. +func (t tenantUserQueryDo) GetByIDs(ids ...int64) ([]*TenantUser, error) { + if len(ids) == 0 { + return []*TenantUser{}, nil + } + pk := field.NewInt64(t.TableName(), "id") + return t.Where(pk.In(ids...)).Find() +} + +// DeleteByID deletes records by primary key. +func (t tenantUserQueryDo) DeleteByID(id int64) (gen.ResultInfo, error) { + pk := field.NewInt64(t.TableName(), "id") + return t.Where(pk.Eq(id)).Delete() +} + +// DeleteByIDs deletes records by a list of primary keys. +func (t tenantUserQueryDo) DeleteByIDs(ids ...int64) (gen.ResultInfo, error) { + if len(ids) == 0 { + return gen.ResultInfo{RowsAffected: 0, Error: nil}, nil + } + pk := field.NewInt64(t.TableName(), "id") + return t.Where(pk.In(ids...)).Delete() +} + +func (t *tenantUserQueryDo) withDO(do gen.Dao) *tenantUserQueryDo { + t.DO = *do.(*gen.DO) + return t +} diff --git a/backend/database/models/tenants.gen.go b/backend/database/models/tenants.gen.go new file mode 100644 index 0000000..329451b --- /dev/null +++ b/backend/database/models/tenants.gen.go @@ -0,0 +1,63 @@ +// Code generated by go.ipao.vip/gen. DO NOT EDIT. +// Code generated by go.ipao.vip/gen. DO NOT EDIT. +// Code generated by go.ipao.vip/gen. DO NOT EDIT. + +package models + +import ( + "context" + "time" + + "quyun/v2/pkg/consts" + + "go.ipao.vip/gen" + "go.ipao.vip/gen/types" +) + +const TableNameTenant = "tenants" + +// Tenant mapped from table +type Tenant struct { + ID int64 `gorm:"column:id;type:bigint;primaryKey;autoIncrement:true" json:"id"` + UserID int64 `gorm:"column:user_id;type:bigint;not null" json:"user_id"` + Code string `gorm:"column:code;type:character varying(64);not null" json:"code"` + UUID types.UUID `gorm:"column:uuid;type:uuid;not null" json:"uuid"` + Name string `gorm:"column:name;type:character varying(128);not null" json:"name"` + Status consts.TenantStatus `gorm:"column:status;type:character varying(64);not null" json:"status"` + Config types.JSON `gorm:"column:config;type:jsonb;not null;default:{}" json:"config"` + ExpiredAt time.Time `gorm:"column:expired_at;type:timestamp with time zone" json:"expired_at"` + CreatedAt time.Time `gorm:"column:created_at;type:timestamp with time zone;not null;default:now()" json:"created_at"` + UpdatedAt time.Time `gorm:"column:updated_at;type:timestamp with time zone;not null;default:now()" json:"updated_at"` +} + +// Quick operations without importing query package +// Update applies changed fields to the database using the default DB. +func (m *Tenant) Update(ctx context.Context) (gen.ResultInfo, error) { + return Q.Tenant.WithContext(ctx).Updates(m) +} + +// Save upserts the model using the default DB. +func (m *Tenant) Save(ctx context.Context) error { return Q.Tenant.WithContext(ctx).Save(m) } + +// Create inserts the model using the default DB. +func (m *Tenant) Create(ctx context.Context) error { return Q.Tenant.WithContext(ctx).Create(m) } + +// Delete removes the row represented by the model using the default DB. +func (m *Tenant) Delete(ctx context.Context) (gen.ResultInfo, error) { + return Q.Tenant.WithContext(ctx).Delete(m) +} + +// ForceDelete permanently deletes the row (ignores soft delete) using the default DB. +func (m *Tenant) ForceDelete(ctx context.Context) (gen.ResultInfo, error) { + return Q.Tenant.WithContext(ctx).Unscoped().Delete(m) +} + +// Reload reloads the model from database by its primary key and overwrites current fields. +func (m *Tenant) Reload(ctx context.Context) error { + fresh, err := Q.Tenant.WithContext(ctx).GetByID(m.ID) + if err != nil { + return err + } + *m = *fresh + return nil +} diff --git a/backend/database/models/tenants.query.gen.go b/backend/database/models/tenants.query.gen.go new file mode 100644 index 0000000..7393e6a --- /dev/null +++ b/backend/database/models/tenants.query.gen.go @@ -0,0 +1,495 @@ +// Code generated by go.ipao.vip/gen. DO NOT EDIT. +// Code generated by go.ipao.vip/gen. DO NOT EDIT. +// Code generated by go.ipao.vip/gen. DO NOT EDIT. + +package models + +import ( + "context" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "go.ipao.vip/gen" + "go.ipao.vip/gen/field" + + "gorm.io/plugin/dbresolver" +) + +func newTenant(db *gorm.DB, opts ...gen.DOOption) tenantQuery { + _tenantQuery := tenantQuery{} + + _tenantQuery.tenantQueryDo.UseDB(db, opts...) + _tenantQuery.tenantQueryDo.UseModel(&Tenant{}) + + tableName := _tenantQuery.tenantQueryDo.TableName() + _tenantQuery.ALL = field.NewAsterisk(tableName) + _tenantQuery.ID = field.NewInt64(tableName, "id") + _tenantQuery.UserID = field.NewInt64(tableName, "user_id") + _tenantQuery.Code = field.NewString(tableName, "code") + _tenantQuery.UUID = field.NewField(tableName, "uuid") + _tenantQuery.Name = field.NewString(tableName, "name") + _tenantQuery.Status = field.NewField(tableName, "status") + _tenantQuery.Config = field.NewJSONB(tableName, "config") + _tenantQuery.ExpiredAt = field.NewTime(tableName, "expired_at") + _tenantQuery.CreatedAt = field.NewTime(tableName, "created_at") + _tenantQuery.UpdatedAt = field.NewTime(tableName, "updated_at") + + _tenantQuery.fillFieldMap() + + return _tenantQuery +} + +type tenantQuery struct { + tenantQueryDo tenantQueryDo + + ALL field.Asterisk + ID field.Int64 + UserID field.Int64 + Code field.String + UUID field.Field + Name field.String + Status field.Field + Config field.JSONB + ExpiredAt field.Time + CreatedAt field.Time + UpdatedAt field.Time + + fieldMap map[string]field.Expr +} + +func (t tenantQuery) Table(newTableName string) *tenantQuery { + t.tenantQueryDo.UseTable(newTableName) + return t.updateTableName(newTableName) +} + +func (t tenantQuery) As(alias string) *tenantQuery { + t.tenantQueryDo.DO = *(t.tenantQueryDo.As(alias).(*gen.DO)) + return t.updateTableName(alias) +} + +func (t *tenantQuery) updateTableName(table string) *tenantQuery { + t.ALL = field.NewAsterisk(table) + t.ID = field.NewInt64(table, "id") + t.UserID = field.NewInt64(table, "user_id") + t.Code = field.NewString(table, "code") + t.UUID = field.NewField(table, "uuid") + t.Name = field.NewString(table, "name") + t.Status = field.NewField(table, "status") + t.Config = field.NewJSONB(table, "config") + t.ExpiredAt = field.NewTime(table, "expired_at") + t.CreatedAt = field.NewTime(table, "created_at") + t.UpdatedAt = field.NewTime(table, "updated_at") + + t.fillFieldMap() + + return t +} + +func (t *tenantQuery) QueryContext(ctx context.Context) (*tenantQuery, *tenantQueryDo) { + return t, t.tenantQueryDo.WithContext(ctx) +} + +func (t *tenantQuery) WithContext(ctx context.Context) *tenantQueryDo { + return t.tenantQueryDo.WithContext(ctx) +} + +func (t tenantQuery) TableName() string { return t.tenantQueryDo.TableName() } + +func (t tenantQuery) Alias() string { return t.tenantQueryDo.Alias() } + +func (t tenantQuery) Columns(cols ...field.Expr) gen.Columns { return t.tenantQueryDo.Columns(cols...) } + +func (t *tenantQuery) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := t.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (t *tenantQuery) fillFieldMap() { + t.fieldMap = make(map[string]field.Expr, 10) + t.fieldMap["id"] = t.ID + t.fieldMap["user_id"] = t.UserID + t.fieldMap["code"] = t.Code + t.fieldMap["uuid"] = t.UUID + t.fieldMap["name"] = t.Name + t.fieldMap["status"] = t.Status + t.fieldMap["config"] = t.Config + t.fieldMap["expired_at"] = t.ExpiredAt + t.fieldMap["created_at"] = t.CreatedAt + t.fieldMap["updated_at"] = t.UpdatedAt +} + +func (t tenantQuery) clone(db *gorm.DB) tenantQuery { + t.tenantQueryDo.ReplaceConnPool(db.Statement.ConnPool) + return t +} + +func (t tenantQuery) replaceDB(db *gorm.DB) tenantQuery { + t.tenantQueryDo.ReplaceDB(db) + return t +} + +type tenantQueryDo struct{ gen.DO } + +func (t tenantQueryDo) Debug() *tenantQueryDo { + return t.withDO(t.DO.Debug()) +} + +func (t tenantQueryDo) WithContext(ctx context.Context) *tenantQueryDo { + return t.withDO(t.DO.WithContext(ctx)) +} + +func (t tenantQueryDo) ReadDB() *tenantQueryDo { + return t.Clauses(dbresolver.Read) +} + +func (t tenantQueryDo) WriteDB() *tenantQueryDo { + return t.Clauses(dbresolver.Write) +} + +func (t tenantQueryDo) Session(config *gorm.Session) *tenantQueryDo { + return t.withDO(t.DO.Session(config)) +} + +func (t tenantQueryDo) Clauses(conds ...clause.Expression) *tenantQueryDo { + return t.withDO(t.DO.Clauses(conds...)) +} + +func (t tenantQueryDo) Returning(value interface{}, columns ...string) *tenantQueryDo { + return t.withDO(t.DO.Returning(value, columns...)) +} + +func (t tenantQueryDo) Not(conds ...gen.Condition) *tenantQueryDo { + return t.withDO(t.DO.Not(conds...)) +} + +func (t tenantQueryDo) Or(conds ...gen.Condition) *tenantQueryDo { + return t.withDO(t.DO.Or(conds...)) +} + +func (t tenantQueryDo) Select(conds ...field.Expr) *tenantQueryDo { + return t.withDO(t.DO.Select(conds...)) +} + +func (t tenantQueryDo) Where(conds ...gen.Condition) *tenantQueryDo { + return t.withDO(t.DO.Where(conds...)) +} + +func (t tenantQueryDo) Order(conds ...field.Expr) *tenantQueryDo { + return t.withDO(t.DO.Order(conds...)) +} + +func (t tenantQueryDo) Distinct(cols ...field.Expr) *tenantQueryDo { + return t.withDO(t.DO.Distinct(cols...)) +} + +func (t tenantQueryDo) Omit(cols ...field.Expr) *tenantQueryDo { + return t.withDO(t.DO.Omit(cols...)) +} + +func (t tenantQueryDo) Join(table schema.Tabler, on ...field.Expr) *tenantQueryDo { + return t.withDO(t.DO.Join(table, on...)) +} + +func (t tenantQueryDo) LeftJoin(table schema.Tabler, on ...field.Expr) *tenantQueryDo { + return t.withDO(t.DO.LeftJoin(table, on...)) +} + +func (t tenantQueryDo) RightJoin(table schema.Tabler, on ...field.Expr) *tenantQueryDo { + return t.withDO(t.DO.RightJoin(table, on...)) +} + +func (t tenantQueryDo) Group(cols ...field.Expr) *tenantQueryDo { + return t.withDO(t.DO.Group(cols...)) +} + +func (t tenantQueryDo) Having(conds ...gen.Condition) *tenantQueryDo { + return t.withDO(t.DO.Having(conds...)) +} + +func (t tenantQueryDo) Limit(limit int) *tenantQueryDo { + return t.withDO(t.DO.Limit(limit)) +} + +func (t tenantQueryDo) Offset(offset int) *tenantQueryDo { + return t.withDO(t.DO.Offset(offset)) +} + +func (t tenantQueryDo) Scopes(funcs ...func(gen.Dao) gen.Dao) *tenantQueryDo { + return t.withDO(t.DO.Scopes(funcs...)) +} + +func (t tenantQueryDo) Unscoped() *tenantQueryDo { + return t.withDO(t.DO.Unscoped()) +} + +func (t tenantQueryDo) Create(values ...*Tenant) error { + if len(values) == 0 { + return nil + } + return t.DO.Create(values) +} + +func (t tenantQueryDo) CreateInBatches(values []*Tenant, batchSize int) error { + return t.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (t tenantQueryDo) Save(values ...*Tenant) error { + if len(values) == 0 { + return nil + } + return t.DO.Save(values) +} + +func (t tenantQueryDo) First() (*Tenant, error) { + if result, err := t.DO.First(); err != nil { + return nil, err + } else { + return result.(*Tenant), nil + } +} + +func (t tenantQueryDo) Take() (*Tenant, error) { + if result, err := t.DO.Take(); err != nil { + return nil, err + } else { + return result.(*Tenant), nil + } +} + +func (t tenantQueryDo) Last() (*Tenant, error) { + if result, err := t.DO.Last(); err != nil { + return nil, err + } else { + return result.(*Tenant), nil + } +} + +func (t tenantQueryDo) Find() ([]*Tenant, error) { + result, err := t.DO.Find() + return result.([]*Tenant), err +} + +func (t tenantQueryDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*Tenant, err error) { + buf := make([]*Tenant, 0, batchSize) + err = t.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (t tenantQueryDo) FindInBatches(result *[]*Tenant, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return t.DO.FindInBatches(result, batchSize, fc) +} + +func (t tenantQueryDo) Attrs(attrs ...field.AssignExpr) *tenantQueryDo { + return t.withDO(t.DO.Attrs(attrs...)) +} + +func (t tenantQueryDo) Assign(attrs ...field.AssignExpr) *tenantQueryDo { + return t.withDO(t.DO.Assign(attrs...)) +} + +func (t tenantQueryDo) Joins(fields ...field.RelationField) *tenantQueryDo { + for _, _f := range fields { + t = *t.withDO(t.DO.Joins(_f)) + } + return &t +} + +func (t tenantQueryDo) Preload(fields ...field.RelationField) *tenantQueryDo { + for _, _f := range fields { + t = *t.withDO(t.DO.Preload(_f)) + } + return &t +} + +func (t tenantQueryDo) FirstOrInit() (*Tenant, error) { + if result, err := t.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*Tenant), nil + } +} + +func (t tenantQueryDo) FirstOrCreate() (*Tenant, error) { + if result, err := t.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*Tenant), nil + } +} + +func (t tenantQueryDo) FindByPage(offset int, limit int) (result []*Tenant, count int64, err error) { + result, err = t.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = t.Offset(-1).Limit(-1).Count() + return +} + +func (t tenantQueryDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = t.Count() + if err != nil { + return + } + + err = t.Offset(offset).Limit(limit).Scan(result) + return +} + +func (t tenantQueryDo) Scan(result interface{}) (err error) { + return t.DO.Scan(result) +} + +func (t tenantQueryDo) Delete(models ...*Tenant) (result gen.ResultInfo, err error) { + return t.DO.Delete(models) +} + +// ForceDelete performs a permanent delete (ignores soft-delete) for current scope. +func (t tenantQueryDo) ForceDelete() (gen.ResultInfo, error) { + return t.Unscoped().Delete() +} + +// Inc increases the given column by step for current scope. +func (t tenantQueryDo) Inc(column field.Expr, step int64) (gen.ResultInfo, error) { + // column = column + step + e := field.NewUnsafeFieldRaw("?+?", column.RawExpr(), step) + return t.DO.UpdateColumn(column, e) +} + +// Dec decreases the given column by step for current scope. +func (t tenantQueryDo) Dec(column field.Expr, step int64) (gen.ResultInfo, error) { + // column = column - step + e := field.NewUnsafeFieldRaw("?-?", column.RawExpr(), step) + return t.DO.UpdateColumn(column, e) +} + +// Sum returns SUM(column) for current scope. +func (t tenantQueryDo) Sum(column field.Expr) (float64, error) { + var _v float64 + agg := field.NewUnsafeFieldRaw("SUM(?)", column.RawExpr()) + if err := t.Select(agg).Scan(&_v); err != nil { + return 0, err + } + return _v, nil +} + +// Avg returns AVG(column) for current scope. +func (t tenantQueryDo) Avg(column field.Expr) (float64, error) { + var _v float64 + agg := field.NewUnsafeFieldRaw("AVG(?)", column.RawExpr()) + if err := t.Select(agg).Scan(&_v); err != nil { + return 0, err + } + return _v, nil +} + +// Min returns MIN(column) for current scope. +func (t tenantQueryDo) Min(column field.Expr) (float64, error) { + var _v float64 + agg := field.NewUnsafeFieldRaw("MIN(?)", column.RawExpr()) + if err := t.Select(agg).Scan(&_v); err != nil { + return 0, err + } + return _v, nil +} + +// Max returns MAX(column) for current scope. +func (t tenantQueryDo) Max(column field.Expr) (float64, error) { + var _v float64 + agg := field.NewUnsafeFieldRaw("MAX(?)", column.RawExpr()) + if err := t.Select(agg).Scan(&_v); err != nil { + return 0, err + } + return _v, nil +} + +// PluckMap returns a map[key]value for selected key/value expressions within current scope. +func (t tenantQueryDo) PluckMap(key, val field.Expr) (map[interface{}]interface{}, error) { + do := t.Select(key, val) + rows, err := do.DO.Rows() + if err != nil { + return nil, err + } + defer rows.Close() + mm := make(map[interface{}]interface{}) + for rows.Next() { + var k interface{} + var v interface{} + if err := rows.Scan(&k, &v); err != nil { + return nil, err + } + mm[k] = v + } + return mm, rows.Err() +} + +// Exists returns true if any record matches the given conditions. +func (t tenantQueryDo) Exists(conds ...gen.Condition) (bool, error) { + cnt, err := t.Where(conds...).Count() + if err != nil { + return false, err + } + return cnt > 0, nil +} + +// PluckIDs returns all primary key values under current scope. +func (t tenantQueryDo) PluckIDs() ([]int64, error) { + ids := make([]int64, 0, 16) + pk := field.NewInt64(t.TableName(), "id") + if err := t.DO.Pluck(pk, &ids); err != nil { + return nil, err + } + return ids, nil +} + +// GetByID finds a single record by primary key. +func (t tenantQueryDo) GetByID(id int64) (*Tenant, error) { + pk := field.NewInt64(t.TableName(), "id") + return t.Where(pk.Eq(id)).First() +} + +// GetByIDs finds records by primary key list. +func (t tenantQueryDo) GetByIDs(ids ...int64) ([]*Tenant, error) { + if len(ids) == 0 { + return []*Tenant{}, nil + } + pk := field.NewInt64(t.TableName(), "id") + return t.Where(pk.In(ids...)).Find() +} + +// DeleteByID deletes records by primary key. +func (t tenantQueryDo) DeleteByID(id int64) (gen.ResultInfo, error) { + pk := field.NewInt64(t.TableName(), "id") + return t.Where(pk.Eq(id)).Delete() +} + +// DeleteByIDs deletes records by a list of primary keys. +func (t tenantQueryDo) DeleteByIDs(ids ...int64) (gen.ResultInfo, error) { + if len(ids) == 0 { + return gen.ResultInfo{RowsAffected: 0, Error: nil}, nil + } + pk := field.NewInt64(t.TableName(), "id") + return t.Where(pk.In(ids...)).Delete() +} + +func (t *tenantQueryDo) withDO(do gen.Dao) *tenantQueryDo { + t.DO = *do.(*gen.DO) + return t +} diff --git a/backend/pkg/consts/consts.gen.go b/backend/pkg/consts/consts.gen.go index a0935e4..990a172 100644 --- a/backend/pkg/consts/consts.gen.go +++ b/backend/pkg/consts/consts.gen.go @@ -16,8 +16,6 @@ import ( const ( // RoleUser is a Role of type user. RoleUser Role = "user" - // RoleTenantAdmin is a Role of type tenant_admin. - RoleTenantAdmin Role = "tenant_admin" // RoleSuperAdmin is a Role of type super_admin. RoleSuperAdmin Role = "super_admin" ) @@ -26,7 +24,6 @@ var ErrInvalidRole = fmt.Errorf("not a valid Role, try [%s]", strings.Join(_Role var _RoleNames = []string{ string(RoleUser), - string(RoleTenantAdmin), string(RoleSuperAdmin), } @@ -41,7 +38,6 @@ func RoleNames() []string { func RoleValues() []Role { return []Role{ RoleUser, - RoleTenantAdmin, RoleSuperAdmin, } } @@ -59,9 +55,8 @@ func (x Role) IsValid() bool { } var _RoleValue = map[string]Role{ - "user": RoleUser, - "tenant_admin": RoleTenantAdmin, - "super_admin": RoleSuperAdmin, + "user": RoleUser, + "super_admin": RoleSuperAdmin, } // ParseRole attempts to convert a string to a Role. @@ -178,6 +173,331 @@ func (x NullRoleStr) Value() (driver.Value, error) { return x.Role.String(), nil } +const ( + // TenantStatusPendingVerify is a TenantStatus of type pending_verify. + TenantStatusPendingVerify TenantStatus = "pending_verify" + // TenantStatusVerified is a TenantStatus of type verified. + TenantStatusVerified TenantStatus = "verified" + // TenantStatusBanned is a TenantStatus of type banned. + TenantStatusBanned TenantStatus = "banned" +) + +var ErrInvalidTenantStatus = fmt.Errorf("not a valid TenantStatus, try [%s]", strings.Join(_TenantStatusNames, ", ")) + +var _TenantStatusNames = []string{ + string(TenantStatusPendingVerify), + string(TenantStatusVerified), + string(TenantStatusBanned), +} + +// TenantStatusNames returns a list of possible string values of TenantStatus. +func TenantStatusNames() []string { + tmp := make([]string, len(_TenantStatusNames)) + copy(tmp, _TenantStatusNames) + return tmp +} + +// TenantStatusValues returns a list of the values for TenantStatus +func TenantStatusValues() []TenantStatus { + return []TenantStatus{ + TenantStatusPendingVerify, + TenantStatusVerified, + TenantStatusBanned, + } +} + +// String implements the Stringer interface. +func (x TenantStatus) String() string { + return string(x) +} + +// IsValid provides a quick way to determine if the typed value is +// part of the allowed enumerated values +func (x TenantStatus) IsValid() bool { + _, err := ParseTenantStatus(string(x)) + return err == nil +} + +var _TenantStatusValue = map[string]TenantStatus{ + "pending_verify": TenantStatusPendingVerify, + "verified": TenantStatusVerified, + "banned": TenantStatusBanned, +} + +// ParseTenantStatus attempts to convert a string to a TenantStatus. +func ParseTenantStatus(name string) (TenantStatus, error) { + if x, ok := _TenantStatusValue[name]; ok { + return x, nil + } + return TenantStatus(""), fmt.Errorf("%s is %w", name, ErrInvalidTenantStatus) +} + +var errTenantStatusNilPtr = errors.New("value pointer is nil") // one per type for package clashes + +// Scan implements the Scanner interface. +func (x *TenantStatus) Scan(value interface{}) (err error) { + if value == nil { + *x = TenantStatus("") + return + } + + // A wider range of scannable types. + // driver.Value values at the top of the list for expediency + switch v := value.(type) { + case string: + *x, err = ParseTenantStatus(v) + case []byte: + *x, err = ParseTenantStatus(string(v)) + case TenantStatus: + *x = v + case *TenantStatus: + if v == nil { + return errTenantStatusNilPtr + } + *x = *v + case *string: + if v == nil { + return errTenantStatusNilPtr + } + *x, err = ParseTenantStatus(*v) + default: + return errors.New("invalid type for TenantStatus") + } + + return +} + +// Value implements the driver Valuer interface. +func (x TenantStatus) Value() (driver.Value, error) { + return x.String(), nil +} + +// Set implements the Golang flag.Value interface func. +func (x *TenantStatus) Set(val string) error { + v, err := ParseTenantStatus(val) + *x = v + return err +} + +// Get implements the Golang flag.Getter interface func. +func (x *TenantStatus) Get() interface{} { + return *x +} + +// Type implements the github.com/spf13/pFlag Value interface. +func (x *TenantStatus) Type() string { + return "TenantStatus" +} + +type NullTenantStatus struct { + TenantStatus TenantStatus + Valid bool +} + +func NewNullTenantStatus(val interface{}) (x NullTenantStatus) { + err := x.Scan(val) // yes, we ignore this error, it will just be an invalid value. + _ = err // make any errcheck linters happy + return +} + +// Scan implements the Scanner interface. +func (x *NullTenantStatus) Scan(value interface{}) (err error) { + if value == nil { + x.TenantStatus, x.Valid = TenantStatus(""), false + return + } + + err = x.TenantStatus.Scan(value) + x.Valid = (err == nil) + return +} + +// Value implements the driver Valuer interface. +func (x NullTenantStatus) Value() (driver.Value, error) { + if !x.Valid { + return nil, nil + } + // driver.Value accepts int64 for int values. + return string(x.TenantStatus), nil +} + +type NullTenantStatusStr struct { + NullTenantStatus +} + +func NewNullTenantStatusStr(val interface{}) (x NullTenantStatusStr) { + x.Scan(val) // yes, we ignore this error, it will just be an invalid value. + return +} + +// Value implements the driver Valuer interface. +func (x NullTenantStatusStr) Value() (driver.Value, error) { + if !x.Valid { + return nil, nil + } + return x.TenantStatus.String(), nil +} + +const ( + // TenantUserRoleMember is a TenantUserRole of type member. + TenantUserRoleMember TenantUserRole = "member" + // TenantUserRoleTenantAdmin is a TenantUserRole of type tenant_admin. + TenantUserRoleTenantAdmin TenantUserRole = "tenant_admin" +) + +var ErrInvalidTenantUserRole = fmt.Errorf("not a valid TenantUserRole, try [%s]", strings.Join(_TenantUserRoleNames, ", ")) + +var _TenantUserRoleNames = []string{ + string(TenantUserRoleMember), + string(TenantUserRoleTenantAdmin), +} + +// TenantUserRoleNames returns a list of possible string values of TenantUserRole. +func TenantUserRoleNames() []string { + tmp := make([]string, len(_TenantUserRoleNames)) + copy(tmp, _TenantUserRoleNames) + return tmp +} + +// TenantUserRoleValues returns a list of the values for TenantUserRole +func TenantUserRoleValues() []TenantUserRole { + return []TenantUserRole{ + TenantUserRoleMember, + TenantUserRoleTenantAdmin, + } +} + +// String implements the Stringer interface. +func (x TenantUserRole) String() string { + return string(x) +} + +// IsValid provides a quick way to determine if the typed value is +// part of the allowed enumerated values +func (x TenantUserRole) IsValid() bool { + _, err := ParseTenantUserRole(string(x)) + return err == nil +} + +var _TenantUserRoleValue = map[string]TenantUserRole{ + "member": TenantUserRoleMember, + "tenant_admin": TenantUserRoleTenantAdmin, +} + +// ParseTenantUserRole attempts to convert a string to a TenantUserRole. +func ParseTenantUserRole(name string) (TenantUserRole, error) { + if x, ok := _TenantUserRoleValue[name]; ok { + return x, nil + } + return TenantUserRole(""), fmt.Errorf("%s is %w", name, ErrInvalidTenantUserRole) +} + +var errTenantUserRoleNilPtr = errors.New("value pointer is nil") // one per type for package clashes + +// Scan implements the Scanner interface. +func (x *TenantUserRole) Scan(value interface{}) (err error) { + if value == nil { + *x = TenantUserRole("") + return + } + + // A wider range of scannable types. + // driver.Value values at the top of the list for expediency + switch v := value.(type) { + case string: + *x, err = ParseTenantUserRole(v) + case []byte: + *x, err = ParseTenantUserRole(string(v)) + case TenantUserRole: + *x = v + case *TenantUserRole: + if v == nil { + return errTenantUserRoleNilPtr + } + *x = *v + case *string: + if v == nil { + return errTenantUserRoleNilPtr + } + *x, err = ParseTenantUserRole(*v) + default: + return errors.New("invalid type for TenantUserRole") + } + + return +} + +// Value implements the driver Valuer interface. +func (x TenantUserRole) Value() (driver.Value, error) { + return x.String(), nil +} + +// Set implements the Golang flag.Value interface func. +func (x *TenantUserRole) Set(val string) error { + v, err := ParseTenantUserRole(val) + *x = v + return err +} + +// Get implements the Golang flag.Getter interface func. +func (x *TenantUserRole) Get() interface{} { + return *x +} + +// Type implements the github.com/spf13/pFlag Value interface. +func (x *TenantUserRole) Type() string { + return "TenantUserRole" +} + +type NullTenantUserRole struct { + TenantUserRole TenantUserRole + Valid bool +} + +func NewNullTenantUserRole(val interface{}) (x NullTenantUserRole) { + err := x.Scan(val) // yes, we ignore this error, it will just be an invalid value. + _ = err // make any errcheck linters happy + return +} + +// Scan implements the Scanner interface. +func (x *NullTenantUserRole) Scan(value interface{}) (err error) { + if value == nil { + x.TenantUserRole, x.Valid = TenantUserRole(""), false + return + } + + err = x.TenantUserRole.Scan(value) + x.Valid = (err == nil) + return +} + +// Value implements the driver Valuer interface. +func (x NullTenantUserRole) Value() (driver.Value, error) { + if !x.Valid { + return nil, nil + } + // driver.Value accepts int64 for int values. + return string(x.TenantUserRole), nil +} + +type NullTenantUserRoleStr struct { + NullTenantUserRole +} + +func NewNullTenantUserRoleStr(val interface{}) (x NullTenantUserRoleStr) { + x.Scan(val) // yes, we ignore this error, it will just be an invalid value. + return +} + +// Value implements the driver Valuer interface. +func (x NullTenantUserRoleStr) Value() (driver.Value, error) { + if !x.Valid { + return nil, nil + } + return x.TenantUserRole.String(), nil +} + const ( // UserStatusPendingVerify is a UserStatus of type pending_verify. UserStatusPendingVerify UserStatus = "pending_verify" diff --git a/backend/pkg/consts/consts.go b/backend/pkg/consts/consts.go index 6aa34c9..3308f4f 100644 --- a/backend/pkg/consts/consts.go +++ b/backend/pkg/consts/consts.go @@ -8,9 +8,19 @@ package consts // // ) // swagger:enum Role -// ENUM( user, tenant_admin, super_admin) +// ENUM( user, super_admin) type Role string // swagger:enum UserStatus // ENUM(pending_verify, verified, banned, ) type UserStatus string + +// tenants + +// swagger:enum TenantStatus +// ENUM( pending_verify, verified, banned ) +type TenantStatus string + +// swagger:enum TenantUserRole +// ENUM( member, tenant_admin) +type TenantUserRole string