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

124
app/api/admin/controller/account.go
View File

@ -1 +1,125 @@
package controller
import (
"SciencesServer/app/api/admin/model"
model2 "SciencesServer/app/common/model"
"SciencesServer/app/handle"
"SciencesServer/app/service"
"SciencesServer/app/session"
"SciencesServer/config"
"SciencesServer/utils"
"errors"
"fmt"
)
type Account struct {
session *session.Admin
tenantID uint64
}
type AccountHandle func(session *session.Admin, tenantID uint64) *Account
type (
// AccountLoginParams 登陆参数
AccountLoginParams struct {
Account, Password, Captcha string
}
// AccountLoginResponse 登陆响应
AccountLoginResponse struct {
Token string `json:"token"`
EffectTime int `json:"effect_time"`
}
)
// loginHandle 登陆操作，1：账户密码登陆，2：短信验证登陆
var loginHandle = map[int]func(params *AccountLoginParams, tenantID uint64) (*model.SysUser, error){
1: loginForPassword, 2: loginForSmsCaptcha,
}
// loginForPassword 密码登陆
func loginForPassword(params *AccountLoginParams, tenantID uint64) (*model.SysUser, error) {
if params.Password == "" {
return nil, errors.New("操作错误，密码不可为空")
}
mSysUser := model.NewSysUser()
isExist, err := mSysUser.GetByAccountOrMobile(params.Account, tenantID)
if err != nil {
return nil, err
} else if !isExist {
return nil, errors.New("操作错误，当前帐号信息不存在或已被删除")
}
if !mSysUser.ValidatePassword(params.Password) {
return nil, errors.New("操作错误，用户名或密码错误")
}
return mSysUser, nil
}
// loginForSmsCaptcha 短信验证码登陆
func loginForSmsCaptcha(params *AccountLoginParams, tenantID uint64) (*model.SysUser, error) {
if params.Password == "" {
return nil, errors.New("操作错误，验证码不可为空")
}
// 验证验证码
if pass, _ := handle.NewCaptcha().Validate(&handle.CaptchaSms{Mobile: params.Account, Captcha: params.Captcha}); !pass {
return nil, errors.New("操作错误，验证码错误")
}
mSysUser := model.NewSysUser()
isExist, err := model2.FirstField(mSysUser.SysUser, []string{
"id", "tenant_id", "name", "mobile", "is_admin", "status",
}, model2.NewWhere("tenant_id", tenantID), model2.NewWhere("mobile", params.Account))
if err != nil {
return nil, err
} else if !isExist {
return nil, errors.New("操作错误，当前帐号信息不存在或已被删除")
}
return mSysUser, nil
}
// Login 登录请求
func (c *Account) Login(mode int, params *AccountLoginParams, equipment, ip string) (*AccountLoginResponse, error) {
_handle, has := loginHandle[mode]
if !has {
return nil, errors.New("操作错误，未知的登陆模式")
}
data, err := _handle(params, c.tenantID)
if err != nil {
return nil, err
} else if data.Status != model2.SysUserStatusForNormal {
return nil, errors.New(fmt.Sprintf("操作错误，当前账号【%s】状态异常，已禁止登陆，请联系管理员", data.Name))
}
_session := session.NewAdmin()
_session.UID = data.UUID
_session.TenantID = data.TenantID
_session.Name = data.Name
_session.Mobile = data.Mobile
_session.IsAdmin = data.IsAdminUser()
_uid := data.UUIDString()
_session.Token = utils.JWTEncrypt(config.SettingInfo.TokenEffectTime, map[string]interface{}{config.TokenForUID: _uid})
service.Publish(config.EventForRedisHashProduce, config.RedisKeyForAccountAdmin, _uid, _session)
service.Publish(config.EventForAccountLoginProduce, data.TenantID, _session.UID, equipment, ip)
return &AccountLoginResponse{Token: _session.Token, EffectTime: config.SettingInfo.TokenEffectTime}, nil
}
// Logout 退出请求
func (c *Account) Logout() error {
if c.session != nil && c.session.UID > 0 {
service.Publish(config.EventForRedisHashDestroy, config.RedisKeyForAccountAdmin, utils.UintToString(c.session.UID))
}
return nil
}
func NewAccount() AccountHandle {
return func(session *session.Admin, tenantID uint64) *Account {
return &Account{session: session, tenantID: tenantID}
}
}

60
app/api/admin/controller/auth/base.go Normal file
View File

@ -0,0 +1,60 @@
package auth
import (
"SciencesServer/app/api/admin/model"
model2 "SciencesServer/app/common/model"
)
type (
// Tree 权限信息
Tree struct {
*model2.SysAuth
KindTitle string `json:"kind_title"`
Children []*Tree `json:"children"`
}
// TreeRole 角色权限信息
TreeRole struct {
*model2.SysAuth
KindTitle string `json:"kind_title"`
Checked bool `json:"checked"`
Children []*TreeRole `json:"children"`
}
// TreeChecked 角色选中状态
TreeChecked struct {
*model2.SysAuth
Checked bool `json:"checked"`
Children []*TreeChecked `json:"children"`
}
)
// tree 树状筛选
func tree(src []*model2.SysAuth, parentID uint64) []*Tree {
out := make([]*Tree, 0)
for _, v := range src {
if v.ParentID == parentID {
out = append(out, &Tree{
SysAuth: v,
KindTitle: v.KindTitle(),
Children: tree(src, v.ID),
})
}
}
return out
}
// TreeCheckedFunc 树状筛选
func TreeCheckedFunc(src []*model.SysAuthScene, parentID uint64) []*TreeChecked {
out := make([]*TreeChecked, 0)
for _, v := range src {
if v.ParentID == parentID {
out = append(out, &TreeChecked{
SysAuth: v.SysAuth,
Checked: v.SceneID > 0,
Children: TreeCheckedFunc(src, v.ID),
})
}
}
return out
}

34
app/api/admin/controller/auth/instance.go Normal file
View File

@ -0,0 +1,34 @@
package auth
import (
"SciencesServer/app/api/admin/controller"
"SciencesServer/app/api/admin/model"
model2 "SciencesServer/app/common/model"
"SciencesServer/app/service"
)
type Instance struct{ *controller.Platform }
type InstanceHandle func(session *service.Session) *Instance
// List 列表信息
func (c *Instance) List() ([]*Tree, error) {
mSysAuth := model.NewSysAuth()
where := []*model2.ModelWhereOrder{
&model2.ModelWhereOrder{Order: model2.NewOrder("parent_id", model2.OrderModeToAsc)},
&model2.ModelWhereOrder{Order: model2.NewOrder("sort", model2.OrderModeToDesc)},
}
out := make([]*model2.SysAuth, 0)
if err := model2.Scan(mSysAuth, &out, where...); err != nil {
return nil, err
}
return tree(out, 0), nil
}
func NewInstance() InstanceHandle {
return func(session *service.Session) *Instance {
return &Instance{Platform: &controller.Platform{Session: session}}
}
}

