123 lines
4.6 KiB
Go
123 lines
4.6 KiB
Go
package service
|
|
|
|
import (
|
|
"context"
|
|
|
|
"kra/internal/biz"
|
|
"kra/internal/service/dto"
|
|
)
|
|
|
|
type AuthorityService struct{ uc *biz.AuthorityUsecase }
|
|
|
|
func NewAuthorityService(uc *biz.AuthorityUsecase) *AuthorityService {
|
|
return &AuthorityService{uc: uc}
|
|
}
|
|
|
|
type PermissionService struct{ uc *biz.PermissionUsecase }
|
|
|
|
func NewPermissionService(uc *biz.PermissionUsecase) *PermissionService {
|
|
return &PermissionService{uc: uc}
|
|
}
|
|
|
|
type AccessControlService struct{ uc *biz.AccessControlUsecase }
|
|
|
|
func NewAccessControlService(uc *biz.AccessControlUsecase) *AccessControlService {
|
|
return &AccessControlService{uc: uc}
|
|
}
|
|
|
|
func (s *AccessControlService) Authorize(ctx context.Context, aid uint, path, method string) (bool, error) {
|
|
return s.uc.Authorize(ctx, aid, path, method)
|
|
}
|
|
|
|
func authorityDTO(v *biz.Authority) map[string]any {
|
|
out := convertAuthority(*v)
|
|
children := make([]map[string]any, 0, len(v.Children))
|
|
for _, child := range v.Children {
|
|
children = append(children, authorityDTO(child))
|
|
}
|
|
out["children"] = children
|
|
return out
|
|
}
|
|
func (s *AuthorityService) Authorities(ctx context.Context) ([]map[string]any, error) {
|
|
items, err := s.uc.AuthorityTree(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
roots := make([]map[string]any, 0, len(items))
|
|
for _, v := range items {
|
|
roots = append(roots, authorityDTO(v))
|
|
}
|
|
return roots, nil
|
|
}
|
|
func (s *AuthorityService) CreateAuthority(ctx context.Context, v *biz.Authority) error {
|
|
return s.uc.CreateAuthority(ctx, v)
|
|
}
|
|
func (s *AuthorityService) CopyAuthority(ctx context.Context, sourceID uint, v *biz.Authority) error {
|
|
return s.uc.CopyAuthority(ctx, sourceID, v)
|
|
}
|
|
func (s *AuthorityService) UpdateAuthority(ctx context.Context, v *biz.Authority) error {
|
|
return s.uc.UpdateAuthority(ctx, v)
|
|
}
|
|
func (s *AuthorityService) DeleteAuthority(ctx context.Context, id uint) error {
|
|
return s.uc.DeleteAuthority(ctx, id)
|
|
}
|
|
func authorityDomain(req *dto.AuthorityRequest) *biz.Authority {
|
|
return &biz.Authority{AuthorityID: req.AuthorityID, AuthorityName: req.AuthorityName, ParentID: req.ParentID, DataScope: req.DataScope, DefaultRouter: req.DefaultRouter}
|
|
}
|
|
func authorityResponse(value *biz.Authority) *dto.AuthorityResponse {
|
|
return &dto.AuthorityResponse{AuthorityID: value.AuthorityID, AuthorityName: value.AuthorityName, ParentID: value.ParentID, DataScope: value.DataScope, DefaultRouter: value.DefaultRouter}
|
|
}
|
|
func (s *AuthorityService) CreateAuthorityRequest(ctx context.Context, req *dto.AuthorityRequest) (*dto.AuthorityResponse, error) {
|
|
value := authorityDomain(req)
|
|
if err := s.CreateAuthority(ctx, value); err != nil {
|
|
return nil, err
|
|
}
|
|
return authorityResponse(value), nil
|
|
}
|
|
func (s *AuthorityService) CopyAuthorityRequest(ctx context.Context, req *dto.CopyAuthorityRequest) (*dto.AuthorityResponse, error) {
|
|
value := authorityDomain(&req.Authority)
|
|
if err := s.CopyAuthority(ctx, req.OldAuthorityID, value); err != nil {
|
|
return nil, err
|
|
}
|
|
return authorityResponse(value), nil
|
|
}
|
|
func (s *AuthorityService) UpdateAuthorityRequest(ctx context.Context, req *dto.AuthorityRequest) (*dto.AuthorityResponse, error) {
|
|
value := authorityDomain(req)
|
|
if err := s.UpdateAuthority(ctx, value); err != nil {
|
|
return nil, err
|
|
}
|
|
return authorityResponse(value), nil
|
|
}
|
|
func (s *AuthorityService) SetAuthorityUsers(ctx context.Context, id uint, ids []uint) error {
|
|
return s.uc.SetAuthorityUsers(ctx, id, ids)
|
|
}
|
|
func (s *AuthorityService) AuthorityUserIDs(ctx context.Context, id uint) ([]uint, error) {
|
|
return s.uc.AuthorityUserIDs(ctx, id)
|
|
}
|
|
func (s *AuthorityService) SetDataScope(ctx context.Context, id uint, scope int, ids []uint) error {
|
|
return s.uc.SetDataScope(ctx, id, scope, ids)
|
|
}
|
|
func (s *AuthorityService) DataScopeDepartmentIDs(ctx context.Context, id uint) ([]uint, error) {
|
|
return s.uc.DataScopeDepartmentIDs(ctx, id)
|
|
}
|
|
func (s *AccessControlService) ResolveDataScope(ctx context.Context, authorityID, userID uint) (biz.DataScope, error) {
|
|
return s.uc.ResolveDataScope(ctx, authorityID, userID)
|
|
}
|
|
func (s *AccessControlService) ContextWithDataScope(ctx context.Context, authorityID, userID uint) (context.Context, error) {
|
|
scope, err := s.ResolveDataScope(ctx, authorityID, userID)
|
|
if err != nil {
|
|
return ctx, err
|
|
}
|
|
return biz.NewDataScopeContext(ctx, scope), nil
|
|
}
|
|
|
|
func (s *PermissionService) SelectedButtons(ctx context.Context, aid, menuID uint) ([]uint, error) {
|
|
return s.uc.SelectedButtons(ctx, aid, menuID)
|
|
}
|
|
func (s *PermissionService) SetSelectedButtons(ctx context.Context, aid, menuID uint, ids []uint) error {
|
|
return s.uc.SetSelectedButtons(ctx, aid, menuID, ids)
|
|
}
|
|
func (s *PermissionService) CanRemoveButton(ctx context.Context, id uint) (bool, error) {
|
|
return s.uc.CanRemoveButton(ctx, id)
|
|
}
|