williamet/cas_tt_cloud_backend
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

feat：完善项目信息

Browse Source
This commit is contained in:
henry
2022-01-05 11:29:27 +08:00
parent d8ca61a449
commit 822ced6041
88 changed files with 375 additions and 308 deletions
Download Patch File Download Diff File Expand all files Collapse all files

107
app/api/admin/controller/tenant/auth.go Normal file
View File

@ -0,0 +1,107 @@
package tenant
import (
"SciencesServer/app/api/admin/controller"
model3 "SciencesServer/app/api/admin/model"
model2 "SciencesServer/app/common/model"
"SciencesServer/app/service"
"SciencesServer/serve/logger"
"SciencesServer/serve/orm"
"SciencesServer/utils"
"errors"
"gorm.io/gorm"
)
type Auth struct{ *controller.Platform }
type AuthHandle func(session *service.Session) *Auth
// delete 删除所有权限
func (c *Auth) delete(tenantID uint64, tenantKey string, tx *gorm.DB) error {
mSysRoleAuth := model3.NewSysRoleAuth()
err := model2.DeleteWhere(mSysRoleAuth.SysRoleAuth, []*model2.ModelWhere{model2.NewWhere("tenant_id", tenantID)}, tx)
if err != nil {
return err
}
go utils.TryCatch(func() {
permission := service.NewPermission(nil)(tenantKey, "")
if succ, err := permission.RemoveFilteredGroupingPolicy(); err != nil {
logger.ErrorF("删除租户【%s】权限信息错误：%v", tenantKey, err)
} else if !succ {
logger.ErrorF("删除租户【%s】权限信息失败", tenantKey)
}
})
return nil
}
// revoke 撤销某些权限
func (c *Auth) revoke(tenantID uint64, tenantKey string, authIDs []uint64, tx *gorm.DB) error {
// 查询该租户下不含有的权限信息
mSysRuleAuth := model3.NewSysRoleAuth()
out, err := mSysRuleAuth.Auths(model2.NewWhere("r.tenant_id", tenantID), model2.NewWhereNotIn("r_a.auth_id", authIDs))
if err != nil {
return err
}
if len(out) <= 0 {
return nil
}
roleAuthIDs := make([]uint64, 0)
roleIDs := make([]string, 0)
auths := make([]*service.AuthRequest, 0)
for _, v := range out {
roleAuthIDs = append(roleAuthIDs, v.ID)
roleIDs = append(roleIDs, utils.UintToString(v.RoleID))
auths = append(auths, &service.AuthRequest{Url: v.Auth, Method: "*"})
}
if err = model2.DeleteWhere(mSysRuleAuth.SysRoleAuth, []*model2.ModelWhere{model2.NewWhereIn("id", roleAuthIDs)}); err != nil {
return err
}
go utils.TryCatch(func() {
//permission := service.NewPermission(roleIDs, auths...)(c.TenantKey, "")
//// 删除角色权限
//if _, err = permission.RemoveNamedGroupingPolicies(); err != nil {
// logger.ErrorF("删除租户【%s】下角色权限错误：%v", tenantKey, err)
// return
//}
})
return nil
}
// Bind 绑定权限
func (c *Auth) Bind(tenantID uint64, authIDs []uint64) error {
mSysTenant := model3.NewSysTenant()
mSysTenant.ID = tenantID
isExist, err := model2.FirstField(mSysTenant.SysTenant, []string{"id", "key"})
if err != nil {
return err
} else if !isExist {
return errors.New("租户/公司信息不存在或已被删除")
}
return orm.GetDB().Transaction(func(tx *gorm.DB) error {
mSysTenantAuth := model3.NewSysTenantAuth()
if err = model2.DeleteWhere(mSysTenantAuth.SysTenantAuth, []*model2.ModelWhere{model2.NewWhere("tenant_id", mSysTenant.ID)}, tx); err != nil {
return err
}
if len(authIDs) <= 0 {
// 删除租户下所有角色的权限
return c.delete(mSysTenant.ID, mSysTenant.Key, tx)
}
return c.revoke(mSysTenant.ID, mSysTenant.Key, authIDs, tx)
})
}
func NewAuth() AuthHandle {
return func(session *service.Session) *Auth {
return &Auth{Platform: &controller.Platform{Session: session}}
}
}

421
app/api/admin/controller/tenant/instance.go Normal file
View File