37
app/api/admin/controller/base.go Normal file
View File

@ -0,0 +1,37 @@
package controller
import (
"SciencesServer/app/service"
"SciencesServer/config"
"SciencesServer/serve/cache"
"SciencesServer/utils"
)
// Platform
type Platform struct{ *service.Session }
func (c *Platform) Format() string {
return ""
}
// ReturnPages 分页数据
type ReturnPages struct {
Data interface{} `json:"data"`
Count int64 `json:"count"`
}
type Key struct{}
// Generate 生成秘钥
func (*Key) Generate(len int) string {
key := utils.GetRandomString(len)
for {
isExist, _ := cache.Cache.SIsMember(config.RedisKeyForTenantKeys, key)
if !isExist {
_ = cache.Cache.SAdd(config.RedisKeyForTenantKeys, key)
return key
}
key = utils.GetRandomString(len)
}
}

64
app/api/admin/controller/config.go Normal file
View File

@ -0,0 +1,64 @@
package controller
import (
"SciencesServer/app/api/admin/model"
model2 "SciencesServer/app/common/model"
"SciencesServer/config"
"SciencesServer/serve/orm"
"errors"
"time"
"gorm.io/gorm"
)
type Config struct{}
type ConfigHandle func() *Config
func (c *Config) Config(kind, page, pageSize int) (*ReturnPages, error) {
mSysConfig := model.NewSysConfig()
where := []*model2.ModelWhereOrder{
&model2.ModelWhereOrder{Order: model2.NewOrder("kind", model2.OrderModeToAsc)},
}
if kind > 0 {
where = append(where, &model2.ModelWhereOrder{Where: model2.NewWhere("kind", kind)})
}
out := make([]*model2.SysConfig, 0)
var count int64
if err := model2.Pages(mSysConfig.SysConfig, &out, page, pageSize, &count, where...); err != nil {
return nil, err
}
return &ReturnPages{Data: out, Count: count}, nil
}
func (c *Config) Form(params map[string]interface{}) error {
if len(params) <= 0 {
return nil
}
return orm.GetDB().Transaction(func(tx *gorm.DB) error {
mSysConfig := model.NewSysConfig()
now := time.Now()
for k, v := range params {
if _, has := config.SystemConfig[k]; !has {
return errors.New("UnKnown Config Key ：" + k)
}
if err := model2.UpdatesWhere(mSysConfig.SysConfig, map[string]interface{}{
"value": v, "updated_at": now,
}, []*model2.ModelWhere{model2.NewWhere("key", k)}, tx); err != nil {
return err
}
config.SystemConfig[k] = v
}
return nil
})
}
func NewConfig() ConfigHandle {
return func() *Config {
return &Config{}
}
}

98
app/api/admin/controller/department.go Normal file
View File

@ -0,0 +1,98 @@
package controller
import (
"SciencesServer/app/api/admin/model"
model2 "SciencesServer/app/common/model"
"SciencesServer/app/service"
"time"
)
type Department struct{ *Platform }
type DepartmentHandle func(session *service.Session) *Department
type DepartmentParams struct {
ID, ParentID uint64
Title, Name, Mobile, Remark string
}
type DepartmentTree struct {
*model2.SysDepartment
Children []*DepartmentTree `json:"children"`
}
func (c *Department) tree(src []*model2.SysDepartment, parentID uint64) []*DepartmentTree {
out := make([]*DepartmentTree, 0)
for _, v := range src {
if v.ParentID == parentID {
out = append(out, &DepartmentTree{
SysDepartment: v,
Children: c.tree(src, v.ID),
})
}
}
return out
}
func (c *Department) List() ([]*DepartmentTree, error) {
mSysDepartment := model.NewSysDepartment()
out := make([]*model2.SysDepartment, 0)
if err := model2.Scan(mSysDepartment.SysDepartment, &out, &model2.ModelWhereOrder{
Where: model2.NewWhere("tenant_id", c.TenantID),
Order: model2.NewOrder("parent_id", model2.OrderModeToAsc)}); err != nil {
return nil, err
}
return c.tree(out, 0), nil
}
func (c *Department) Select() ([]*DepartmentTree, error) {
mSysDepartment := model.NewSysDepartment()
out := make([]*model2.SysDepartment, 0)
if err := model2.ScanFields(mSysDepartment.SysDepartment, &out, []string{"id", "name"}, &model2.ModelWhereOrder{
Where: model2.NewWhere("tenant_id", c.TenantID),
Order: model2.NewOrder("parent_id", model2.OrderModeToAsc)}); err != nil {
return nil, err
}
return c.tree(out, 0), nil
}
func (c *Department) Data(params *DepartmentParams) error {
mSysDepartment := model.NewSysDepartment()
if params.ID <= 0 {
mSysDepartment.ParentID = params.ParentID
mSysDepartment.Title = params.Title
mSysDepartment.Name = params.Name
mSysDepartment.Mobile = params.Mobile
mSysDepartment.Remark = params.Remark
return model2.Create(mSysDepartment.SysDepartment)
}
mSysDepartment.ID = params.ID
return model2.Updates(mSysDepartment.SysDepartment, map[string]interface{}{
"parent_id": params.ParentID, "title": params.Title, "name": params.Name,
"mobile": params.Mobile, "remark": params.Remark, "updated_at": time.Now(),
})
}
func (c *Department) Delete(id uint64) error {
mSysDepartment := model.NewSysDepartment()
mSysDepartment.ID = id
if err := model2.Delete(mSysDepartment.SysDepartment); err != nil {
return err
}
return nil
}
func NewDepartment() DepartmentHandle {
return func(session *service.Session) *Department {
return &Department{Platform: &Platform{Session: session}}
}
}

57
app/api/admin/controller/logs.go Normal file
View File

@ -0,0 +1,57 @@
package controller
import (
"SciencesServer/app/api/admin/model"
model2 "SciencesServer/app/common/model"
"SciencesServer/app/service"
"SciencesServer/tools/ip"
)
type Log struct{ *Platform }
type LogHandle func(session *service.Session) *Log
type (
// LogForLogin 登录日志
LogForLogin struct {
*model.SysUserLoginLogInfo
IPAddress string `json:"ip_address"`
}
)
// Login 登录日志
func (c *Log) Login(name string, page, pageSize int) (*ReturnPages, error) {
mSysUserLoginLogs := model.NewSysUserLoginLog()
where := make([]*model2.ModelWhere, 0)
if c.TenantID > 0 {
where = append(where, model2.NewWhere("l.tenant_id", c.TenantID))
}
if name != "" {
where = append(where, model2.NewWhereLike("u.name", name))
}
var count int64
out, err := mSysUserLoginLogs.Logs(page, pageSize, &count, where...)
if err != nil {
return nil, err
}
list := make([]*LogForLogin, 0)
for _, v := range out {
ipAddress, _ := ip.Find(v.IP)
list = append(list, &LogForLogin{
SysUserLoginLogInfo: v, IPAddress: string(ipAddress),
})
}
return &ReturnPages{Data: list, Count: count}, nil
}
func NewLog() LogHandle {
return func(session *service.Session) *Log {
return &Log{Platform: &Platform{Session: session}}
}
}

