91 lines
3.2 KiB
Go
91 lines
3.2 KiB
Go
package service
|
|
|
|
import (
|
|
"context"
|
|
|
|
"kra/internal/biz"
|
|
"kra/internal/service/dto"
|
|
)
|
|
|
|
func apiDomain(value *dto.APIRequest) *biz.API {
|
|
return &biz.API{ID: value.ID, Path: value.Path, Description: value.Description, APIGroup: value.APIGroup, Method: value.Method}
|
|
}
|
|
|
|
func apiResponse(value *biz.API) *dto.APIResponse {
|
|
return &dto.APIResponse{ID: value.ID, CreatedAt: value.CreatedAt, UpdatedAt: value.UpdatedAt, DeletedAt: nil, Path: value.Path, Description: value.Description, APIGroup: value.APIGroup, Method: value.Method}
|
|
}
|
|
|
|
func apiResponses(items []*biz.API) []*dto.APIResponse {
|
|
out := make([]*dto.APIResponse, 0, len(items))
|
|
for _, item := range items {
|
|
out = append(out, apiResponse(item))
|
|
}
|
|
return out
|
|
}
|
|
|
|
func (s *AccessService) ListAPI(ctx context.Context, req *dto.APIListRequest) ([]*dto.APIResponse, int64, error) {
|
|
items, total, err := s.uc.Repo().ListAPIs(ctx, req.Page, req.PageSize, &biz.API{Path: req.Path, Description: req.Description, APIGroup: req.APIGroup, Method: req.Method})
|
|
if err != nil {
|
|
return nil, 0, err
|
|
}
|
|
return apiResponses(items), total, nil
|
|
}
|
|
|
|
func (s *AccessService) AllAPI(ctx context.Context) ([]*dto.APIResponse, error) {
|
|
items, _, err := s.uc.Repo().ListAPIs(ctx, 1, 10000, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return apiResponses(items), nil
|
|
}
|
|
|
|
func (s *AccessService) CreateAPIRequest(ctx context.Context, req *dto.APIRequest) error {
|
|
return s.uc.Repo().CreateAPI(ctx, apiDomain(req))
|
|
}
|
|
func (s *AccessService) UpdateAPIRequest(ctx context.Context, req *dto.APIRequest) error {
|
|
return s.uc.Repo().UpdateAPI(ctx, apiDomain(req))
|
|
}
|
|
func (s *AccessService) FindAPIResponse(ctx context.Context, id uint) (*dto.APIResponse, error) {
|
|
value, err := s.uc.Repo().FindAPI(ctx, id)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return apiResponse(value), nil
|
|
}
|
|
func (s *AccessService) ApplyAPISyncRequest(ctx context.Context, req *dto.ApplyAPISyncRequest) error {
|
|
added := make([]*biz.API, 0, len(req.NewAPIs))
|
|
deleted := make([]*biz.API, 0, len(req.DeleteAPIs))
|
|
for i := range req.NewAPIs {
|
|
added = append(added, apiDomain(&req.NewAPIs[i]))
|
|
}
|
|
for i := range req.DeleteAPIs {
|
|
deleted = append(deleted, apiDomain(&req.DeleteAPIs[i]))
|
|
}
|
|
return s.uc.Repo().ApplyAPISync(ctx, added, deleted)
|
|
}
|
|
func (s *AccessService) SetPolicyPathsRequest(ctx context.Context, req *dto.SetPolicyPathsRequest) error {
|
|
paths := make([]*biz.API, 0, len(req.Infos))
|
|
for _, value := range req.Infos {
|
|
paths = append(paths, &biz.API{Path: value.Path, Method: value.Method})
|
|
}
|
|
return s.uc.Repo().SetPolicyPaths(ctx, req.AuthorityID, paths)
|
|
}
|
|
func (s *AccessService) PolicyPathResponses(ctx context.Context, authorityID uint) ([]dto.PolicyPathRequest, error) {
|
|
items, err := s.uc.Repo().PolicyPaths(ctx, authorityID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out := make([]dto.PolicyPathRequest, 0, len(items))
|
|
for _, item := range items {
|
|
out = append(out, dto.PolicyPathRequest{Path: item.Path, Method: item.Method})
|
|
}
|
|
return out, nil
|
|
}
|
|
func (s *AccessService) SyncAPIResponses(ctx context.Context, routes []dto.APIRequest) (*dto.APISyncResponse, error) {
|
|
items := make([]*biz.API, 0, len(routes))
|
|
for i := range routes {
|
|
items = append(items, apiDomain(&routes[i]))
|
|
}
|
|
return s.SyncAPIs(ctx, items)
|
|
}
|