fusen/fusenapi
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'develop' of gitee.com:fusenpack/fusenapi into develop

Browse Source
This commit is contained in:
laodaming 2023-11-22 11:31:46 +08:00
commit b46b707586
20 changed files with 232 additions and 265 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
model/gmodel/ldap_casbin_rule_gen.go
View File

@ -1,24 +0,0 @@
package gmodel
import (
"gorm.io/gorm"
)
// ldap_casbin_rule 权限表
type LdapCasbinRule struct {
Id int64 `gorm:"primary_key;default:0;auto_increment;" json:"id"` //
V0 *string `gorm:"default:'';" json:"v0"` //
V1 *string `gorm:"default:'';" json:"v1"` //
V2 *string `gorm:"default:'';" json:"v2"` //
V3 *string `gorm:"default:'';" json:"v3"` //
V4 *string `gorm:"default:'';" json:"v4"` //
V5 *string `gorm:"default:'';" json:"v5"` //
}
type LdapCasbinRuleModel struct {
db *gorm.DB
name string
}
func NewLdapCasbinRuleModel(db *gorm.DB) *LdapCasbinRuleModel {
return &LdapCasbinRuleModel{db: db, name: "ldap_casbin_rule"}
}

2
model/gmodel/ldap_casbin_rule_logic.go
View File

@ -1,2 +0,0 @@
package gmodel
// TODO: 使用model的属性做你想做的

17
model/gmodel/ldap_group_gen.go
View File