228
app/api/admin/controller/manage/examine.go Normal file
View File

@ -0,0 +1,228 @@
package manage
import (
"SciencesServer/app/api/admin/model"
"SciencesServer/app/basic/config"
model2 "SciencesServer/app/common/model"
"SciencesServer/app/service"
"SciencesServer/serve/orm"
"SciencesServer/utils"
"errors"
"gorm.io/gorm"
"time"
)
type Examine struct {
*service.Session
local string
}
type ExamineHandle func(session *service.Session, local string) *Examine
type ExamineManageInfo struct {
IModel model2.IModel
UIDs []uint64 // 用户表UUID
}
// examineHandle 审核处理
var examineHandle = map[int]func(uint64) (*ExamineManageInfo, error){
config.TenantUserIdentityForCompany: examineCompany,
config.TenantUserIdentityForExpert: examineExpert,
config.TenantUserIdentityForResearch: examineResearch,
config.TenantUserIdentityForLaboratory: examineLaboratory,
}
func checkManage(IModel model2.IModel, id uint64) error {
IModel.SetID(id)
if isExist, err := model2.FirstField(IModel, []string{"id", "examine_status"}); err != nil {
return err
} else if !isExist {
return errors.New("数据信息不存在")
}
return nil
}
func examineCompany(id uint64) (*ExamineManageInfo, error) {
mManageCompany := model.NewManageCompany()
err := checkManage(mManageCompany.ManageCompany, id)
if err != nil {
return nil, err
} else if mManageCompany.Examine.ExamineStatus != model2.ExamineStatusForOngoing {
return nil, errors.New("操作错误，当前入驻信息已审核")
}
mUserCompany := model.NewUserCompany()
uids := make([]uint64, 0)
if err = model2.Pluck(mUserCompany.UserCompany, "uid", &uids, model2.NewWhere("company_id", id),
model2.NewWhere("invalid_status", model2.InvalidStatusForNot)); err != nil {
return nil, err
}
return &ExamineManageInfo{IModel: mManageCompany.ManageCompany, UIDs: uids}, nil
}
func examineExpert(id uint64) (*ExamineManageInfo, error) {
mManageExpert := model.NewManageExpert()
err := checkManage(mManageExpert.ManageExpert, id)
if err != nil {
return nil, err
} else if mManageExpert.Examine.ExamineStatus != model2.ExamineStatusForOngoing {
return nil, errors.New("操作错误，当前入驻信息已审核")
}
mUserExpert := model.NewUserExpert()
uids := make([]uint64, 0)
if err = model2.Pluck(mUserExpert.UserExpert, "uid", &uids, model2.NewWhere("expert_id", id),
model2.NewWhere("invalid_status", model2.InvalidStatusForNot)); err != nil {
return nil, err
}
return &ExamineManageInfo{IModel: mManageExpert.ManageExpert, UIDs: uids}, nil
}
func examineResearch(id uint64) (*ExamineManageInfo, error) {
mManageResearch := model.NewManageResearch()
err := checkManage(mManageResearch.ManageResearch, id)
if err != nil {
return nil, err
} else if mManageResearch.Examine.ExamineStatus != model2.ExamineStatusForOngoing {
return nil, errors.New("操作错误，当前入驻信息已审核")
}
mUserResearch := model.NewUserResearch()
uids := make([]uint64, 0)
if err = model2.Pluck(mUserResearch.UserResearch, "uid", &uids, model2.NewWhere("research_id", id),
model2.NewWhere("invalid_status", model2.InvalidStatusForNot)); err != nil {
return nil, err
}
return &ExamineManageInfo{IModel: mManageResearch.ManageResearch, UIDs: uids}, nil
}
func examineLaboratory(id uint64) (*ExamineManageInfo, error) {
mManageLaboratory := model.NewManageLaboratory()
err := checkManage(mManageLaboratory.ManageLaboratory, id)
if err != nil {
return nil, err
} else if mManageLaboratory.Examine.ExamineStatus != model2.ExamineStatusForOngoing {
return nil, errors.New("操作错误，当前入驻信息已审核")
}
mUserLaboratory := model.NewUserLaboratory()
uids := make([]uint64, 0)
if err = model2.Pluck(mUserLaboratory.UserLaboratory, "uid", &uids, model2.NewWhere("laboratory_id", id),
model2.NewWhere("invalid_status", model2.InvalidStatusForNot)); err != nil {
return nil, err
}
return &ExamineManageInfo{IModel: mManageLaboratory.ManageLaboratory, UIDs: uids}, nil
}
func examineAgent(id uint64) (*ExamineManageInfo, error) {
mManageAgent := model.NewManageAgent()
err := checkManage(mManageAgent.ManageAgent, id)
if err != nil {
return nil, err
} else if mManageAgent.Examine.ExamineStatus != model2.ExamineStatusForOngoing {
return nil, errors.New("操作错误，当前入驻信息已审核")
}
mUserAgent := model.NewUserAgent()
uids := make([]uint64, 0)
if err = model2.Pluck(mUserAgent.UserAgent, "uid", &uids, model2.NewWhere("laboratory_id", id),
model2.NewWhere("invalid_status", model2.InvalidStatusForNot)); err != nil {
return nil, err
}
return &ExamineManageInfo{IModel: mManageAgent.ManageAgent, UIDs: uids}, nil
}
// Launch 发起审核
func (c *Examine) Launch(id uint64, identity, status int) error {
_status := model2.ExamineStatusKind(status)
if _status != model2.ExamineStatusForRefuse && _status != model2.ExamineStatusForAgree {
return errors.New("未知的审核模式")
}
handle, has := examineHandle[identity]
if !has {
return errors.New("未知的身份信息")
}
data, err := handle(id)
if err != nil {
return err
}
return orm.GetDB().Transaction(func(tx *gorm.DB) error {
if err = model2.Updates(data.IModel, map[string]interface{}{
"examine_status": status, "updated_at": time.Now(),
}, tx); err != nil {
return err
}
// 拒绝后，不执行以下数据
if _status == model2.ExamineStatusForRefuse {
return nil
}
mUserInstance := model.NewUserInstance()
users := make([]*model2.UserInstance, 0)
if err = model2.ScanFields(mUserInstance.UserInstance, &users, []string{"id", "uuid", "identity"},
&model2.ModelWhereOrder{
Where: model2.NewWhereIn("uuid", data.UIDs),
}); err != nil {
return err
}
mUserIdentity := model.NewUserIdentity()
identitys := make([]*model2.UserIdentity, 0)
now := time.Now()
snowflake, _ := utils.NewSnowflake(1)
for _, v := range users {
identitys = append(identitys, &model2.UserIdentity{
UUID: uint64(snowflake.GetID()),
UID: v.UUID,
Identity: identity,
ModelAt: model2.ModelAt{
CreatedAt: now, UpdatedAt: now,
},
})
if err = model2.UpdatesWhere(mUserInstance.UserInstance, map[string]interface{}{
"identity": mUserInstance.Identity | identity, "updated_at": now,
}, []*model2.ModelWhere{
model2.NewWhere("id", v.ID),
}, tx); err != nil {
return err
}
}
if len(identitys) > 0 {
if err = model2.Creates(mUserIdentity.UserIdentity, identity, tx); err != nil {
return err
}
}
return nil
})
}
func NewExamine() ExamineHandle {
return func(session *service.Session, local string) *Examine {
return &Examine{
Session: session,
local: local,
}
}
}

