190 lines
7.6 KiB
Go
190 lines
7.6 KiB
Go
package service
|
|
|
|
import (
|
|
"context"
|
|
"strings"
|
|
|
|
"kra/internal/biz"
|
|
"kra/internal/service/dto"
|
|
)
|
|
|
|
type AccessService struct{ uc *biz.AccessUsecase }
|
|
|
|
func NewAccessService(uc *biz.AccessUsecase) *AccessService { return &AccessService{uc: uc} }
|
|
func (s *AccessService) 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 { return convertAuthority(*v) }
|
|
func apiDTO(v *biz.API) map[string]any {
|
|
return map[string]any{"ID": v.ID, "CreatedAt": v.CreatedAt, "UpdatedAt": v.UpdatedAt, "DeletedAt": nil, "path": v.Path, "description": v.Description, "apiGroup": v.APIGroup, "method": v.Method}
|
|
}
|
|
func departmentDTO(v *biz.Department) map[string]any {
|
|
children := make([]map[string]any, 0, len(v.Children))
|
|
for _, c := range v.Children {
|
|
children = append(children, departmentDTO(c))
|
|
}
|
|
return map[string]any{"ID": v.ID, "CreatedAt": v.CreatedAt, "UpdatedAt": v.UpdatedAt, "DeletedAt": nil, "name": v.Name, "parentId": v.ParentID, "ancestors": v.Ancestors, "sort": v.Sort, "leaderId": v.LeaderID, "leader": nil, "status": v.Status, "children": children, "namePath": ""}
|
|
}
|
|
func positionDTO(v *biz.Position) map[string]any {
|
|
return map[string]any{"ID": v.ID, "CreatedAt": v.CreatedAt, "UpdatedAt": v.UpdatedAt, "DeletedAt": nil, "name": v.Name, "code": v.Code, "sort": v.Sort, "status": v.Status, "remark": v.Remark}
|
|
}
|
|
|
|
func (s *AccessService) Authorities(ctx context.Context) ([]map[string]any, error) {
|
|
items, err := s.uc.Repo().ListAuthorities(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
byID := make(map[uint]map[string]any, len(items))
|
|
for _, v := range items {
|
|
byID[v.AuthorityID] = authorityDTO(v)
|
|
}
|
|
roots := make([]map[string]any, 0)
|
|
for _, v := range items {
|
|
item := byID[v.AuthorityID]
|
|
if v.ParentID != nil && *v.ParentID != 0 && byID[*v.ParentID] != nil {
|
|
parent := byID[*v.ParentID]
|
|
children, _ := parent["children"].([]map[string]any)
|
|
parent["children"] = append(children, item)
|
|
} else {
|
|
roots = append(roots, item)
|
|
}
|
|
}
|
|
return roots, nil
|
|
}
|
|
func (s *AccessService) CreateAuthority(ctx context.Context, v *biz.Authority) error {
|
|
return s.uc.Repo().CreateAuthority(ctx, v)
|
|
}
|
|
func (s *AccessService) CopyAuthority(ctx context.Context, sourceID uint, v *biz.Authority) error {
|
|
return s.uc.Repo().CopyAuthority(ctx, sourceID, v)
|
|
}
|
|
func (s *AccessService) UpdateAuthority(ctx context.Context, v *biz.Authority) error {
|
|
return s.uc.Repo().UpdateAuthority(ctx, v)
|
|
}
|
|
func (s *AccessService) DeleteAuthority(ctx context.Context, id uint) error {
|
|
return s.uc.Repo().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 *AccessService) 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 *AccessService) 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 *AccessService) 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 *AccessService) SetAuthorityUsers(ctx context.Context, id uint, ids []uint) error {
|
|
return s.uc.Repo().SetAuthorityUsers(ctx, id, ids)
|
|
}
|
|
func (s *AccessService) AuthorityUserIDs(ctx context.Context, id uint) ([]uint, error) {
|
|
return s.uc.Repo().AuthorityUserIDs(ctx, id)
|
|
}
|
|
func (s *AccessService) SetDataScope(ctx context.Context, id uint, scope int, ids []uint) error {
|
|
return s.uc.Repo().SetDataScope(ctx, id, scope, ids)
|
|
}
|
|
func (s *AccessService) DataScopeDepartmentIDs(ctx context.Context, id uint) ([]uint, error) {
|
|
return s.uc.Repo().DataScopeDepartmentIDs(ctx, id)
|
|
}
|
|
func (s *AccessService) ResolveDataScope(ctx context.Context, authorityID, userID uint) (biz.DataScope, error) {
|
|
return s.uc.Repo().ResolveDataScope(ctx, authorityID, userID)
|
|
}
|
|
|
|
func (s *AccessService) DeleteAPIs(ctx context.Context, ids []uint) error {
|
|
return s.uc.Repo().DeleteAPIs(ctx, ids)
|
|
}
|
|
func (s *AccessService) APIRoleIDs(ctx context.Context, id uint) ([]uint, error) {
|
|
return s.uc.Repo().APIRoleIDs(ctx, id)
|
|
}
|
|
func (s *AccessService) SetAPIRoles(ctx context.Context, id uint, ids []uint) error {
|
|
return s.uc.Repo().SetAPIRoles(ctx, id, ids)
|
|
}
|
|
func (s *AccessService) SyncAPIs(ctx context.Context, routes []*biz.API) (*dto.APISyncResponse, error) {
|
|
stored, _, err := s.uc.Repo().ListAPIs(ctx, 1, 100000, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
ignored, err := s.uc.Repo().IgnoredAPIs(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
key := func(v *biz.API) string { return strings.ToUpper(v.Method) + " " + v.Path }
|
|
ignoreSet := make(map[string]bool, len(ignored))
|
|
for _, item := range ignored {
|
|
ignoreSet[key(item)] = true
|
|
}
|
|
routeSet := make(map[string]*biz.API, len(routes))
|
|
for _, item := range routes {
|
|
if !ignoreSet[key(item)] {
|
|
routeSet[key(item)] = item
|
|
}
|
|
}
|
|
storedSet := make(map[string]*biz.API, len(stored))
|
|
for _, item := range stored {
|
|
storedSet[key(item)] = item
|
|
}
|
|
added := make([]*dto.APIResponse, 0)
|
|
deleted := make([]*dto.APIResponse, 0)
|
|
ignoredDTO := make([]*dto.APIResponse, 0, len(ignored))
|
|
for k, item := range routeSet {
|
|
if storedSet[k] == nil {
|
|
added = append(added, apiResponse(item))
|
|
}
|
|
}
|
|
for k, item := range storedSet {
|
|
if routeSet[k] == nil && !ignoreSet[k] {
|
|
deleted = append(deleted, apiResponse(item))
|
|
}
|
|
}
|
|
for _, item := range ignored {
|
|
ignoredDTO = append(ignoredDTO, apiResponse(item))
|
|
}
|
|
return &dto.APISyncResponse{NewAPIs: added, DeleteAPIs: deleted, IgnoreAPIs: ignoredDTO}, nil
|
|
}
|
|
func (s *AccessService) SetAPIIgnored(ctx context.Context, path, method string, ignored bool) error {
|
|
return s.uc.Repo().SetAPIIgnored(ctx, path, method, ignored)
|
|
}
|
|
func (s *AccessService) Buttons(ctx context.Context, id uint) ([]map[string]any, error) {
|
|
items, err := s.uc.Repo().Buttons(ctx, id)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out := make([]map[string]any, 0, len(items))
|
|
for _, v := range items {
|
|
out = append(out, map[string]any{"ID": v.ID, "name": v.Name, "desc": v.Description, "sysBaseMenuID": v.MenuID})
|
|
}
|
|
return out, nil
|
|
}
|
|
func (s *AccessService) SetAuthorityButtons(ctx context.Context, id uint, v map[uint][]uint) error {
|
|
return s.uc.Repo().SetAuthorityButtons(ctx, id, v)
|
|
}
|
|
func (s *AccessService) AuthorityButtonIDs(ctx context.Context, id uint) ([]uint, error) {
|
|
return s.uc.Repo().AuthorityButtonIDs(ctx, id)
|
|
}
|
|
func (s *AccessService) SelectedButtons(ctx context.Context, aid, menuID uint) ([]uint, error) {
|
|
return s.uc.Repo().SelectedButtons(ctx, aid, menuID)
|
|
}
|
|
func (s *AccessService) SetSelectedButtons(ctx context.Context, aid, menuID uint, ids []uint) error {
|
|
return s.uc.Repo().SetSelectedButtons(ctx, aid, menuID, ids)
|
|
}
|
|
func (s *AccessService) CanRemoveButton(ctx context.Context, id uint) (bool, error) {
|
|
return s.uc.Repo().CanRemoveButton(ctx, id)
|
|
}
|