@ -0,0 +1,421 @@
package tenant
import (
"SciencesServer/app/api/admin/controller"
auth2 "SciencesServer/app/api/admin/controller/auth"
menu2 "SciencesServer/app/api/admin/controller/menu"
model3 "SciencesServer/app/api/admin/model"
model2 "SciencesServer/app/common/model"
"SciencesServer/app/service"
"SciencesServer/config"
"SciencesServer/serve/orm"
"errors"
"fmt"
"time"
"gorm.io/gorm"
)
type Instance struct{ *controller.Platform }
type InstanceHandle func(session *service.Session) *Instance
type (
// InstanceInfo 租户信息
InstanceInfo struct {
*model3.SysTenantInfo
}
// InstanceParams 租户参数信息
InstanceParams struct {
ID uint64
Image, Name, Account, Password, RepeatPwd string
Deadline, Remark string
}
// InstanceBasicInfo 租户基本信息
InstanceBasicInfo struct {
ID uint64 `json:"id"`
Name string `json:"name"`
}
// InstanceDetailType 租户信息类型
InstanceDetailType int
)
const (
// InstanceDetailTypeForBasic 基本信息
InstanceDetailTypeForBasic InstanceDetailType = iota + 1
// InstanceDetailTypeForMember 成员信息
InstanceDetailTypeForMember
// InstanceDetailTypeForAuth 权限信息
InstanceDetailTypeForAuth
)
// instanceDetailGetHandle 详细信息获取操作
var instanceDetailGetHandle = map[InstanceDetailType]func(id uint64) func(args ...interface{}) (interface{}, error){
InstanceDetailTypeForBasic: basic,
InstanceDetailTypeForMember: member,
InstanceDetailTypeForAuth: auth,
}
// basic 基本信息
func basic(id uint64) func(args ...interface{}) (interface{}, error) {
return func(args ...interface{}) (interface{}, error) {
mSysTenant := model3.NewSysTenant()
mSysTenant.ID = id
isExist, err := model2.FirstWhere(mSysTenant.SysTenant)
if err != nil {
return nil, err
} else if !isExist {
return nil, errors.New("信息不存在")
}
return &InstanceInfo{SysTenantInfo: &model3.SysTenantInfo{
SysTenant: mSysTenant.SysTenant,
}}, nil
}
}
// member 人员信息
func member(id uint64) func(args ...interface{}) (interface{}, error) {
return func(args ...interface{}) (interface{}, error) {
mSysUserTenant := model3.NewSysUserTenant()
page := args[0].(int)
pageSize := args[1].(int)
where := []*model2.ModelWhere{model2.NewWhere("u_t.tenant_id", id)}
if args[2] != nil && args[2] != "" {
where = append(where, model2.NewWhereLike("u.name", args[2]))
}
if args[3] != nil && args[3].(int) > 0 {
where = append(where, model2.NewWhere("u_t.status", args[3]))
}
var count int64
out, err := mSysUserTenant.Member(page, pageSize, &count, where...)
if err != nil {
return nil, err
}
return &controller.ReturnPages{Data: out, Count: count}, nil
}
}
// auth 权限信息
func auth(id uint64) func(args ...interface{}) (interface{}, error) {
return func(args ...interface{}) (interface{}, error) {
mSysMenu := model3.NewSysMenu()
_menu, err := mSysMenu.TenantMenu(id)
if err != nil {
return nil, err
}
mSysAuth := model3.NewSysAuth()
_auth := make([]*model3.SysAuthScene, 0)
if _auth, err = mSysAuth.TenantAuth(id); err != nil {
return nil, err
}
return map[string]interface{}{
"menu": menu2.TreeCheckedFunc(_menu, 0), "auth": auth2.TreeCheckedFunc(_auth, 0),
}, nil
}
}
// validateForCustomerCount 验证最大客户数
func (c *Instance) validateForCustomerCount(tenantID uint64, sysValue, srcValue int) (bool, error) {
if srcValue > sysValue {
return true, nil
}
mSysTenant := model3.NewSysTenant()
var count int64
if err := model2.Count(mSysTenant.SysTenant, &count, model2.NewWhere("parent_id", tenantID)); err != nil {
return false, err
}
return int(count) <= srcValue, nil
}
// List 列表信息
func (c *Instance) List(name string, status, page, pageSize int) (*controller.ReturnPages, error) {
mSysTenant := model3.NewSysTenant()
var count int64
where := []*model2.ModelWhere{model2.NewWhere("t.parent_id", 0)}
if name != "" {
where = append(where, model2.NewWhereLike("t.name", name))
}
if status > 0 {
where = append(where, model2.NewWhere("t.status", status))
}
out, err := mSysTenant.Tenants(page, pageSize, &count, where...)
if err != nil {
return nil, err
}
list := make([]*InstanceInfo, 0)
for _, v := range out {
v.Image.Image = v.Image.Analysis(config.SettingInfo.Domain)
list = append(list, &InstanceInfo{SysTenantInfo: v})
}
return &controller.ReturnPages{Data: list, Count: count}, nil
}
// Add 数据处理
func (c *Instance) Add(params *InstanceParams) error {
mSysTenant := model3.NewSysTenant()
if params.Password != params.RepeatPwd {
return errors.New("密码不一致")
}
isExist, err := model2.FirstWhere(mSysTenant.SysTenant, model2.NewWhere("name", params.Name))
if err != nil {
return err
} else if isExist {
return errors.New("该租户/公司名称已存在")
}
mSysUser := model3.NewSysUser()
if isExist, err = model2.FirstWhere(mSysUser.SysUser, model2.NewWhere("account", params.Account)); err != nil {
return err
} else if isExist {
return errors.New("登录用户名已存在")
}
if err = orm.GetDB().Transaction(func(tx *gorm.DB) error {
mSysTenant.Image.Image = params.Image
mSysTenant.Name = params.Name
mSysTenant.Remark = params.Remark
if err = model2.Create(mSysTenant.SysTenant, tx); err != nil {
return err
}
mSysUser.Name = mSysTenant.Name
mSysUser.Account = params.Account
mSysUser.Password = params.Password
if err = model2.Create(mSysUser.SysUser, tx); err != nil {
return err
}
mSysUserTenant := model3.NewSysUserTenant()
mSysUserTenant.TenantID = mSysTenant.ID
mSysUserTenant.UID = mSysUser.UUID
mSysUserTenant.Identity = model2.SysUserTenantIdentityForSystemAdmin
if err = model2.Create(mSysUserTenant.SysUserTenant, tx); err != nil {
return err
}
return nil
}); err != nil {
return err
}
return nil
}
// Edit 修改信息
func (c *Instance) Edit(params *InstanceParams) error {
mSysTenant := model3.NewSysTenant()
mSysTenant.ID = params.ID
isExist, err := model2.FirstWhere(mSysTenant.SysTenant)
if err != nil {
return err
} else if !isExist {
return errors.New("租户/公司信息不存在")
} else if c.TenantID > 0 {
if mSysTenant.ParentID <= 0 {
return errors.New("不可修改其他租户/公司的信息")
} else if c.TenantID != mSysTenant.ParentID {
return errors.New("不可修改其他租户/公司的客户信息")
}
}
if mSysTenant.Name != params.Name {
if isExist, err = model2.FirstWhere(mSysTenant.SysTenant, model2.NewWhere("name", params.Name)); err != nil {
return err
} else if isExist {
return errors.New("该租户/公司名称已存在")
}
}
if err = model2.Updates(mSysTenant.SysTenant, map[string]interface{}{
"name": params.Name, "image": params.Image, "remark": params.Remark, "updated_at": time.Now(),
}); err != nil {
return err
}
return nil
}
// EditPassword 修改信息
func (c *Instance) EditPassword(params *InstanceParams) error {
mSysTenant := model3.NewSysTenant()
mSysTenant.ID = params.ID
isExist, err := model2.FirstWhere(mSysTenant.SysTenant)
if err != nil {
return err
} else if !isExist {
return errors.New("租户/公司信息不存在")
} else if c.TenantID > 0 {
if mSysTenant.ParentID <= 0 {
return errors.New("不可修改其他租户/公司的用户密码信息")
} else if c.TenantID != mSysTenant.ParentID {
return errors.New("不可修改其他租户/公司的用户密码信息")
}
}
if params.Password != params.RepeatPwd {
return errors.New("密码不一致")
}
// 查询该租户下管理员信息
mSysUserTenant := model3.NewSysUserTenant()
if isExist, err = model2.FirstField(mSysUserTenant.SysUserTenant, []string{"id", "uid", "identity"},
model2.NewWhere("tenant_id", params.ID), model2.NewWhere("identity", model2.SysUserTenantIdentityForSystemAdmin)); err != nil {
return err
} else if !isExist {
return errors.New("该租户/公司下管理员信息不存在或已被删除")
}
mSysUser := model3.NewSysUser()
mSysUser.Password = params.Password
mSysUser.Pass()
if err = model2.UpdatesWhere(mSysUser.SysUser, map[string]interface{}{
"password": mSysUser.Password, "salt": mSysUser.Salt, "updated_at": time.Now(),
}, []*model2.ModelWhere{model2.NewWhere("uuid", mSysUserTenant.UID)}); err != nil {
return err
}
return nil
}
// Detail 详细信息
func (c *Instance) Detail(id uint64, tType InstanceDetailType, page, pageSize int, name string, status int) (interface{}, error) {
handle, has := instanceDetailGetHandle[tType]
if !has {
return nil, errors.New(fmt.Sprintf("Unknown Tenant Detail Type：%d", tType))
}
out, err := handle(id)(page, pageSize, name, status)
if err != nil {
return nil, err
}
return out, nil
}
// Renewal 续期操作
func (c *Instance) Renewal(id uint64, deadline string) error {
mSysTenant := model3.NewSysTenant()
mSysTenant.ID = id
isExist, err := model2.FirstWhere(mSysTenant.SysTenant)
if err != nil {
return err
} else if !isExist {
return errors.New("租户/公司信息不存在")
} else if c.TenantID > 0 {
if mSysTenant.ParentID <= 0 {
return errors.New("非超级管理员，不可操作")
} else if c.TenantID != mSysTenant.ParentID {
return errors.New("非法操作，不可续期他人客户使用期限")
}
}
now := time.Now()
updates := make(map[string]interface{}, 0)
updates["updated_at"] = now
if err = model2.Updates(mSysTenant.SysTenant, updates); err != nil {
return err
}
return nil
}
// StartUp 启用处理
func (c *Instance) StartUp(id uint64) error {
mSysTenant := model3.NewSysTenant()
mSysTenant.ID = id
isExist, err := model2.FirstWhere(mSysTenant.SysTenant)
if err != nil {
return err
} else if !isExist {
return errors.New("租户/公司/客户信息不存在")
} else if c.TenantID > 0 {
if mSysTenant.ParentID <= 0 {
return errors.New("非超级管理员，不可操作")
} else if c.TenantID != mSysTenant.ParentID {
return errors.New("不可启用其他租户/公司客户")
}
}
if err = model2.Updates(mSysTenant.SysTenant, map[string]interface{}{}); err != nil {
return err
}
return nil
}
// Disable 禁用处理
func (c *Instance) Disable(id uint64) error {
//mSysTenant := model.NewSysTenant()
//mSysTenant.ID = id
//
//isExist, err := model2.FirstWhere(mSysTenant.SysTenant)
//if err != nil {
// return err
//} else if !isExist {
// return errors.New("租户/公司/客户信息不存在")
//} else if c.TenantID > 0 {
// if mSysTenant.ParentID <= 0 {
// return errors.New("非超级管理员，不可操作")
// } else if c.TenantID != mSysTenant.ParentID {
// return errors.New("不可启用其他租户/公司/客户")
// }
//} else if mSysTenant.Status == model2.SysTenantStatusForDisable {
// return errors.New("该租户/公司/客户已是禁用状态")
//}
//if err = model2.Updates(mSysTenant.SysTenant, map[string]interface{}{
// "status": model2.SysTenantStatusForDisable, "updated_at": time.Now(),
//}); err != nil {
// return err
//}
//// TODO：推送用户强制退出，并强行删除所有产品数据
//service.Publish(config.EventForRedisListDestroy, config.RedisKeyForTenant, mSysTenant.Key)
return nil
}
// MemberBind 人员绑定/解绑
func (c *Instance) MemberBind(id uint64, status int) error {
mSysUserTenant := model3.NewSysUserTenant()
mSysUserTenant.ID = id
isExist, err := model2.FirstField(mSysUserTenant.SysUserTenant, []string{"id", "tenant_id", "identity"})
if err != nil {
return err
} else if !isExist {
return errors.New("用户信息不存在")
}
if err := model2.Updates(mSysUserTenant.SysUserTenant, map[string]interface{}{
"status": status, "updated_at": time.Now(),
}); err != nil {
return err
}
return nil
}
func NewInstance() InstanceHandle {
return func(session *service.Session) *Instance {
return &Instance{Platform: &controller.Platform{Session: session}}
}
}

