116 lines
3.3 KiB
Go
116 lines
3.3 KiB
Go
package biz
|
|
|
|
import (
|
|
"context"
|
|
"time"
|
|
)
|
|
|
|
type API struct {
|
|
ID uint
|
|
CreatedAt time.Time
|
|
UpdatedAt time.Time
|
|
Path string
|
|
Description string
|
|
APIGroup string
|
|
Method string
|
|
OrderKey string
|
|
Desc bool
|
|
StrictAll bool
|
|
}
|
|
|
|
type APIRepo interface {
|
|
CreateAPI(context.Context, *API) error
|
|
UpdateAPI(context.Context, *API) error
|
|
DeleteAPIs(context.Context, []uint) error
|
|
FindAPI(context.Context, uint) (*API, error)
|
|
ListAPIs(context.Context, int, int, *API) ([]*API, int64, error)
|
|
APIRoleIDs(context.Context, string, string) ([]uint, error)
|
|
SetAPIRoles(context.Context, string, string, []uint) error
|
|
CheckPolicyStore(context.Context) error
|
|
Authorize(context.Context, uint, string, string) (bool, error)
|
|
PolicyPaths(context.Context, uint) ([]*API, error)
|
|
SetPolicyPaths(context.Context, uint, []*API) error
|
|
IgnoredAPIs(context.Context) ([]*API, error)
|
|
SetAPIIgnored(context.Context, string, string, bool) error
|
|
ApplyAPISync(context.Context, []*API, []*API) error
|
|
}
|
|
|
|
type APIUsecase struct{ APIRepo }
|
|
|
|
func NewAPIUsecase(repo APIRepo) *APIUsecase { return &APIUsecase{APIRepo: repo} }
|
|
|
|
func (uc *APIUsecase) FreshCasbin(ctx context.Context) error {
|
|
return uc.CheckPolicyStore(ctx)
|
|
}
|
|
|
|
// DeleteAPI preserves the single-delete contract used by the legacy admin:
|
|
// the target is looked up first, so deleting a missing API returns the
|
|
// repository's not-found error instead of silently succeeding on an empty
|
|
// UPDATE/DELETE. Bulk deletion intentionally keeps separate semantics.
|
|
func (uc *APIUsecase) DeleteAPI(ctx context.Context, id uint) error {
|
|
if _, err := uc.FindAPI(ctx, id); err != nil {
|
|
return err
|
|
}
|
|
return uc.DeleteAPIs(ctx, []uint{id})
|
|
}
|
|
|
|
type APISyncDiff struct {
|
|
Added []*API
|
|
Deleted []*API
|
|
Ignored []*API
|
|
}
|
|
|
|
func (uc *APIUsecase) SyncAPIs(ctx context.Context, routes []*API) (*APISyncDiff, error) {
|
|
stored, _, err := uc.ListAPIs(ctx, 0, 0, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
ignored, err := uc.IgnoredAPIs(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
key := func(value *API) string { return value.Method + " " + value.Path }
|
|
ignoreSet := make(map[string]bool, len(ignored))
|
|
for _, item := range ignored {
|
|
ignoreSet[key(item)] = true
|
|
}
|
|
routeSet := make(map[string]*API, len(routes))
|
|
for _, item := range routes {
|
|
if !ignoreSet[key(item)] {
|
|
routeSet[key(item)] = item
|
|
}
|
|
}
|
|
storedSet := make(map[string]*API, len(stored))
|
|
for _, item := range stored {
|
|
storedSet[key(item)] = item
|
|
}
|
|
// The sync API always returns JSON arrays for all three collections,
|
|
// including when no routes were added or removed.
|
|
diff := &APISyncDiff{
|
|
Added: make([]*API, 0),
|
|
Deleted: make([]*API, 0),
|
|
Ignored: ignored,
|
|
}
|
|
added := make(map[string]bool)
|
|
for _, item := range routes {
|
|
routeKey := key(item)
|
|
if ignoreSet[routeKey] || added[routeKey] {
|
|
continue
|
|
}
|
|
if storedSet[routeKey] == nil {
|
|
diff.Added = append(diff.Added, item)
|
|
added[routeKey] = true
|
|
}
|
|
}
|
|
for _, item := range stored {
|
|
storedKey := key(item)
|
|
// Ignoring an API removes it from the in-memory route comparison. If it
|
|
// already exists in sys_apis, the reference implementation therefore
|
|
// returns it in deleteApis while also returning it in ignoreApis.
|
|
if routeSet[storedKey] == nil {
|
|
diff.Deleted = append(diff.Deleted, item)
|
|
}
|
|
}
|
|
return diff, nil
|
|
}
|