96
app/api/admin/controller/manage/instance.go Normal file
View File

@ -0,0 +1,96 @@
package manage
import (
"SciencesServer/app/api/admin/controller"
"SciencesServer/app/api/admin/model"
"SciencesServer/app/basic/config"
model2 "SciencesServer/app/common/model"
"SciencesServer/app/service"
"gorm.io/gorm"
"strings"
"time"
)
type Instance struct {
*service.Session
gorm.Model
local string
}
type InstanceHandle func(session *service.Session, local string) *Instance
type (
// InstanceForExpert 专家信息
InstanceForExpert struct {
ID string `json:"id"`
Name string `json:"name"`
Industry []string `json:"industry"`
ResearchName string `json:"research_name"`
LaboratoryName string `json:"laboratory_name"`
Address string `json:"address"`
CreatedAt time.Time `json:"created_at"`
}
)
func (c *Instance) Company(name string, status int, page, pageSize int) {
mManageCompany := model.NewManageCompany()
where := make([]*model2.ModelWhere, 0)
if name != "" {
where = append(where, model2.NewWhereLike("name", name))
}
var count int64
mManageCompany.Companys(page, pageSize, &count)
}
// Expert 专家信息
func (c *Instance) Expert(name string, status int, page, pageSize int) (*controller.ReturnPages, error) {
mManageExpert := model.NewManageExpert()
where := make([]*model2.ModelWhere, 0)
if name != "" {
where = append(where, model2.NewWhereLike("name", name))
}
var count int64
out, err := mManageExpert.Experts(page, pageSize, &count, where...)
if err != nil {
return nil, err
}
list := make([]*InstanceForExpert, 0)
for _, v := range out {
industry := make([]string, 0)
for _, v := range strings.Split(v.Industry, ";") {
industry = append(industry, config.GetIndustryInfo(v, "-"))
}
// 研究机构，实验室
researchName := v.LaboratoryName
laboratoryName := ""
if v.LaboratoryName != "" {
researchName = v.ResearchName
laboratoryName = v.LaboratoryName
}
list = append(list, &InstanceForExpert{ID: v.GetEncodeID(), Name: v.Name, Industry: industry,
ResearchName: researchName, LaboratoryName: laboratoryName,
Address: v.FormatBasic(), CreatedAt: v.CreatedAt,
})
}
return &controller.ReturnPages{Data: list, Count: count}, nil
}
func NewInstance() InstanceHandle {
return func(session *service.Session, local string) *Instance {
return &Instance{
Session: session,
local: local,
}
}
}

97
app/api/admin/controller/menu/base.go Normal file
View File

@ -0,0 +1,97 @@
package menu
import (
"SciencesServer/app/api/admin/model"
model2 "SciencesServer/app/common/model"
)
type (
Tree struct {
*model2.SysMenu
Children []*Tree `json:"children"`
}
TreeChecked struct {
*model2.SysMenuBasic
Checked bool `json:"checked"`
Children []*TreeChecked `json:"children"`
}
)
// tree 树状筛选
func tree(src []*model2.SysMenu, parentID uint64) []*Tree {
out := make([]*Tree, 0)
for _, v := range src {
if v.ParentID == parentID {
out = append(out, &Tree{
SysMenu: v,
Children: tree(src, v.ID),
})
}
}
return out
}
// TreeCheckedFunc 树状筛选
func TreeCheckedFunc(src []*model.SysMenuScene, parentID uint64) []*TreeChecked {
out := make([]*TreeChecked, 0)
for _, v := range src {
if v.ParentID == parentID {
out = append(out, &TreeChecked{
SysMenuBasic: v.SysMenuBasic,
Checked: v.SceneID > 0,
Children: TreeCheckedFunc(src, v.ID),
})
}
}
return out
}
// menuForSystem 系统管理员菜单
func menuForSystem(iModel model2.IModel, where ...*model2.ModelWhere) ([]*Tree, error) {
out, err := iModel.(*model.SysMenu).SystemMenu(where...)
if err != nil {
return nil, err
}
return tree(out, 0), nil
}
// MenuForSystem 系统管理员菜单
func MenuForSystem(iModel model2.IModel, where ...*model2.ModelWhere) ([]*Tree, error) {
out, err := iModel.(*model.SysMenu).SystemMenu(where...)
if err != nil {
return nil, err
}
return tree(out, 0), nil
}
// MenuForTenant 租户人员菜单
func MenuForTenant(iModel model2.IModel, tenantID uint64) ([]*TreeChecked, error) {
out, err := iModel.(*model.SysMenu).TenantMenu(tenantID)
if err != nil {
return nil, err
}
return TreeCheckedFunc(out, 0), nil
}
func MenuForRole(iModel model2.IModel, tenantID uint64, roleID uint64) ([]*TreeChecked, error) {
out, err := iModel.(*model.SysMenu).RoleMenu(tenantID, roleID)
if err != nil {
return nil, err
}
return TreeCheckedFunc(out, 0), nil
}
// MenuForUser 当前用户菜单
func MenuForUser(iModel model2.IModel, tenantID uint64, uid uint64) ([]*TreeChecked, error) {
out, err := iModel.(*model.SysMenu).UserMenu(tenantID, uid)
if err != nil {
return nil, err
}
return TreeCheckedFunc(out, 0), nil
}

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

