170 lines
4.6 KiB
Go
170 lines
4.6 KiB
Go
package usecase
|
|
|
|
import (
|
|
"context"
|
|
|
|
"code.30cm.net/digimon/app-cloudep-permission-server/pkg/domain/entity"
|
|
"code.30cm.net/digimon/app-cloudep-permission-server/pkg/domain/permission"
|
|
"code.30cm.net/digimon/app-cloudep-permission-server/pkg/domain/repository"
|
|
"code.30cm.net/digimon/app-cloudep-permission-server/pkg/domain/usecase"
|
|
)
|
|
|
|
type RolePermissionUseCaseParam struct {
|
|
rolePermissionRepository repository.RolePermissionRepository
|
|
permissionRepository repository.PermissionRepository
|
|
roleRepository repository.RoleRepository
|
|
userRoleRepository repository.UserRoleRepository
|
|
}
|
|
|
|
type RolePermissionUseCase struct {
|
|
RolePermissionUseCaseParam
|
|
}
|
|
|
|
func NewRolePermissionUseCase(param RolePermissionUseCaseParam) usecase.RolePermissionUseCase {
|
|
return &RolePermissionUseCase{
|
|
RolePermissionUseCaseParam: param,
|
|
}
|
|
}
|
|
|
|
// Get 拿到這個 Role ID 底下有哪些權限是開的
|
|
func (use *RolePermissionUseCase) Get(ctx context.Context, roleID string) (permission.Permissions, error) {
|
|
// 拿到這個 role 底下有哪些 Permission
|
|
rolePermission, err := use.rolePermissionRepository.Get(ctx, roleID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
p, err := use.permissionRepository.GetAll(ctx, nil) // -> 開的關的 permission 都會拿到
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return GeneratePermissionTree(p).getFullParentPermission(rolePermission), nil
|
|
}
|
|
|
|
func (use *RolePermissionUseCase) Create(ctx context.Context, roleID string, permissions permission.Permissions) error {
|
|
// 如果加了一個，要把上面的節點都加入才可以
|
|
permissionIDs, err := use.getPermissionIDs(ctx, permissions)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
insert := make([]entity.RolePermission, 0, len(permissions))
|
|
|
|
for _, permissionID := range permissionIDs {
|
|
insert = append(insert, entity.RolePermission{
|
|
RoleID: roleID,
|
|
PermissionID: permissionID,
|
|
})
|
|
}
|
|
|
|
err = use.rolePermissionRepository.Create(ctx, insert)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (use *RolePermissionUseCase) getPermissionIDs(ctx context.Context, setPermissions permission.Permissions) ([]string, error) {
|
|
p, err := use.permissionRepository.GetAll(ctx, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return GeneratePermissionTree(p).getFullParentPermissionIDs(setPermissions)
|
|
}
|
|
|
|
func (use *RolePermissionUseCase) Delete(ctx context.Context, roleID string, permissions permission.Permissions) error {
|
|
// 如果加了一個，要把上面的節點都加入才可以
|
|
permissionIDs, err := use.getPermissionIDs(ctx, permissions)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
del := make([]string, 0, len(permissions))
|
|
for _, permissionID := range permissionIDs {
|
|
del = append(del, permissionID)
|
|
}
|
|
|
|
err = use.rolePermissionRepository.Delete(ctx, roleID, del)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (use *RolePermissionUseCase) List(ctx context.Context, req usecase.ListQuery) (usecase.RoleResp, error) {
|
|
roles, total, err := use.roleRepository.List(ctx, repository.ListQuery{
|
|
PageIndex: req.PageIndex,
|
|
PageSize: req.PageSize,
|
|
ClientID: req.ClientID,
|
|
UID: req.UID,
|
|
Name: req.Name,
|
|
Status: req.Status,
|
|
})
|
|
if err != nil {
|
|
return usecase.RoleResp{}, err
|
|
}
|
|
|
|
result := make([]usecase.Role, 0, len(roles))
|
|
for _, item := range roles {
|
|
result = append(result, usecase.Role{
|
|
ID: item.ID.Hex(),
|
|
UID: item.UID,
|
|
Name: item.Name,
|
|
Status: item.Status,
|
|
ClientID: item.ClientID,
|
|
})
|
|
}
|
|
|
|
return usecase.RoleResp{
|
|
Total: total,
|
|
Roles: result,
|
|
}, nil
|
|
}
|
|
|
|
//// GetByRoleUID 拿到這個 UID 底下有哪些權限是開的
|
|
//func (use *RolePermissionUseCase) GetByRoleUID(ctx context.Context, uid string) (permission.Permissions, error) {
|
|
// permissions := make(permission.Permissions)
|
|
//
|
|
// // admin權限
|
|
// if uid == permission.AdminRoleUID {
|
|
// data, err := use.permissionRepository.GetAll(ctx, nil)
|
|
// if err != nil {
|
|
// return nil, err
|
|
// }
|
|
//
|
|
// for _, v := range data {
|
|
// permissions[v.Name] = permission.OpenPermission
|
|
// }
|
|
// } else {
|
|
// role, err := use.roleRepository.GetByUID(ctx, uid)
|
|
// if err != nil {
|
|
// return nil, err
|
|
// }
|
|
//
|
|
// permissions, err = use.Get(ctx, role.ID.Hex())
|
|
// if err != nil {
|
|
// return nil, err
|
|
// }
|
|
// }
|
|
//
|
|
// return permissions, nil
|
|
//}
|
|
//
|
|
//func (use *RolePermissionUseCase) GetByUser(ctx context.Context, uid string) (usecase.UserPermission, error) {
|
|
// userRole, err := use.userRoleRepository.GetByUserID(ctx, uid)
|
|
// if err != nil {
|
|
// return usecase.UserPermission{}, err
|
|
// }
|
|
//
|
|
// p, err := use.Get(ctx, userRole.RoleID)
|
|
// if err != nil {
|
|
// return usecase.UserPermission{}, err
|
|
// }
|
|
//
|
|
// return usecase.UserPermission{
|
|
// RoleID: userRole.RoleID,
|
|
// Permissions: p,
|
|
// }, nil
|
|
//}
|