mirror of
https://github.com/APIParkLab/APIPark.git
synced 2026-06-12 18:11:34 +08:00
Liujian
303 lines
7.9 KiB
Go
303 lines
7.9 KiB
Go
package api
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"time"
|
|
|
|
"github.com/google/uuid"
|
|
"gorm.io/gorm"
|
|
|
|
"github.com/APIParkLab/APIPark/service/universally/commit"
|
|
|
|
"github.com/APIParkLab/APIPark/stores/api"
|
|
|
|
"github.com/eolinker/go-common/utils"
|
|
|
|
"github.com/eolinker/go-common/auto"
|
|
|
|
"github.com/APIParkLab/APIPark/service/universally"
|
|
)
|
|
|
|
var (
|
|
_ IAPIService = (*imlAPIService)(nil)
|
|
)
|
|
|
|
type HistoryType string
|
|
|
|
const (
|
|
HistoryRequest HistoryType = "request"
|
|
HistoryProxy HistoryType = "proxy"
|
|
HistoryPlugin HistoryType = "plugin"
|
|
)
|
|
|
|
type imlAPIService struct {
|
|
store api.IApiBaseStore `autowired:""`
|
|
apiInfoStore api.IAPIInfoStore `autowired:""`
|
|
requestCommitService commit.ICommitWithKeyService[Request] `autowired:""`
|
|
proxyCommitService commit.ICommitWithKeyService[Proxy] `autowired:""`
|
|
universally.IServiceGet[API]
|
|
universally.IServiceDelete
|
|
}
|
|
|
|
func (i *imlAPIService) ListLatestCommitRequest(ctx context.Context, aid ...string) ([]*commit.Commit[Request], error) {
|
|
return i.requestCommitService.ListLatest(ctx, aid...)
|
|
}
|
|
|
|
func (i *imlAPIService) LatestRequest(ctx context.Context, aid string) (*commit.Commit[Request], error) {
|
|
return i.requestCommitService.Latest(ctx, aid)
|
|
}
|
|
|
|
func (i *imlAPIService) GetRequestCommit(ctx context.Context, commitId string) (*commit.Commit[Request], error) {
|
|
return i.requestCommitService.Get(ctx, commitId)
|
|
}
|
|
|
|
func (i *imlAPIService) ListRequestCommit(ctx context.Context, commitId ...string) ([]*commit.Commit[Request], error) {
|
|
return i.requestCommitService.List(ctx, commitId...)
|
|
}
|
|
|
|
func (i *imlAPIService) SaveRequest(ctx context.Context, aid string, data *Request) error {
|
|
return i.requestCommitService.Save(ctx, aid, data)
|
|
}
|
|
|
|
func (i *imlAPIService) CountMapByService(ctx context.Context, service ...string) (map[string]int64, error) {
|
|
w := map[string]interface{}{}
|
|
if len(service) > 0 {
|
|
w["service"] = service
|
|
}
|
|
return i.store.CountByGroup(ctx, "", w, "service")
|
|
}
|
|
|
|
func (i *imlAPIService) ListInfoForService(ctx context.Context, serviceId string) ([]*Info, error) {
|
|
apis, err := i.store.List(ctx, map[string]interface{}{
|
|
"service": serviceId,
|
|
})
|
|
aids := utils.SliceToSlice(apis, func(a *api.API) int64 {
|
|
return a.Id
|
|
})
|
|
list, err := i.apiInfoStore.List(ctx, map[string]interface{}{
|
|
"service": serviceId,
|
|
"id": aids,
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return utils.SliceToSlice(list, FromEntityInfo), nil
|
|
}
|
|
|
|
func (i *imlAPIService) ListInfo(ctx context.Context, aids ...string) ([]*Info, error) {
|
|
w := map[string]interface{}{}
|
|
if len(aids) > 0 {
|
|
w["uuid"] = aids
|
|
}
|
|
list, err := i.apiInfoStore.List(ctx, w)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return utils.SliceToSlice(list, FromEntityInfo), nil
|
|
}
|
|
|
|
func (i *imlAPIService) GetInfo(ctx context.Context, aid string) (*Info, error) {
|
|
|
|
info, err := i.apiInfoStore.GetByUUID(ctx, aid)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return FromEntityInfo(info), nil
|
|
}
|
|
|
|
func (i *imlAPIService) Save(ctx context.Context, id string, model *Edit) error {
|
|
if model == nil {
|
|
return errors.New("input is nil")
|
|
}
|
|
return i.apiInfoStore.Transaction(ctx, func(ctx context.Context) error {
|
|
ev, err := i.apiInfoStore.GetByUUID(ctx, id)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if model.Name != nil {
|
|
ev.Name = *model.Name
|
|
}
|
|
|
|
if model.Description != nil {
|
|
ev.Description = *model.Description
|
|
}
|
|
if model.Protocols != nil {
|
|
ev.Protocol = *model.Protocols
|
|
}
|
|
if model.Path != nil {
|
|
ev.Path = *model.Path
|
|
}
|
|
if model.Match != nil {
|
|
ev.Match = *model.Match
|
|
}
|
|
if model.Methods != nil {
|
|
ev.Method = *model.Methods
|
|
}
|
|
if model.Disable != nil {
|
|
ev.Disable = *model.Disable
|
|
}
|
|
|
|
e := i.apiInfoStore.Save(ctx, ev)
|
|
if e != nil {
|
|
return e
|
|
}
|
|
return i.store.SetLabels(ctx, ev.Id, getLabels(ev)...)
|
|
|
|
})
|
|
}
|
|
func getLabels(input *api.Info, appends ...string) []string {
|
|
labels := make([]string, 0, len(appends)+9)
|
|
labels = append(labels, input.UUID, input.Name, input.Description, input.Path, input.Service, input.Team, input.Updater)
|
|
labels = append(labels, appends...)
|
|
return labels
|
|
}
|
|
func (i *imlAPIService) Create(ctx context.Context, input *Create) (err error) {
|
|
operater := utils.UserId(ctx)
|
|
return i.store.Transaction(ctx, func(ctx context.Context) error {
|
|
if input.UUID != "" {
|
|
_, err = i.store.GetByUUID(ctx, input.UUID)
|
|
if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return err
|
|
}
|
|
|
|
} else {
|
|
input.UUID = uuid.NewString()
|
|
}
|
|
|
|
ne := api.API{
|
|
UUID: input.UUID,
|
|
Name: input.Name,
|
|
Service: input.Service,
|
|
Team: input.Team,
|
|
Creator: operater,
|
|
CreateAt: time.Now(),
|
|
Method: input.Methods,
|
|
Path: input.Path,
|
|
}
|
|
err = i.store.Insert(ctx, &ne)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
ev := &api.Info{
|
|
Id: ne.Id,
|
|
UUID: ne.UUID,
|
|
Name: ne.Name,
|
|
Description: input.Description,
|
|
Updater: operater,
|
|
UpdateAt: time.Now(),
|
|
Creator: operater,
|
|
CreateAt: time.Now(),
|
|
Method: input.Methods,
|
|
Path: input.Path,
|
|
Match: input.Match,
|
|
Service: input.Service,
|
|
Team: input.Team,
|
|
}
|
|
err = i.apiInfoStore.Save(ctx, ev)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = i.store.SetLabels(ctx, ne.Id, getLabels(ev)...)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
})
|
|
}
|
|
|
|
func (i *imlAPIService) ListProxyCommit(ctx context.Context, commitId ...string) ([]*commit.Commit[Proxy], error) {
|
|
return i.proxyCommitService.List(ctx, commitId...)
|
|
}
|
|
|
|
func (i *imlAPIService) CountByService(ctx context.Context, service string) (int64, error) {
|
|
return i.store.CountWhere(ctx, map[string]interface{}{
|
|
"service": service,
|
|
})
|
|
}
|
|
|
|
func (i *imlAPIService) Exist(ctx context.Context, aid string, a *Exist) error {
|
|
list, err := i.store.Search(ctx, "", map[string]interface{}{
|
|
"path": a.Path,
|
|
})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
existMethodMap := make(map[string]struct{})
|
|
for _, t := range list {
|
|
if len(t.Method) == 0 {
|
|
if t.UUID != aid {
|
|
return fmt.Errorf("method(%v),path(%s) is exist", a.Methods, a.Path)
|
|
}
|
|
continue
|
|
}
|
|
if t.UUID == aid {
|
|
continue
|
|
}
|
|
|
|
for _, m := range t.Method {
|
|
|
|
existMethodMap[m] = struct{}{}
|
|
}
|
|
}
|
|
for _, m := range a.Methods {
|
|
if _, ok := existMethodMap[m]; ok {
|
|
|
|
return fmt.Errorf("method(%s),path(%s) is exist", m, a.Path)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (i *imlAPIService) ListForService(ctx context.Context, serviceId string) ([]*API, error) {
|
|
list, err := i.listForService(ctx, serviceId, false)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return utils.SliceToSlice(list, FromEntity), nil
|
|
}
|
|
func (i *imlAPIService) listForService(ctx context.Context, serviceId string, isDelete bool) ([]*api.API, error) {
|
|
return i.store.ListQuery(ctx, "service=? and is_delete=?", []interface{}{serviceId, isDelete}, "id")
|
|
}
|
|
func (i *imlAPIService) ListLatestCommitProxy(ctx context.Context, apiUUID ...string) ([]*commit.Commit[Proxy], error) {
|
|
|
|
return i.proxyCommitService.ListLatest(ctx, apiUUID...)
|
|
|
|
}
|
|
|
|
func (i *imlAPIService) LatestProxy(ctx context.Context, aid string) (*commit.Commit[Proxy], error) {
|
|
|
|
return i.proxyCommitService.Latest(ctx, aid)
|
|
}
|
|
|
|
func (i *imlAPIService) GetProxyCommit(ctx context.Context, commitId string) (*commit.Commit[Proxy], error) {
|
|
return i.proxyCommitService.Get(ctx, commitId)
|
|
}
|
|
|
|
func (i *imlAPIService) SaveProxy(ctx context.Context, aid string, data *Proxy) error {
|
|
|
|
return i.proxyCommitService.Save(ctx, aid, data)
|
|
}
|
|
|
|
func (i *imlAPIService) GetLabels(ctx context.Context, ids ...string) map[string]string {
|
|
if len(ids) == 0 {
|
|
return nil
|
|
}
|
|
list, err := i.apiInfoStore.ListQuery(ctx, "`uuid` in (?)", []interface{}{ids}, "id")
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
return utils.SliceToMapO(list, func(i *api.Info) (string, string) {
|
|
return i.UUID, i.Name
|
|
})
|
|
}
|
|
|
|
func (i *imlAPIService) OnComplete() {
|
|
i.IServiceGet = universally.NewGetSoftDelete[API, api.API](i.store, FromEntity)
|
|
|
|
i.IServiceDelete = universally.NewSoftDelete[api.API](i.store)
|
|
|
|
auto.RegisterService("api", i)
|
|
}
|