@ -0,0 +1,113 @@
package menu
import (
"SciencesServer/app/api/admin/controller"
"SciencesServer/app/api/admin/model"
model2 "SciencesServer/app/common/model"
"SciencesServer/app/service"
"errors"
"time"
)
// Instance 菜单管理
type Instance struct{ *controller.Platform }
type InstanceHandle func(session *service.Session) *Instance
type (
// InstanceParams 菜单参数
InstanceParams struct {
ID, ParentID uint64
Kind, Auth int
Name, Link, Component, Icon string
Sort, Status int
Remark string
}
)
// List 列表信息
func (c *Instance) List() ([]*Tree, error) {
mSysMenu := model.NewSysMenu()
auth := []model2.SysMenuAuth{model2.SysMenuAuthForOrdinary}
if c.IsAdmin {
auth = append(auth, model2.SysMenuAuthForSystem)
}
return menuForSystem(mSysMenu, model2.NewWhereIn("auth", auth))
}
// Form 数据操作
func (c *Instance) Form(params *InstanceParams) error {
if params.ID <= 0 {
return model2.Create(&model2.SysMenu{
SysMenuBasic: model2.SysMenuBasic{
ParentID: params.ParentID,
Name: params.Name,
Kind: model2.SysMenuKind(params.Kind),
Link: params.Link,
Component: params.Component,
Icon: params.Icon,
},
Auth: model2.SysMenuAuth(params.Auth),
Sort: params.Sort,
Status: model2.SysMenuStatusForNormal,
Remark: params.Remark,
})
}
out := model.NewSysMenu()
out.ID = params.ID
isExist, err := model2.FirstWhere(out.SysMenu)
if err != nil {
return err
} else if !isExist {
return errors.New("菜单信息不存在")
}
out.ParentID = params.ParentID
out.Name = params.Name
out.Kind = model2.SysMenuKind(params.Kind)
out.Link = params.Link
out.Component = params.Component
out.Icon = params.Icon
out.Auth = model2.SysMenuAuth(params.Auth)
out.Sort = params.Sort
out.Status = model2.SysMenuStatus(params.Status)
out.Remark = params.Remark
if err = model2.Save(out); err != nil {
return err
}
return nil
}
// Status 状态操作
func (c *Instance) Status(id uint64, status int) error {
mSysMenu := model.NewSysMenu()
mSysMenu.ID = id
if err := model2.Updates(mSysMenu.SysMenu, map[string]interface{}{
"status": status, "updated_at": time.Now(),
}); err != nil {
return err
}
return nil
}
// Delete 删除操作
func (c *Instance) Delete(id uint64) error {
mSysMenu := model.NewSysMenu()
mSysMenu.ID = id
if err := model2.Delete(mSysMenu.SysMenu); err != nil {
return err
}
return nil
}
func NewInstance() InstanceHandle {
return func(session *service.Session) *Instance {
return &Instance{Platform: &controller.Platform{Session: session}}
}
}

87
app/api/admin/controller/role/auth.go Normal file
View File

@ -0,0 +1,87 @@
package role
import (
"SciencesServer/app/api/admin/controller"
auth2 "SciencesServer/app/api/admin/controller/auth"
model3 "SciencesServer/app/api/admin/model"
model2 "SciencesServer/app/common/model"
"SciencesServer/app/service"
"SciencesServer/serve/orm"
"SciencesServer/utils"
"gorm.io/gorm"
)
type Auth struct{ *controller.Platform }
type AuthHandle func(session *service.Session) *Auth
// List 角色权限列表
func (c *Auth) List(roleID uint64) ([]*auth2.TreeChecked, error) {
mSysAuth := model3.NewSysAuth()
out, err := mSysAuth.RoleAuth(c.TenantID, roleID)
if err != nil {
return nil, err
}
return auth2.TreeCheckedFunc(out, 0), nil
}
// Bind 角色权限绑定
func (c *Auth) Bind(roleID uint64, authIDs []uint64) error {
return orm.GetDB().Transaction(func(tx *gorm.DB) error {
mSysRoleAuth := model3.NewSysRoleAuth()
err := model2.DeleteWhere(mSysRoleAuth.SysRoleAuth, []*model2.ModelWhere{model2.NewWhere("role_id", roleID)}, tx)
if err != nil {
return err
}
// 查询权限信息
mSysAuth := model3.NewSysAuth()
auths := make([]*model2.SysAuth, 0)
if err = model2.Find(mSysAuth.SysAuth, &auths, &model2.ModelWhereOrder{Where: model2.NewWhereIn("id", authIDs)}); err != nil {
return err
}
authRequests := make([]*service.AuthRequest, 0)
roles := make([]*model2.SysRoleAuth, 0)
for _, v := range auths {
roles = append(roles, &model2.SysRoleAuth{
ModelTenant: model2.ModelTenant{TenantID: c.TenantID}, RoleID: roleID, AuthID: v.ID,
})
if v.Auth == "" {
continue
}
authRequests = append(authRequests, &service.AuthRequest{Url: v.Auth, Method: "*"})
}
if err = model2.Creates(mSysRoleAuth.SysRoleAuth, roles, tx); err != nil {
return err
}
go utils.TryCatch(func() {
//permission := service.NewPermission([]string{utils.UintToString(roleID)}, authRequests...)(c.TenantKey, "")
//// 删除角色权限
//if _, err = permission.RemoveRolePolicy(); err != nil {
// logger.ErrorF("删除角色【%d】规则信息错误：%v", roleID, err)
// return
//}
//if len(authRequests) > 0 {
// if _, err = permission.AddPolicies(); err != nil {
// logger.ErrorF("创建角色【%d】规则信息错误：%v", roleID, err)
// return
// }
//}
})
return nil
})
}
func NewAuth() AuthHandle {
return func(session *service.Session) *Auth {
return &Auth{Platform: &controller.Platform{Session: session}}
}
}

173
app/api/admin/controller/role/instance.go Normal file
View File