88
app/api/admin/controller/tenant/menu.go Normal file
View File

@ -0,0 +1,88 @@
package tenant
import (
"SciencesServer/app/api/admin/controller"
menu2 "SciencesServer/app/api/admin/controller/menu"
model3 "SciencesServer/app/api/admin/model"
model2 "SciencesServer/app/common/model"
"SciencesServer/app/service"
"SciencesServer/serve/orm"
"errors"
"gorm.io/gorm"
)
type Menu struct{ *controller.Platform }
type MenuHandle func(session *service.Session) *Menu
// List 菜单列表
func (c *Menu) List(tenantID uint64) ([]*menu2.TreeChecked, error) {
mSysMenu := model3.NewSysMenu()
return menu2.MenuForTenant(mSysMenu, tenantID)
}
// Bind 绑定菜单
func (c *Menu) Bind(tenantID uint64, menuIDs []uint64) error {
if len(menuIDs) > 0 {
var count int64
mSysMenu := model3.NewSysMenu()
if err := model2.Count(mSysMenu.SysMenu, &count, model2.NewWhereIn("id", menuIDs),
model2.NewWhere("auth", model2.SysMenuAuthForSystem)); err != nil {
return err
} else if count > 0 {
return errors.New("不可设置超管菜单")
}
}
mSysTenantMenu := model3.NewSysTenantMenu()
return orm.GetDB().Transaction(func(tx *gorm.DB) error {
// TODO：先全部删除，后期考虑局部删除
err := model2.DeleteWhere(mSysTenantMenu.SysTenantMenu, []*model2.ModelWhere{model2.NewWhere("tenant_id", tenantID)}, tx)
if err != nil {
return err
}
// 租户角色的菜单
mSysRoleMenu := model3.NewSysRoleMenu()
if len(menuIDs) <= 0 {
if err = model2.DeleteWhere(mSysRoleMenu.SysRoleMenu, []*model2.ModelWhere{model2.NewWhere("tenant_id", tenantID)}, tx); err != nil {
return err
}
return nil
}
menus := make([]*model2.SysTenantMenu, 0)
mark := make(map[uint64]uint64, 0)
for _, v := range menuIDs {
if _, has := mark[v]; has {
continue
}
menus = append(menus, &model2.SysTenantMenu{
ModelTenant: model2.ModelTenant{TenantID: tenantID}, MenuID: v,
})
mark[v] = v
}
if err = model2.Creates(mSysTenantMenu.SysTenantMenu, menus, tx); err != nil {
return err
}
// 删除租户下角色不存在的菜单
if err = model2.DeleteWhere(mSysRoleMenu.SysRoleMenu, []*model2.ModelWhere{
model2.NewWhere("tenant_id", tenantID),
model2.NewWhereNotIn("menu_id", menuIDs),
}); err != nil {
return err
}
return nil
})
}
func NewMenu() MenuHandle {
return func(session *service.Session) *Menu {
return &Menu{Platform: &controller.Platform{Session: session}}
}
}