@ -7,14 +7,15 @@ import (
// ldap_group 权限组表
type LdapGroup struct {
Id int64 `gorm:"primary_key;default:0;auto_increment;" json:"id"` //
Name *string `gorm:"default:'';" json:"name"` //
Keyword *string `gorm:"default:'';" json:"keyword"` //
Remark *string `gorm:"default:'';" json:"remark"` //
Status *int64 `gorm:"default:1;" json:"status"` // 1正常, 2禁用
Sort *int64 `gorm:"default:999;" json:"sort"` // 分组排序(排序越大权限越低, 不能查看比自己序号小的角色, 不能编辑同序号用户权限, 排序为1表示超级管理员)
Ctime *time.Time `gorm:"default:'0000-00-00 00:00:00';" json:"ctime"` //
Utime *time.Time `gorm:"default:'0000-00-00 00:00:00';" json:"utime"` //
Id int64 `gorm:"primary_key;default:0;auto_increment;" json:"id"` //
Name *string `gorm:"default:'';" json:"name"` //
Keyword *string `gorm:"default:'';" json:"keyword"` //
Remark *string `gorm:"default:'';" json:"remark"` //
Status *int64 `gorm:"default:1;" json:"status"` // 1正常, 2禁用
Sort *int64 `gorm:"default:999;" json:"sort"` // 分组排序(排序越大权限越低, 不能查看比自己序号小的角色, 不能编辑同序号用户权限, 排序为1表示超级管理员)
Metadata *[]byte `gorm:"default:'';" json:"metadata"` //
Ctime *time.Time `gorm:"default:'0000-00-00 00:00:00';" json:"ctime"` //
Utime *time.Time `gorm:"default:'0000-00-00 00:00:00';" json:"utime"` //
}
type LdapGroupModel struct {
db *gorm.DB

19
model/gmodel/ldap_group_menus_gen.go
View File

@ -1,19 +0,0 @@
package gmodel
import (
"gorm.io/gorm"
)
// ldap_group_menus 权限分组菜单表
type LdapGroupMenus struct {
MenuId *int64 `gorm:"default:0;" json:"menu_id"` //
GroupId *int64 `gorm:"default:0;" json:"group_id"` //
}
type LdapGroupMenusModel struct {
db *gorm.DB
name string
}
func NewLdapGroupMenusModel(db *gorm.DB) *LdapGroupMenusModel {
return &LdapGroupMenusModel{db: db, name: "ldap_group_menus"}
}

23
model/gmodel/ldap_group_menus_logic.go
View File

@ -1,23 +0,0 @@
package gmodel
import "context"
func (gm *LdapGroupMenusModel) FindOne(ctx context.Context, menuId, groupId int64) (resp *LdapGroupMenus, err error) {
err = gm.db.WithContext(ctx).Model(&LdapGroupMenus{}).Where("menu_id = ? and group_id = ?", menuId, groupId).Take(&resp).Error
return resp, err
}
func (gm *LdapGroupMenusModel) Create(ctx context.Context, data *LdapGroupMenus) error {
return gm.db.WithContext(ctx).Model(&LdapGroupMenus{}).Create(&data).Error
}
func (gm *LdapGroupMenusModel) Delete(ctx context.Context, menuId, groupId int64) error {
return gm.db.WithContext(ctx).Model(&LdapGroupMenus{}).Where("menu_id = ? and group_id", menuId, groupId).Delete(&LdapGroupMenus{}).Error
}
func (gm *LdapGroupMenusModel) DeleteByMenuId(ctx context.Context, menuId int64) error {
return gm.db.WithContext(ctx).Model(&LdapGroupMenus{}).Where("menu_id = ?", menuId).Delete(&LdapGroupMenus{}).Error
}
func (gm *LdapGroupMenusModel) DeleteByGroupId(ctx context.Context, groupId int64) error {
return gm.db.WithContext(ctx).Model(&LdapGroupMenus{}).Where("group_id = ?", groupId).Delete(&LdapGroupMenus{}).Error
}

4
model/gmodel/var_gen.go
View File

@ -110,9 +110,7 @@ type AllModelsGen struct {
FsWebSet *FsWebSetModel // fs_web_set 网站配置表
FsZipCode *FsZipCodeModel // fs_zip_code 邮编表
LdapApis *LdapApisModel // ldap_apis api表
LdapCasbinRule *LdapCasbinRuleModel // ldap_casbin_rule 权限表
LdapGroup *LdapGroupModel // ldap_group 权限组表
LdapGroupMenus *LdapGroupMenusModel // ldap_group_menus 权限分组菜单表
LdapMenus *LdapMenusModel // ldap_menus 菜单表
LdapUser *LdapUserModel // ldap_user ldap_用户id递增表
LdapUserGroup *LdapUserGroupModel // ldap_user_group 用户权限分组表
@ -227,9 +225,7 @@ func NewAllModels(gdb *gorm.DB) *AllModelsGen {
FsWebSet: NewFsWebSetModel(gdb),
FsZipCode: NewFsZipCodeModel(gdb),
LdapApis: NewLdapApisModel(gdb),
LdapCasbinRule: NewLdapCasbinRuleModel(gdb),
LdapGroup: NewLdapGroupModel(gdb),
LdapGroupMenus: NewLdapGroupMenusModel(gdb),
LdapMenus: NewLdapMenusModel(gdb),
LdapUser: NewLdapUserModel(gdb),
LdapUserGroup: NewLdapUserGroupModel(gdb),

8
server/ldap-admin/internal/handler/setldapgroupmenushandler.go → server/ldap-admin/internal/handler/getldapgroupdetailhandler.go
View File

@ -11,22 +11,22 @@ import (
"fusenapi/server/ldap-admin/internal/types"
)
func SetLdapGroupMenusHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
func GetLdapGroupDetailHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.SetLdapGroupMenusReq
var req types.GetLdapGroupDetailReq
userinfo, err := basic.RequestParse(w, r, svcCtx, &req)
if err != nil {
return
}
// 创建一个业务逻辑层实例
l := logic.NewSetLdapGroupMenusLogic(r.Context(), svcCtx)
l := logic.NewGetLdapGroupDetailLogic(r.Context(), svcCtx)
rl := reflect.ValueOf(l)
basic.BeforeLogic(w, r, rl)
resp := l.SetLdapGroupMenus(&req, userinfo)
resp := l.GetLdapGroupDetail(&req, userinfo)
if !basic.AfterLogic(w, r, rl, resp) {
basic.NormalAfterLogic(w, r, resp)

14
server/ldap-admin/internal/handler/routes.go
View File

@ -17,6 +17,11 @@ func RegisterHandlers(server *rest.Server, serverCtx *svc.ServiceContext) {
Path: "/api/ldap-admin/get_ldap_group",
Handler: GetLdapGroupsHandler(serverCtx),
},
{
Method: http.MethodGet,
Path: "/api/ldap-admin/get_ldap_group_detail",
Handler: GetLdapGroupDetailHandler(serverCtx),
},
{
Method: http.MethodPost,
Path: "/api/ldap-admin/save_ldap_group",
@ -29,13 +34,8 @@ func RegisterHandlers(server *rest.Server, serverCtx *svc.ServiceContext) {
},
{
Method: http.MethodPost,
Path: "/api/ldap-admin/set_ldap_group_menus",
Handler: SetLdapGroupMenusHandler(serverCtx),
},
{
Method: http.MethodPost,
Path: "/api/ldap-admin/set_ldap_casbin_rule",
Handler: SetLdapCasbinRuleHandler(serverCtx),
Path: "/api/ldap-admin/set_ldap_group_auth",
Handler: SetLdapGroupAuthHandler(serverCtx),
},
{
Method: http.MethodPost,

8
server/ldap-admin/internal/handler/setldapcasbinrulehandler.go → server/ldap-admin/internal/handler/setldapgroupauthhandler.go
View File

@ -11,22 +11,22 @@ import (
"fusenapi/server/ldap-admin/internal/types"
)
func SetLdapCasbinRuleHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
func SetLdapGroupAuthHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.SetLdapCasbinRuleReq
var req types.SetLdapGroupAuthReq
userinfo, err := basic.RequestParse(w, r, svcCtx, &req)
if err != nil {
return
}
// 创建一个业务逻辑层实例
l := logic.NewSetLdapCasbinRuleLogic(r.Context(), svcCtx)
l := logic.NewSetLdapGroupAuthLogic(r.Context(), svcCtx)
rl := reflect.ValueOf(l)
basic.BeforeLogic(w, r, rl)
resp := l.SetLdapCasbinRule(&req, userinfo)
resp := l.SetLdapGroupAuth(&req, userinfo)
if !basic.AfterLogic(w, r, rl, resp) {
basic.NormalAfterLogic(w, r, resp)

4
server/ldap-admin/internal/logic/deleteapilogic.go
View File

@ -50,10 +50,6 @@ func (l *DeleteApiLogic) DeleteApi(req *types.DeleteApiReq, userinfo *auth.UserI
if resLdapApiDel.Error != nil {
return resLdapApiDel.Error
}
resLdapCasbinRulesDel := tx.Where("v3 IN ?", req.Ids).Delete(&gmodel.LdapCasbinRule{})
if resLdapCasbinRulesDel.Error != nil {
return resLdapCasbinRulesDel.Error
}
return nil
})
if txErr != nil {

8
server/ldap-admin/internal/logic/deleteldapgrouplogic.go
View File

@ -55,14 +55,6 @@ func (l *DeleteLdapGroupLogic) DeleteLdapGroup(req *types.DeleteLdapGroupReq, us
if resLdapUserGroupDel.Error != nil {
return resLdapUserGroupDel.Error
}
resLdapGroupMenusDel := tx.Where("group_id IN ?", req.Ids).Delete(&gmodel.LdapGroupMenus{})
if resLdapGroupMenusDel.Error != nil {
return resLdapGroupMenusDel.Error
}
resLdapCasbinRulesDel := tx.Where("v0 IN ?", req.Ids).Delete(&gmodel.LdapCasbinRule{})
if resLdapCasbinRulesDel.Error != nil {
return resLdapCasbinRulesDel.Error
}
return nil
})
if txErr != nil {

7
server/ldap-admin/internal/logic/deletemenulogic.go
View File

@ -4,9 +4,10 @@ import (
"fusenapi/model/gmodel"
"fusenapi/utils/auth"
"fusenapi/utils/basic"
"gorm.io/gorm"
"time"
"gorm.io/gorm"
"context"
"fusenapi/server/ldap-admin/internal/svc"
@ -48,9 +49,7 @@ func (l *DeleteMenuLogic) DeleteMenu(req *types.DeleteMenuReq, userinfo *auth.Us
if err != nil {
return err
}
//删除分组绑定的菜单
groupMenusModel := gmodel.NewLdapGroupMenusModel(tx)
return groupMenusModel.DeleteByMenuId(l.ctx, req.Id)
return nil
})
if err != nil {
logx.Error(err)

70
server/ldap-admin/internal/logic/getldapgroupdetaillogic.go Normal file
View File

@ -0,0 +1,70 @@
package logic
import (
"encoding/json"
"errors"
"fusenapi/utils/auth"
"fusenapi/utils/basic"
"context"
"fusenapi/server/ldap-admin/internal/svc"
"fusenapi/server/ldap-admin/internal/types"
"github.com/zeromicro/go-zero/core/logx"
"gorm.io/gorm"
)
type GetLdapGroupDetailLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewGetLdapGroupDetailLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetLdapGroupDetailLogic {
return &GetLdapGroupDetailLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
// 处理进入前逻辑w,r
// func (l *GetLdapGroupDetailLogic) BeforeLogic(w http.ResponseWriter, r *http.Request) {
// }
func (l *GetLdapGroupDetailLogic) GetLdapGroupDetail(req *types.GetLdapGroupDetailReq, userinfo *auth.UserInfo) (resp *basic.Response) {
// 返回值必须调用Set重新返回, resp可以空指针调用 resp.SetStatus(basic.CodeOK, data)
// userinfo 传入值时, 一定不为null
resOne, err := l.svcCtx.AllModels.LdapGroup.FindOneById(l.ctx, req.Id)
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
basic.CodeServiceErr.Message = "记录不存在"
} else {
basic.CodeServiceErr.Message = "系统出错"
}
return resp.SetStatus(basic.CodeServiceErr)
}
var metadata []types.GroupAuth
if resOne.Metadata != nil {
err := json.Unmarshal(*resOne.Metadata, &metadata)
if err != nil {
basic.CodeServiceErr.Message = "系统出错"
return resp.SetStatus(basic.CodeServiceErr)
}
}
return resp.SetStatus(basic.CodeOK, map[string]interface{}{
"id": resOne.Id,
"name": resOne.Name,
"keyword": resOne.Keyword,
"remark": resOne.Remark,
"status": resOne.Status,
"sort": resOne.Sort,
"metadata": metadata,
})
}
// 处理逻辑后 w,r 如:重定向, resp 必须重新处理
// func (l *GetLdapGroupDetailLogic) AfterLogic(w http.ResponseWriter, r *http.Request, resp *basic.Response) {
// // httpx.OkJsonCtx(r.Context(), w, resp)
// }

5
server/ldap-admin/internal/logic/getldapgroupslogic.go
View File

@ -37,8 +37,9 @@ func (l *GetLdapGroupsLogic) GetLdapGroups(req *types.GetLdapGroupsReq, userinfo
// userinfo 传入值时, 一定不为null
resList, resCount, err := l.svcCtx.AllModels.LdapGroup.FindPage(l.ctx, gmodel.FindPageReq{
Page: req.CurrentPage,
Limit: req.PerPage,
Page: req.CurrentPage,
Limit: req.PerPage,
Fields: "id,name,keyword,remark,status,sort",
})
if err != nil {
return resp.SetStatus(basic.CodeServiceErr)

3
server/ldap-admin/internal/logic/savemenulogic.go
View File

@ -5,10 +5,11 @@ import (
"fusenapi/model/gmodel"
"fusenapi/utils/auth"
"fusenapi/utils/basic"
"gorm.io/gorm"
"strings"
"time"
"gorm.io/gorm"
"context"
"fusenapi/server/ldap-admin/internal/svc"

78
server/ldap-admin/internal/logic/setldapcasbinrulelogic.go
View File

@ -1,78 +0,0 @@
package logic
import (
"errors"
"fusenapi/model/gmodel"
"fusenapi/utils/auth"
"fusenapi/utils/basic"
"strconv"
"context"
"fusenapi/server/ldap-admin/internal/svc"
"fusenapi/server/ldap-admin/internal/types"
"github.com/zeromicro/go-zero/core/logx"
"gorm.io/gorm"
)
type SetLdapCasbinRuleLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewSetLdapCasbinRuleLogic(ctx context.Context, svcCtx *svc.ServiceContext) *SetLdapCasbinRuleLogic {
return &SetLdapCasbinRuleLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
// 处理进入前逻辑w,r
// func (l *SetLdapCasbinRuleLogic) BeforeLogic(w http.ResponseWriter, r *http.Request) {
// }
func (l *SetLdapCasbinRuleLogic) SetLdapCasbinRule(req *types.SetLdapCasbinRuleReq, userinfo *auth.UserInfo) (resp *basic.Response) {
// 返回值必须调用Set重新返回, resp可以空指针调用 resp.SetStatus(basic.CodeOK, data)
// userinfo 传入值时, 一定不为null
resLdapGroupInfo, err := l.svcCtx.AllModels.LdapGroup.FindOneById(l.ctx, req.GroupId)
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
basic.CodeServiceErr.Message = "权限组记录不存在"
} else {
basic.CodeServiceErr.Message = "系统出错"
}
return resp.SetStatus(basic.CodeServiceErr)
}
resLdapApiList, err := l.svcCtx.AllModels.LdapApis.FindAll(l.ctx, l.svcCtx.MysqlConn.Where("id IN ?", req.ApIds))
if err != nil {
return resp.SetStatus(basic.CodeServiceErr)
}
if len(resLdapApiList) > 0 {
var groupIdStr = strconv.Itoa(int(resLdapGroupInfo.Id))
var ldapCasbinRules []gmodel.LdapCasbinRule
for _, ldapApi := range resLdapApiList {
var apiIdStr = strconv.Itoa(int(ldapApi.Id))
ldapCasbinRules = append(ldapCasbinRules, gmodel.LdapCasbinRule{
V0: &groupIdStr,
V1: ldapApi.Path,
V2: ldapApi.Method,
V3: &apiIdStr,
})
}
resCreateInBatches := l.svcCtx.MysqlConn.WithContext(l.ctx).CreateInBatches(ldapCasbinRules, 100)
if resCreateInBatches.Error != nil {
basic.CodeServiceErr.Message = "系统出错"
return resp.SetStatus(basic.CodeServiceErr)
}
}
return resp.SetStatus(basic.CodeOK)
}
// 处理逻辑后 w,r 如:重定向, resp 必须重新处理
// func (l *SetLdapCasbinRuleLogic) AfterLogic(w http.ResponseWriter, r *http.Request, resp *basic.Response) {
// // httpx.OkJsonCtx(r.Context(), w, resp)
// }

90
server/ldap-admin/internal/logic/setldapgroupauthlogic.go Normal file
View File

@ -0,0 +1,90 @@
package logic
import (
"encoding/json"
"errors"
"fusenapi/utils/auth"
"fusenapi/utils/basic"
"context"
"fusenapi/server/ldap-admin/internal/svc"
"fusenapi/server/ldap-admin/internal/types"
"github.com/zeromicro/go-zero/core/logx"
"gorm.io/gorm"
)
type SetLdapGroupAuthLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewSetLdapGroupAuthLogic(ctx context.Context, svcCtx *svc.ServiceContext) *SetLdapGroupAuthLogic {
return &SetLdapGroupAuthLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
// 处理进入前逻辑w,r
// func (l *SetLdapGroupAuthLogic) BeforeLogic(w http.ResponseWriter, r *http.Request) {
// }
func (l *SetLdapGroupAuthLogic) SetLdapGroupAuth(req *types.SetLdapGroupAuthReq, userinfo *auth.UserInfo) (resp *basic.Response) {
// 返回值必须调用Set重新返回, resp可以空指针调用 resp.SetStatus(basic.CodeOK, data)
// userinfo 传入值时, 一定不为null
resOne, err := l.svcCtx.AllModels.LdapGroup.FindOneById(l.ctx, req.GroupId)
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
basic.CodeServiceErr.Message = "记录不存在"
} else {
basic.CodeServiceErr.Message = "系统出错"
}
return resp.SetStatus(basic.CodeServiceErr)
}
var metadata []types.GroupAuth
if resOne.Metadata != nil {
err := json.Unmarshal(*resOne.Metadata, &metadata)
if err != nil {
basic.CodeServiceErr.Message = "系统出错"
return resp.SetStatus(basic.CodeServiceErr)
}
}
var groupAuth = types.GroupAuth{
Id: req.GroupAuth.Id,
Type: req.GroupAuth.Type,
Name: req.GroupAuth.Name,
Metadata: req.GroupAuth.Metadata,
}
var status = 0
if len(metadata) > 0 {
for k, v := range metadata {
if v.Type == groupAuth.Type && v.Id == groupAuth.Id {
status = 1
metadata[k] = groupAuth
}
}
}
if status == 0 {
metadata = append(metadata, groupAuth)
}
// 更新metadata
metadataByte, _ := json.Marshal(metadata)
err = l.svcCtx.AllModels.LdapGroup.UpdateOne(l.ctx, resOne, map[string]interface{}{
"metadata": string(metadataByte),
})
if err != nil {
basic.CodeServiceErr.Message = "系统出错"
return resp.SetStatus(basic.CodeServiceErr)
}
return resp.SetStatus(basic.CodeOK)
}
// 处理逻辑后 w,r 如:重定向, resp 必须重新处理
// func (l *SetLdapGroupAuthLogic) AfterLogic(w http.ResponseWriter, r *http.Request, resp *basic.Response) {
// // httpx.OkJsonCtx(r.Context(), w, resp)
// }

66
server/ldap-admin/internal/logic/setldapgroupmenuslogic.go
View File

@ -1,66 +0,0 @@
package logic
import (
"errors"
"fusenapi/model/gmodel"
"fusenapi/utils/auth"
"fusenapi/utils/basic"
"context"
"fusenapi/server/ldap-admin/internal/svc"
"fusenapi/server/ldap-admin/internal/types"
"github.com/zeromicro/go-zero/core/logx"
"gorm.io/gorm"
)
type SetLdapGroupMenusLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewSetLdapGroupMenusLogic(ctx context.Context, svcCtx *svc.ServiceContext) *SetLdapGroupMenusLogic {
return &SetLdapGroupMenusLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
// 处理进入前逻辑w,r
// func (l *SetLdapGroupMenusLogic) BeforeLogic(w http.ResponseWriter, r *http.Request) {
// }
func (l *SetLdapGroupMenusLogic) SetLdapGroupMenus(req *types.SetLdapGroupMenusReq, userinfo *auth.UserInfo) (resp *basic.Response) {
// 返回值必须调用Set重新返回, resp可以空指针调用 resp.SetStatus(basic.CodeOK, data)
// userinfo 传入值时, 一定不为null
resLdapGroupInfo, err := l.svcCtx.AllModels.LdapGroup.FindOneById(l.ctx, req.GroupId)
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
basic.CodeServiceErr.Message = "权限组记录不存在"
} else {
basic.CodeServiceErr.Message = "系统出错"
}
return resp.SetStatus(basic.CodeServiceErr)
}
var groupMenus []gmodel.LdapGroupMenus
for _, menuId := range req.MenuIds {
groupMenus = append(groupMenus, gmodel.LdapGroupMenus{
GroupId: &resLdapGroupInfo.Id,
MenuId: &menuId,
})
}
resCreateInBatches := l.svcCtx.MysqlConn.WithContext(l.ctx).CreateInBatches(groupMenus, 100)
if resCreateInBatches.Error != nil {
basic.CodeServiceErr.Message = "系统出错"
return resp.SetStatus(basic.CodeServiceErr)
}
return resp.SetStatus(basic.CodeOK)
}
// 处理逻辑后 w,r 如:重定向, resp 必须重新处理
// func (l *SetLdapGroupMenusLogic) AfterLogic(w http.ResponseWriter, r *http.Request, resp *basic.Response) {
// // httpx.OkJsonCtx(r.Context(), w, resp)
// }

16
server/ldap-admin/internal/types/types.go
View File

@ -5,6 +5,22 @@ import (
"fusenapi/utils/basic"
)
type GetLdapGroupDetailReq struct {
Id int64 `form:"id"`
}
type SetLdapGroupAuthReq struct {
GroupId int64 `json:"group_id"`
GroupAuth GroupAuth `json:"group_auth"`
}
type GroupAuth struct {
Id int64 `json:"id"`
Name string `json:"name"`
Type string `json:"type"`
Metadata []*GroupAuth `json:"metadata,optional"`
}
type GetLdapGroupsReq struct {
Id int64 `form:"id,optional"` //id
Name string `form:"name,optional"` //名称

31
server_api/ldap-admin.api
View File

@ -13,18 +13,20 @@ service ldap-admin {
//获取权限组列表
@handler GetLdapGroupsHandler
get /api/ldap-admin/get_ldap_group(GetLdapGroupsReq) returns (response);
//获取权限组详情
@handler GetLdapGroupDetailHandler
get /api/ldap-admin/get_ldap_group_detail(GetLdapGroupDetailReq) returns (response);
//保存权限组
@handler SaveLdapGroupHandler
post /api/ldap-admin/save_ldap_group(SaveLdapGroupReq) returns (response);
//删除权限组
@handler DeleteLdapGroupHandler
post /api/ldap-admin/delete_ldap_group(DeleteLdapGroupReq) returns (response);
//权限组授权菜单
@handler SetLdapGroupMenusHandler
post /api/ldap-admin/set_ldap_group_menus(SetLdapGroupMenusReq) returns (response);
//权限组授权接口
@handler SetLdapCasbinRuleHandler
post /api/ldap-admin/set_ldap_casbin_rule(SetLdapCasbinRuleReq) returns (response);
//权限组授权
@handler SetLdapGroupAuthHandler
post /api/ldap-admin/set_ldap_group_auth(SetLdapGroupAuthReq) returns (response);
//权限组授权用户
@handler SetLdapGroupUserHandler
post /api/ldap-admin/set_ldap_group_user(SetLdapGroupUserReq) returns (response);
@ -37,7 +39,7 @@ service ldap-admin {
//删除API
@handler DeleteApiHandler
post /api/ldap-admin/delete_api(DeleteApiReq) returns (response);
//保存菜单
@handler SaveMenuHandler
post /api/ldap-admin/save_menu(SaveMenuReq) returns (response);
@ -98,6 +100,21 @@ service ldap-admin {
}
type (
GetLdapGroupDetailReq {
Id int64 `form:"id"`
}
SetLdapGroupAuthReq {
GroupId int64 `json:"group_id"`
GroupAuth GroupAuth `json:"group_auth"`
}
GroupAuth {
Id int64 `json:"id"`
Name string `json:"name"`
Type string `json:"type"`
Metadata []*GroupAuth `json:"metadata,optional"`
}
GetLdapGroupsReq {
Id int64 `form:"id,optional"` //id
Name string `form:"name,optional"` //名称