@ -0,0 +1,173 @@
package role
import (
"SciencesServer/app/api/admin/controller"
"SciencesServer/app/api/admin/model"
model2 "SciencesServer/app/common/model"
"SciencesServer/app/service"
"SciencesServer/utils"
"errors"
"time"
)
type Instance struct{ *controller.Platform }
type InstanceHandle func(session *service.Session) *Instance
type (
// InstanceInfo 角色信息
InstanceInfo struct {
*model2.SysRole
StatusTitle string `json:"status_title"`
}
// InstanceBasicInfo 角色基本信息
InstanceBasicInfo struct {
ID uint64 `json:"id"`
Name string `json:"name"`
}
)
// List 列表信息
func (c *Instance) List(name string, status, page, pageSize int) (*controller.ReturnPages, error) {
mSysRole := model.NewSysRole()
where := []*model2.ModelWhereOrder{
&model2.ModelWhereOrder{
Where: model2.NewWhere("tenant_id", c.TenantID),
Order: model2.NewOrder("sort", model2.OrderModeToDesc),
},
&model2.ModelWhereOrder{
Order: model2.NewOrder("id", model2.OrderModeToDesc),
},
}
if name != "" {
where = append(where, &model2.ModelWhereOrder{
Where: model2.NewWhere("tenant_id", c.TenantID),
})
}
if status > 0 {
where = append(where, &model2.ModelWhereOrder{
Where: model2.NewWhere("status", status),
})
}
var count int64
out := make([]*model2.SysRole, 0)
if err := model2.Pages(mSysRole.SysRole, &out, page, pageSize, &count, where...); err != nil {
return nil, err
}
list := make([]*InstanceInfo, 0)
for _, v := range out {
list = append(list, &InstanceInfo{SysRole: v, StatusTitle: v.StatusTitle()})
}
return &controller.ReturnPages{Data: list, Count: count}, nil
}
// Select 筛选信息
func (c *Instance) Select() ([]*InstanceBasicInfo, error) {
mSysRole := model.NewSysRole()
where := []*model2.ModelWhereOrder{
&model2.ModelWhereOrder{
Where: model2.NewWhere("tenant_id", c.TenantID),
Order: model2.NewOrder("sort", model2.OrderModeToDesc),
},
&model2.ModelWhereOrder{
Where: model2.NewWhere("status", model2.SysRoleStatusForNormal),
Order: model2.NewOrder("id", model2.OrderModeToDesc),
},
}
out := make([]*InstanceBasicInfo, 0)
if err := model2.Scan(mSysRole.SysRole, &out, where...); err != nil {
return nil, err
}
return out, nil
}
// Data 数据操作
func (c *Instance) Data(id uint64, name, remark string, sort int) error {
mSysRole := model.NewSysRole()
if id <= 0 {
mSysRole.TenantID = c.TenantID
mSysRole.Name = name
mSysRole.Remark = remark
mSysRole.Sort = sort
mSysRole.Status = model2.SysRoleStatusForNormal
if err := model2.Create(mSysRole.SysRole); err != nil {
return err
}
return nil
}
mSysRole.ID = id
if err := model2.Updates(mSysRole.SysRole, map[string]interface{}{
"name": name, "remark": remark, "sort": sort,
}); err != nil {
return err
}
return nil
}
// Status 状态操作
func (c *Instance) Status(id uint64, status int) error {
mSysRole := model.NewSysRole()
mSysRole.ID = id
isExist, err := model2.FirstWhere(mSysRole.SysRole)
if err != nil {
return err
} else if !isExist {
return errors.New("角色不存在")
}
if c.TenantID > 0 && c.TenantID != mSysRole.TenantID {
return errors.New("不可操作其他租户角色")
}
if err = model2.Updates(mSysRole.SysRole, map[string]interface{}{
"status": status, "updated_at": time.Now(),
}); err != nil {
return err
}
return nil
}
// Delete 删除操作
func (c *Instance) Delete(id uint64) error {
mSysRole := model.NewSysRole()
mSysRole.ID = id
isExist, err := model2.FirstWhere(mSysRole.SysRole)
if err != nil {
return err
} else if !isExist {
return errors.New("角色不存在")
}
if c.TenantID > 0 && c.TenantID != mSysRole.TenantID {
return errors.New("不可删除其他租户角色")
}
if err = model2.Delete(mSysRole.SysRole); err != nil {
return err
}
go utils.TryCatch(func() {
//permission := service.NewPermission([]string{utils.UintToString(id)})(c.TenantKey, "")
//// 删除角色权限
//if _, err = permission.RemoveRolePolicy(); err != nil {
// logger.ErrorF("删除租户【%s】下角色【%d】权限信息错误：%v", c.TenantKey, id, err)
// return
//}
})
return nil
}
func NewInstance() InstanceHandle {
return func(session *service.Session) *Instance {
return &Instance{Platform: &controller.Platform{Session: session}}
}
}

74
app/api/admin/controller/role/menu.go Normal file
View File

@ -0,0 +1,74 @@
package role
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(roleID uint64) ([]*menu2.TreeChecked, error) {
mSysMenu := model3.NewSysMenu()
return menu2.MenuForRole(mSysMenu, c.TenantID, roleID)
}
// Bind 绑定菜单
func (c *Menu) Bind(roleID 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("不可设置超管菜单")
}
}
mSysRoleMenu := model3.NewSysRoleMenu()
return orm.GetDB().Transaction(func(tx *gorm.DB) error {
err := model2.DeleteWhere(mSysRoleMenu.SysRoleMenu, []*model2.ModelWhere{model2.NewWhere("role_id", roleID)}, tx)
if err != nil {
return err
}
if len(menuIDs) <= 0 {
return nil
}
menus := make([]*model2.SysRoleMenu, 0)
mark := make(map[uint64]uint64, 0)
for _, v := range menuIDs {
if _, has := mark[v]; has {
continue
}
menus = append(menus, &model2.SysRoleMenu{
ModelTenant: model2.ModelTenant{TenantID: c.TenantID}, RoleID: roleID, MenuID: v,
})
mark[v] = v
}
if err = model2.Creates(mSysRoleMenu.SysRoleMenu, menus, tx); err != nil {
return err
}
return nil
})
}
func NewMenu() MenuHandle {
return func(session *service.Session) *Menu {
return &Menu{Platform: &controller.Platform{Session: session}}
}
}

79
app/api/admin/controller/role/user.go Normal file
View File

@ -0,0 +1,79 @@
package role
import (
"SciencesServer/app/api/admin/controller"
model3 "SciencesServer/app/api/admin/model"
model2 "SciencesServer/app/common/model"
"SciencesServer/app/service"
"SciencesServer/serve/orm"
"SciencesServer/utils"
"gorm.io/gorm"
)
type User struct{ *controller.Platform }
type UserHandle func(session *service.Session) *User
// List 列表信息
func (c *User) List(uid uint64) ([]*model3.SysRoleUserInfo, error) {
mSysRole := model3.NewSysRole()
out, err := mSysRole.UserRole(uid)
if err != nil {
return nil, err
}
return out, nil
}
// Bind 绑定角色
func (c *User) Bind(uid uint64, roleIDs []uint64) error {
mSysUserRole := model3.NewSysUserRole()
return orm.GetDB().Transaction(func(tx *gorm.DB) error {
err := model2.DeleteWhere(mSysUserRole.SysUserRole, []*model2.ModelWhere{model2.NewWhere("uid", uid)}, tx)
if err != nil {
return err
}
roles := make([]*model2.SysUserRole, 0)
obj := make([]string, 0)
mark := make(map[uint64]uint64, 0)
for _, v := range roleIDs {
if _, has := mark[v]; has {
continue
}
obj = append(obj, utils.UintToString(v))
roles = append(roles, &model2.SysUserRole{
UID: uid, RoleID: v,
})
mark[v] = v
}
if err = model2.Creates(mSysUserRole.SysUserRole, roles, tx); err != nil {
return err
}
go utils.TryCatch(func() {
//permission := service.NewPermission(obj)(c.TenantKey, utils.UintToString(uid))
//
//if _, err = permission.DeleteRolesForUser(false); err != nil {
// logger.ErrorF("删除用户【%d】角色权限错误：%v", uid, err)
// return
//}
//if _, err = permission.AddRoleForUser(); err != nil {
// logger.ErrorF("添加用户【%d】角色权限错误：%v", uid, err)
// return
//}
})
return nil
})
}
func NewUser() UserHandle {
return func(session *service.Session) *User {
return &User{Platform: &controller.Platform{Session: session}}
}
}