20
app/api/admin/controller/tenant/struct.go Normal file
View File

@ -0,0 +1,20 @@
package tenant
// InstanceParamsForProtocol 协议参数
type InstanceParamsForSetting struct {
Protocol []uint
MaxDevices, MaxCustomer int
}
// NewProtocol 消息协议
func (c *InstanceParamsForSetting) NewProtocol() uint {
// &（与）：0&0=0 0&1=0 1&0=0 1&1=1
// |（或）：0&0=0 0&1=1 1&0=1 1&1=1
// ^（非）：0^0=0 0&1=1 1^0=1 1^1=0
var protocol uint
for i := 0; i < len(c.Protocol); i++ {
}
return protocol
}

44
app/api/admin/controller/tenant/sub.go Normal file
View File

@ -0,0 +1,44 @@
package tenant
import (
model2 "SciencesServer/app/common/model"
"SciencesServer/config"
"fmt"
"gorm.io/gorm"
)
type Sub struct{}
type SubHandle func() *Sub
// database 数据表
func (c *Sub) database(key string) string {
return model2.SubDatabase + "_" + key
}
// sync 同步数据
func (c *Sub) sync(tx *gorm.DB, database string) error {
// TODO：生成租户对应数据库，并生成对应数据表
err := tx.Exec(fmt.Sprintf("CREATE DATABASE %s;", database)).Error
if err != nil {
return err
}
// 使用生成后的数据库
if err = tx.Exec(fmt.Sprintf("use %s;", database)).Error; err != nil {
return err
}
iModels := []model2.IModel{}
for _, v := range iModels {
if err = tx.Migrator().CreateTable(v); err != nil {
return err
}
}
// 重新使用默认的数据库
tx.Exec(fmt.Sprintf("use %s;", config.EngineInfo.Engines.Mysql.Database))
return nil
}