1
app/api/admin/controller/tenant.go
View File

@ -1 +0,0 @@
package controller

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
}

249
app/api/admin/controller/user/instance.go Normal file
View File

@ -0,0 +1,249 @@
package user
import (
"SciencesServer/app/api/admin/controller"
model3 "SciencesServer/app/api/admin/model"
model2 "SciencesServer/app/common/model"
"SciencesServer/app/service"
"SciencesServer/serve/orm"
"SciencesServer/utils"
"errors"
"strings"
"time"
"gorm.io/gorm"
)
type Instance struct{ *controller.Platform }
type InstanceHandle func(session *service.Session) *Instance
type (
// InstanceInfo 基本信息
InstanceInfo struct {
UID string `json:"uid"`
Name string `json:"name"`
Email string `json:"email"`
Mobile string `json:"mobile"`
Remark string `json:"remark"`
}
// InstanceUserInfo 用户信息
InstanceUserInfo struct {
*model3.SysUserTenantUser
UID string `json:"uid"`
}
)
// InstanceForm 表单信息
type InstanceForm struct {
ID uint64 // 租户用户主键ID
Account, Name, Mobile, Password, Remark string
Gender int
Departments, Roles []uint64
}
// Info 用户信息
func (c *Instance) Info() (*InstanceInfo, error) {
mSysUser := model3.NewSysUser()
_, err := model2.FirstWhere(mSysUser.SysUser, model2.NewWhere("uuid", c.UID))
if err != nil {
return nil, err
}
return &InstanceInfo{
UID: mSysUser.UUIDString(), Name: mSysUser.Name, Email: mSysUser.Email, Mobile: mSysUser.Mobile, Remark: mSysUser.Remark,
}, nil
}
// List 列表信息
func (c *Instance) List(name, mobile string, status, page, pageSize int) (*controller.ReturnPages, error) {
mSysUserTenant := model3.NewSysUserTenant()
where := []*model2.ModelWhere{model2.NewWhere("u_t.tenant_id", c.TenantID)}
if name != "" {
where = append(where, model2.NewWhereLike("u.name", name))
}
if mobile != "" {
where = append(where, model2.NewWhereLike("u.mobile", mobile))
}
if status > 0 {
where = append(where, model2.NewWhere("u_t.status", status))
}
var count int64
out, err := mSysUserTenant.User(page, pageSize, &count, where...)
if err != nil {
return nil, err
}
list := make([]*InstanceUserInfo, 0)
for _, v := range out {
list = append(list, &InstanceUserInfo{SysUserTenantUser: v, UID: utils.UintToString(v.UID)})
}
return &controller.ReturnPages{Data: list, Count: count}, nil
}
// Add 添加用户
func (c *Instance) Add(params *InstanceForm) error {
if utils.ValidateMobile(params.Mobile) {
return errors.New("手机号码格式错误")
}
mSysUser := model3.NewSysUser()
// 查询登录账户或手机号码是否注册
var count int64
err := model2.Count(mSysUser.SysUser, &count, model2.NewWhere("account", params.Account))
if err != nil {
return err
}
if err = model2.Count(mSysUser.SysUser, &count, model2.NewWhere("mobile", params.Mobile)); err != nil {
return err
}
mSysUser.Account = params.Account
mSysUser.Name = params.Name
mSysUser.Mobile = params.Mobile
mSysUser.Gender.Gender = model2.GenderKind(params.Gender)
mSysUser.Password = params.Password
mSysUser.Remark = params.Remark
return orm.GetDB().Transaction(func(tx *gorm.DB) error {
if err = model2.Create(mSysUser.SysUser, tx); err != nil {
return err
}
mSysUserTenant := model3.NewSysUserTenant()
mSysUserTenant.TenantID = c.TenantID
mSysUserTenant.UID = mSysUser.UUID
if len(params.Departments) > 0 {
mSysUserTenant.Department = strings.Join(utils.ArrayStrings(params.Departments), ",")
}
if len(params.Roles) > 0 {
mSysUserTenant.Role = strings.Join(utils.ArrayStrings(params.Roles), ",")
}
mSysUserTenant.Identity = model2.SysUserTenantIdentityForSystemUser
if err = model2.Create(mSysUserTenant.SysUserTenant, tx); err != nil {
return err
}
return nil
})
}
// Edit 修改用户信息
func (c *Instance) Edit(params *InstanceForm) error {
if utils.ValidateMobile(params.Mobile) {
return errors.New("手机号码格式错误")
}
mSysUserTenant := model3.NewSysUserTenant()
mSysUserTenant.ID = params.ID
isExist, err := model2.FirstField(mSysUserTenant.SysUserTenant, []string{"id", "tenant_id", "identity"})
if err != nil {
return nil
} else if !isExist {
return errors.New("用户信息不存在")
} else if mSysUserTenant.TenantID != c.TenantID {
return errors.New("不可修改他人用户信息")
}
// 查询用户信息
mSysUser := model3.NewSysUser()
if isExist, err = model2.FirstWhere(mSysUser.SysUser, model2.NewWhere("uuid", mSysUserTenant.UID)); err != nil {
return err
} else if !isExist {
return errors.New("用户信息不存在")
}
if params.Mobile != mSysUser.Mobile {
var count int64
if err = model2.Count(mSysUser.SysUser, &count, model2.NewWhere("mobile", params.Mobile)); err != nil {
return err
} else if count > 0 {
return errors.New("该手机号码已注册")
}
}
now := time.Now()
return orm.GetDB().Transaction(func(tx *gorm.DB) error {
if err = model2.Updates(mSysUserTenant.SysUserTenant, map[string]interface{}{
"department": strings.Join(utils.ArrayStrings(params.Departments), ","),
"role": strings.Join(utils.ArrayStrings(params.Roles), ","),
"updated_at": now,
}, tx); err != nil {
return err
}
if err = model2.Updates(mSysUser.SysUser, map[string]interface{}{
"name": params.Name, "mobile": params.Mobile, "gender": params.Gender, "remark": params.Remark, "updated_at": now,
}, tx); err != nil {
return err
}
return nil
})
}
func (c *Instance) Password(id uint64, password, repeatPwd string) error {
if password != repeatPwd {
return errors.New("两次密码不一致")
}
mSysUserTenant := model3.NewSysUserTenant()
mSysUserTenant.ID = id
isExist, err := model2.FirstField(mSysUserTenant.SysUserTenant, []string{"id", "tenant_id", "identity"})
if err != nil {
return nil
} else if !isExist {
return errors.New("用户信息不存在")
} else if mSysUserTenant.TenantID != c.TenantID {
return errors.New("不可修改他人用户密码")
}
mSysUser := model3.NewSysUser()
mSysUser.Password = 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
}
func (c *Instance) Delete(id uint64) error {
mSysUserTenant := model3.NewSysUserTenant()
mSysUserTenant.ID = id
isExist, err := model2.FirstField(mSysUserTenant.SysUserTenant, []string{"id", "tenant_id", "identity"})
if err != nil {
return nil
} else if !isExist {
return errors.New("用户信息不存在")
} else if mSysUserTenant.TenantID != c.TenantID {
return errors.New("不可删除他人用户信息")
}
return orm.GetDB().Transaction(func(tx *gorm.DB) error {
if err = model2.Delete(mSysUserTenant.SysUserTenant, tx); err != nil {
return err
}
mSysUser := model3.NewSysUser()
if err = model2.DeleteWhere(mSysUser.SysUser, []*model2.ModelWhere{
model2.NewWhere("uuid", mSysUserTenant.UID),
}, tx); err != nil {
return err
}
return nil
})
}
func NewInstance() InstanceHandle {
return func(session *service.Session) *Instance {
return &Instance{Platform: &controller.Platform{Session: session}}
}
}

40
app/api/admin/controller/user/menu.go Normal file
View File

@ -0,0 +1,40 @@
package user
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"
)
type Menu struct{ *controller.Platform }
type MenuHandle func(session *service.Session) *Menu
// List 菜单列表
func (c *Menu) List() (interface{}, error) {
mSysMenu := model3.NewSysMenu()
if c.IsAdmin {
return menu2.MenuForSystem(mSysMenu)
}
mSysUserTenant := model3.NewSysUserTenant()
if isExist, err := model2.FirstField(mSysUserTenant.SysUserTenant, []string{"id", "identity"},
model2.NewWhere("tenant_id", c.TenantID), model2.NewWhere("uid", c.UID)); err != nil {
return nil, err
} else if !isExist {
return nil, nil
}
if mSysUserTenant.Identity == model2.SysUserTenantIdentityForSystemAdmin {
return menu2.MenuForTenant(mSysMenu, c.TenantID)
}
return menu2.MenuForUser(mSysMenu, c.TenantID, c.UID)
}
func NewMenu() MenuHandle {
return func(session *service.Session) *Menu {
return &Menu{Platform: &controller.Platform{Session: session}}
}
}

47
app/api/admin/controller/user/person.go Normal file
View File

@ -0,0 +1,47 @@
package user
import (
"SciencesServer/app/api/admin/model"
model2 "SciencesServer/app/common/model"
"SciencesServer/app/service"
"errors"
"time"
)
type Person struct{ *service.Session }
type PersonHandle func(session *service.Session) *Person
// EditPassword 修改密码
func (c *Person) EditPassword(oldPassword, password, repeatPwd string) error {
if password != repeatPwd {
return errors.New("两次密码不一致")
}
mSysUser := model.NewSysUser()
isExist, err := model2.FirstWhere(mSysUser.SysUser, model2.NewWhere("uuid", c.UID))
if err != nil {
return err
} else if !isExist {
return errors.New("用户信息不存在或已被删除")
}
if !mSysUser.ValidatePassword(oldPassword) {
return errors.New("旧密码错误")
}
mSysUser.Password = password
mSysUser.Pass()
if err = model2.Updates(mSysUser.SysUser, map[string]interface{}{
"password": mSysUser.Password, "salt": mSysUser.Salt, "updated_at": time.Now(),
}); err != nil {
return err
}
return nil
}
func NewPerson() PersonHandle {
return func(session *service.Session) *Person {
return &Person{Session: session}
}
}

79
app/api/admin/controller/user/role.go Normal file
View File

@ -0,0 +1,79 @@
package user
import (
"SciencesServer/app/api/admin/controller"
model3 "SciencesServer/app/api/admin/model"
model2 "SciencesServer/app/common/model"
"SciencesServer/app/service"
"SciencesServer/serve/orm"
"SciencesServer/utils"
"gorm.io/gorm"
)
type Role struct{ *controller.Platform }
type RoleHandle func(session *service.Session) *Role
// List 列表信息
func (c *Role) List(uid uint64) ([]*model3.SysRoleUserInfo, error) {
mSysRole := model3.NewSysRole()
out, err := mSysRole.UserRole(uid)
if err != nil {
return nil, err
}
return out, nil
}
// Bind 绑定角色
func (c *Role) Bind(uid uint64, roleIDs []uint64) error {
mSysUserRole := model3.NewSysUserRole()
return orm.GetDB().Transaction(func(tx *gorm.DB) error {
err := model2.DeleteWhere(mSysUserRole.SysUserRole, []*model2.ModelWhere{model2.NewWhere("uid", uid)}, tx)
if err != nil {
return err
}
roles := make([]*model2.SysUserRole, 0)
obj := make([]string, 0)
mark := make(map[uint64]uint64, 0)
for _, v := range roleIDs {
if _, has := mark[v]; has {
continue
}
obj = append(obj, utils.UintToString(v))
roles = append(roles, &model2.SysUserRole{
UID: uid, RoleID: v,
})
mark[v] = v
}
if err = model2.Creates(mSysUserRole.SysUserRole, roles, tx); err != nil {
return err
}
go utils.TryCatch(func() {
//permission := service.NewPermission(obj)(c.TenantKey, utils.UintToString(uid))
//
//if _, err = permission.DeleteRolesForUser(false); err != nil {
// logger.ErrorF("删除用户【%d】角色权限错误：%v", uid, err)
// return
//}
//if _, err = permission.AddRoleForUser(); err != nil {
// logger.ErrorF("添加用户【%d】角色权限错误：%v", uid, err)
// return
//}
})
return nil
})
}
func NewRole() RoleHandle {
return func(session *service.Session) *Role {
return &Role{Platform: &controller.Platform{Session: session}}
}
}