service

package
v0.0.0-...-55524bd Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 30, 2022 License: Apache-2.0 Imports: 53 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	OpCreate     = adaptor.OpCreate
	OpUpdate     = adaptor.OpUpdate
	OpEdit       = adaptor.OpEdit
	OpDelete     = adaptor.OpDelete
	OpQuery      = adaptor.OpQuery
	OpBuild      = adaptor.OpBuild
	OpRequest    = adaptor.OpRequest
	OpAddRawAPI  = adaptor.OpAddRawAPI
	OpAddPolyAPI = adaptor.OpAddPolyAPI
	OpAddService = adaptor.OpAddService
	OpAddSub     = adaptor.OpAddSub
	OpPublish    = adaptor.OpPublish
)

operations

Variables

This section is empty.

Functions

func DefultProxyFunc 

func DefultProxyFunc(c *gin.Context) (io.ReadCloser, error)

DefultProxyFunc is default ProxyFunc

Types

type APIOperator 

type APIOperator interface {
	QuerySwaggerInBatches(ctx context.Context, req *QueryAPISwaggerReq) (*QueryAPISwaggerResp, error)
}

APIOperator APIOperator

func NewAPIOperator 

func NewAPIOperator(cfg *config.Config) (APIOperator, error)

NewAPIOperator create apiOperator

type APIPermit 

type APIPermit interface {
	CheckAPIPermit(c context.Context, req *CheckPermitReq) (*CheckPermitResp, error)

	AddPermitGroup(c context.Context, req *AddPermitGroupReq) (*AddPermitGroupResp, error)
	DelPermitGroup(c context.Context, req *DelPermitGroupReq) (*DelPermitGroupResp, error)
	UpdatePermitGroup(c context.Context, req *UpdatePermitGroupReq) (*UpdatePermitGroupResp, error)
	ActivePermitGroup(c context.Context, req *ActivePermitGroupReq) (*ActivePermitGroupResp, error)
	ListPermitGroup(c context.Context, req *ListPermitGroupReq) (*ListPermitGroupResp, error)
	QueryPermitGroup(c context.Context, req *QueryPermitGroupReq) (*QueryPermitGroupResp, error)

	AddPermitElem(c context.Context, req *AddPermitElemReq) (*AddPermitElemResp, error)
	UpdatePermitElem(c context.Context, req *UpdatePermitElemReq) (*UpdatePermitElemResp, error)
	DelPermitElem(c context.Context, req *DelPermitElemReq) (*DelPermitElemResp, error)
	ActivePermitElem(c context.Context, req *ActivePermitElemReq) (*ActivePermitElemResp, error)
	ListPermitElem(c context.Context, req *ListPermitElemReq) (*ListPermitElemResp, error)
	QueryPermitElem(c context.Context, req *QueryPermitElemReq) (*QueryPermitElemResp, error)

	AddPermitGrant(c context.Context, req *AddPermitGrantReq) (*AddPermitGrantResp, error)
	DelPermitGrant(c context.Context, req *DelPermitGrantReq) (*DelPermitGrantResp, error)
	UpdatePermitGrant(c context.Context, req *UpdatePermitGrantReq) (*UpdatePermitGrantResp, error)
	ActivePermitGrant(c context.Context, req *ActivePermitGrantReq) (*ActivePermitGrantResp, error)
	ListPermitGrant(c context.Context, req *ListPermitGrantReq) (*ListPermitGrantResp, error)
	QueryPermitGrant(c context.Context, req *QueryPermitGrantReq) (*QueryPermitGrantResp, error)
}

APIPermit is the api permit operator

func CreateAPIPermit 

func CreateAPIPermit(conf *config.Config) (APIPermit, error)

CreateAPIPermit CreateAPIPermit

type APISchemaOper 

type APISchemaOper interface {
	GenSchema(ctx context.Context, req *GenSchemaReq) (*GenSchemaResp, error)
	QuerySchema(ctx context.Context, req *QuerySchemaReq) (*QuerySchemaResp, error)
	ListSchema(ctx context.Context, req *ListSchemaReq) (*ListSchemaResp, error)
	DeleteSchema(ctx context.Context, req *DeleteSchemaReq) (*DeleteSchemaResp, error)
	Request(ctx context.Context, req *SchemaRequestReq) (*SchemaRequestResp, error)
}

APISchemaOper represents the api schema operator

func CreateSchemaOper 

func CreateSchemaOper(cfg *config.Config) (APISchemaOper, error)

CreateSchemaOper new

type APIService 

type APIService interface {
	Delete(c context.Context, req *DeleteServiceReq) (*DeleteServiceResp, error)
	Update(c context.Context, req *UpdateServiceReq) (*UpdateServiceResp, error)
	UpdateProperty(c context.Context, req *UpdatePropertyReq) (*UpdatePropertyResp, error)
	Active(c context.Context, req *ActiveServiceReq) (*ActiveServiceResp, error)
	List(c context.Context, req *ListServiceReq) (*ListServiceResp, error)
	Query(c context.Context, service string) (*ServicesResp, error)
	Create(c context.Context, req *CreateServiceReq) (*CreateServiceResp, error)
	Check(c context.Context, service string, owner string, op Operation) (*ServicesResp, error)
}

APIService represents the api service operator

func CreateServiceOper 

func CreateServiceOper(conf *config.Config) (APIService, error)

CreateServiceOper create a namespace API operater

type APIStat 

type APIStat interface {
	IncTimeStat(c context.Context, apiPath string, raw bool, dur time.Duration) error
	//GetStat(c context.Context, apiPath string, raw bool) (int64, error)
	IsBlocked(c context.Context, apiPath string, raw bool) bool
}

APIStat represents the api stat operator

func CreateAPIStatOper 

func CreateAPIStatOper(conf *config.Config) (APIStat, error)

CreateAPIStatOper create a API stat operater

type ActiveNsReq 

type ActiveNsReq struct {
	NamespacePath string `json:"-"`
	Active        uint   `json:"active"`
}

ActiveNsReq ActiveNsReq

type ActiveNsResp 

type ActiveNsResp struct {
	FullPath string `json:"fullPath"`
	Active   uint   `json:"active"`
}

ActiveNsResp ActiveNsResp

type ActivePermitElemReq 

type ActivePermitElemReq struct {
	ID     string `json:"id"`
	Active uint   `json:"active"`
}

ActivePermitElemReq activePermitElemReq

type ActivePermitElemResp 

type ActivePermitElemResp struct {
}

ActivePermitElemResp activePermitElemResp

type ActivePermitGrantReq 

type ActivePermitGrantReq struct {
	ID     string `json:"id"`
	Active uint   `json:"active"`
}

ActivePermitGrantReq ActivePermitGrantReq

type ActivePermitGrantResp 

type ActivePermitGrantResp struct {
}

ActivePermitGrantResp ActivePermitGrantResp

type ActivePermitGroupReq 

type ActivePermitGroupReq struct {
	GroupPath string `json:"-"`
	Active    uint   `json:"active"`
}

ActivePermitGroupReq ActivePermitGroupResp

type ActivePermitGroupResp 

type ActivePermitGroupResp struct {
	FullPath string `json:"fullPath"`
}

ActivePermitGroupResp ActivePermitGroupResp

type ActiveReq 

type ActiveReq struct {
	APIPath string
	Active  uint `json:"active"`
}

ActiveReq ActiveReq

type ActiveResp 

type ActiveResp struct {
	FullPath string `json:"fullPath"`
	Active   uint   `json:"active"`
}

ActiveResp ActiveResp

type ActiveServiceReq 

type ActiveServiceReq struct {
	ServicePath string `json:"-"`
	Active      uint   `json:"active"`
}

ActiveServiceReq ActiveServiceReq

type ActiveServiceResp 

type ActiveServiceResp struct {
	FullPath string `json:"fullPath"`
	Active   uint   `json:"active"`
}

ActiveServiceResp ActiveServiceResp

type AddPermitElemReq 

type AddPermitElemReq struct {
	Owner     string `json:"-"`
	OwnerName string `json:"-"`
	GroupPath string `json:"-"`
	ElemType  string `json:"elemType"`
	ElemID    string `json:"elemID"`
	ElemPath  string `json:"elemPath"`
	Desc      string `json:"desc"`
	Content   string `json:"content"`
}

AddPermitElemReq AddPermitElemReq

type AddPermitElemResp 

type AddPermitElemResp = PermitElemResp

AddPermitElemResp AddPermitElemResp

type AddPermitGrantReq 

type AddPermitGrantReq struct {
	GroupPath string `json:"-"`
	Owner     string `json:"-"`
	OwnerName string `json:"-"`
	GrantType string `json:"grantType"`
	GrantID   string `json:"grantID"`
	GrantName string `json:"grantName"`
	Desc      string `json:"desc"`
}

AddPermitGrantReq AddPermitGrantReq

type AddPermitGrantResp 

type AddPermitGrantResp = PermitGrantResp

AddPermitGrantResp AddPermitGrantResp

type AddPermitGroupReq 

type AddPermitGroupReq struct {
	Owner     string `json:"-"`
	OwnerName string `json:"-"`
	Namespace string `json:"-"`
	Name      string `json:"name"`
	Title     string `json:"title"`
	Desc      string `json:"desc"`
}

AddPermitGroupReq AddPermitGroupReq

type AddPermitGroupResp 

type AddPermitGroupResp = PermitGroupResp

AddPermitGroupResp AddPermitGroupResp

type AppPathReq 

type AppPathReq struct {
	APPID    string `json:"appID" binding:"required,max=64"`
	PathType string `json:"pathType" binding:"required,max=64"`
}

AppPathReq AppPathReq

type AppPathResp 

type AppPathResp struct {
	APPID    string `json:"appID"`
	PathType string `json:"pathType"`
	APPPath  string `json:"appPath"`
}

AppPathResp AppPathResp

type CheckAuthReq 

type CheckAuthReq = adaptor.CheckAuthReq

CheckAuthReq CheckAuthReq

type CheckAuthResp 

type CheckAuthResp = adaptor.CheckAuthResp

CheckAuthResp CheckAuthResp

type CheckPermitReq 

type CheckPermitReq struct {
	AppID  string `json:"-"`
	UserID string `json:"-"`
	KeyID  string `json:"-"`
	APIID  string `json:"-"`
	Key3ID string `json:"-"`
}

CheckPermitReq CheckPermitReq

type CheckPermitResp 

type CheckPermitResp struct {
}

CheckPermitResp CheckPermitResp

type CreateNsReq 

type CreateNsReq = adaptor.CreateNsReq

CreateNsReq export

type CreateNsResp 

type CreateNsResp = adaptor.NamespaceResp

CreateNsResp export

type CreateRawPolyReq 

type CreateRawPolyReq = adaptor.CreateRawPolyReq

CreateRawPolyReq CreateRawPolyReq

type CreateRawPolyResp 

type CreateRawPolyResp = adaptor.CreateRawPolyResp

CreateRawPolyResp CreateRawPolyResp

type CreateServiceReq 

type CreateServiceReq struct {
	NamespacePath string `json:"-"`
	Owner         string `json:"-"`
	OwnerName     string `json:"-"`

	Name      string `json:"name"`
	Title     string `json:"title"`
	Desc      string `json:"desc"`
	Schema    string `json:"schema"`
	Host      string `json:"host"`
	AuthType  string `json:"authType"`
	Authorize string `json:"authorize"`
}

CreateServiceReq CreateServiceReq

type CreateServiceResp 

type CreateServiceResp struct {
	ID        string `json:"id"`
	Owner     string `json:"owner"`
	OwnerName string `json:"ownerName"`
	Namespace string `json:"namespace"`
	Name      string `json:"name"`
	Title     string `json:"title"`
	Desc      string `json:"desc"`
	Active    uint   `json:"active"`
	Schema    string `json:"schema"`
	Host      string `json:"host"`
	AuthType  string `json:"authType"`
	Authorize string `json:"authorize"`
	CreateAt  int64  `json:"createAt"`
	UpdateAt  int64  `json:"updateAt"`
}

CreateServiceResp CreateServiceResp

type DelAppReq 

type DelAppReq struct {
	AppID string
}

DelAppReq DelAppReq

type DelAppResp 

type DelAppResp struct {
	Errors []*ErrNode `json:"errors"`
}

DelAppResp DelAppResp

type DelPathReq 

type DelPathReq struct {
	NamespacePath string `json:"-"`
}

DelPathReq DelPathReq

type DelPathResp 

type DelPathResp struct {
	Errors []*ErrNode `json:"errors"`
}

DelPathResp DelPathResp

type DelPermitElemReq 

type DelPermitElemReq struct {
	ID string `json:"id"`
}

DelPermitElemReq DelPermitElemReq

type DelPermitElemResp 

type DelPermitElemResp struct {
}

DelPermitElemResp DelPermitElemResp

type DelPermitGrantReq 

type DelPermitGrantReq struct {
	ID string `json:"id"`
}

DelPermitGrantReq DelPermitGrantReq

type DelPermitGrantResp 

type DelPermitGrantResp struct {
}

DelPermitGrantResp DelPermitGrantResp

type DelPermitGroupReq 

type DelPermitGroupReq struct {
	GroupPath string `json:"-"`
}

DelPermitGroupReq DelPermitGroupReq

type DelPermitGroupResp 

type DelPermitGroupResp struct {
	FullPath string `json:"fulPath"`
}

DelPermitGroupResp DelPermitGroupResp

type DelReq 

type DelReq = adaptor.DelReq

DelReq DelReq

type DelResp 

type DelResp = adaptor.DelResp

DelResp DelResp

type DeleteByPolyAPIInBatchesReq 

type DeleteByPolyAPIInBatchesReq = adaptor.DeleteByPolyAPIInBatchesReq

DeleteByPolyAPIInBatchesReq DeleteByPolyAPIInBatchesReq

type DeleteByPolyAPIInBatchesResp 

type DeleteByPolyAPIInBatchesResp = adaptor.DeleteByPolyAPIInBatchesResp

DeleteByPolyAPIInBatchesResp DeleteByPolyAPIInBatchesResp

type DeleteByPolyAPIReq 

type DeleteByPolyAPIReq = adaptor.DeleteByPolyAPIReq

DeleteByPolyAPIReq DeleteByPolyAPIReq

type DeleteByPolyAPIResp 

type DeleteByPolyAPIResp = adaptor.DeleteByPolyAPIResp

DeleteByPolyAPIResp DeleteByPolyAPIResp

type DeleteByRawAPIReq 

type DeleteByRawAPIReq = adaptor.DeleteByRawAPIReq

DeleteByRawAPIReq DeleteByRawAPIReq

type DeleteByRawAPIResp 

type DeleteByRawAPIResp = adaptor.DeleteByRawAPIResp

DeleteByRawAPIResp DeleteByRawAPIResp

type DeleteCustomerKeyByPrefixReq 

type DeleteCustomerKeyByPrefixReq = adaptor.DeleteCustomerKeyByPrefixReq

DeleteCustomerKeyByPrefixReq DeleteCustomerKeyByPrefixReq

type DeleteCustomerKeyByPrefixResp 

type DeleteCustomerKeyByPrefixResp = adaptor.DeleteCustomerKeyByPrefixResp

DeleteCustomerKeyByPrefixResp DeleteCustomerKeyByPrefixResp

type DeleteCustomerKeyInBatchReq 

type DeleteCustomerKeyInBatchReq = adaptor.DeleteCustomerKeyInBatchReq

DeleteCustomerKeyInBatchReq DeleteCustomerKeyInBatchReq

type DeleteCustomerKeyInBatchResp 

type DeleteCustomerKeyInBatchResp = adaptor.DeleteCustomerKeyInBatchResp

DeleteCustomerKeyInBatchResp DeleteCustomerKeyInBatchResp

type DeleteNsReq 

type DeleteNsReq = adaptor.DeleteNsReq

DeleteNsReq DeleteNsReq

type DeleteNsResp 

type DeleteNsResp = adaptor.DeleteNsResp

DeleteNsResp DeleteNsResp

type DeleteSchemaReq 

type DeleteSchemaReq struct {
	APIPath string `json:"-"`
}

DeleteSchemaReq DeleteSchemaReq

type DeleteSchemaResp 

type DeleteSchemaResp struct {
}

DeleteSchemaResp DeleteSchemaResp

type DeleteServiceReq 

type DeleteServiceReq = adaptor.DeleteServiceReq

DeleteServiceReq DeleteServiceReq

type DeleteServiceResp 

type DeleteServiceResp = adaptor.DeleteServiceResp

DeleteServiceResp DelteServiceResp

type ErrNode 

type ErrNode struct {
	DB    string `json:"db"`
	Table string `json:"table"`
	SQL   string `json:"sql"`
	Err   error  `json:"error"`
}

ErrNode errNode

type ExportAppReq 

type ExportAppReq struct {
	AppID string `json:"-"`
}

ExportAppReq ExportAppReq

type ExportAppResp 

type ExportAppResp = ExportPathResp

ExportAppResp ExportAppResp

type ExportData 

type ExportData struct {
	Namespace []*adaptor.APINamespace `json:"ns"`
	Raw       []*adaptor.RawAPIFull   `json:"raw"`
	Poly      []*adaptor.PolyAPIFull  `json:"poly"`
	Service   []*adaptor.APIService   `json:"service"`
	RawPoly   []*adaptor.RawPoly      `json:"rawPoly"`
}

ExportData ExportData

type ExportPathReq 

type ExportPathReq struct {
	Path string `json:"-"`
}

ExportPathReq ExportPathReq

type ExportPathResp 

type ExportPathResp struct {
	Path string `json:"path"`
	Data string `json:"data"`
}

ExportPathResp ExportPathResp

type GenSchemaReq 

type GenSchemaReq struct {
	Owner     string `json:"-"`
	OwnerName string `json:"-"`
	APIPath   string `json:"namespace"`
	Title     string `json:"title"`
}

GenSchemaReq GenSchemaReq

type GenSchemaResp 

type GenSchemaResp struct {
}

GenSchemaResp GenSchemaResp

type ImportReq 

type ImportReq struct {
	NewID    string            `json:"newID"`
	OldID    string            `json:"oldID"`
	TableMap map[string]string `json:"tableMap"`
	Data     string            `json:"data"`
}

ImportReq ImportReq

type ImportResp 

type ImportResp struct{}

ImportResp ImportResp

type InitAppPathReq 

type InitAppPathReq = daprevent.EventInitAppPath

InitAppPathReq InitAppPathReq

type InitAppPathResp 

type InitAppPathResp struct {
	APPID string `json:"appID"`
}

InitAppPathResp InitAppPathResp

type InnerDelNsByPrefixPathReq 

type InnerDelNsByPrefixPathReq = adaptor.InnerDelNsByPrefixPathReq

InnerDelNsByPrefixPathReq InnerDelNsByPrefixPathReq

type InnerDelNsByPrefixPathResp 

type InnerDelNsByPrefixPathResp = adaptor.InnerDelNsByPrefixPathResp

InnerDelNsByPrefixPathResp InnerDelNsByPrefixPathResp

type InnerDelPolyByPrefixPathReq 

type InnerDelPolyByPrefixPathReq = adaptor.InnerDelPolyByPrefixPathReq

InnerDelPolyByPrefixPathReq InnerDelPolyByPrefixPathReq

type InnerDelPolyByPrefixPathResp 

type InnerDelPolyByPrefixPathResp = adaptor.InnerDelPolyByPrefixPathResp

InnerDelPolyByPrefixPathResp InnerDelPolyByPrefixPathResp

type InnerDelRawByPrefixPathReq 

type InnerDelRawByPrefixPathReq = adaptor.InnerDelRawByPrefixPathReq

InnerDelRawByPrefixPathReq InnerDelRawByPrefixPathReq

type InnerDelRawByPrefixPathResp 

type InnerDelRawByPrefixPathResp = adaptor.InnerDelRawByPrefixPathResp

InnerDelRawByPrefixPathResp InnerDelRawByPrefixPathResp

type InnerDelRawPolyByPrefixPathReq 

type InnerDelRawPolyByPrefixPathReq = adaptor.InnerDelRawPolyByPrefixPathReq

InnerDelRawPolyByPrefixPathReq InnerDelRawPolyByPrefixPathReq

type InnerDelRawPolyByPrefixPathResp 

type InnerDelRawPolyByPrefixPathResp = adaptor.InnerDelRawPolyByPrefixPathResp

InnerDelRawPolyByPrefixPathResp InnerDelRawPolyByPrefixPathResp

type InnerDelServiceByPrefixPathReq 

type InnerDelServiceByPrefixPathReq = adaptor.InnerDelServiceByPrefixPathReq

InnerDelServiceByPrefixPathReq InnerDelServiceByPrefixPathReq

type InnerDelServiceByPrefixPathResp 

type InnerDelServiceByPrefixPathResp = adaptor.InnerDelServiceByPrefixPathResp

InnerDelServiceByPrefixPathResp InnerDelServiceByPrefixPathResp

type InnerDeleteServiceReq 

type InnerDeleteServiceReq = adaptor.InnerDeleteServiceReq

InnerDeleteServiceReq InnerDeleteServiceReq

type InnerDeleteServiceResp 

type InnerDeleteServiceResp = adaptor.InnerDeleteServiceResp

InnerDeleteServiceResp InnerDeleteServiceResp

type InnerImportNsReq 

type InnerImportNsReq = adaptor.InnerImportNsReq

InnerImportNsReq InnerImportNsReq

type InnerImportNsResp 

type InnerImportNsResp = adaptor.InnerImportNsResp

InnerImportNsResp InnerImportNsResp

type InnerImportPolyReq 

type InnerImportPolyReq = adaptor.InnerImportPolyReq

InnerImportPolyReq InnerImportPolyReq

type InnerImportPolyResp 

type InnerImportPolyResp = adaptor.InnerImportPolyResp

InnerImportPolyResp InnerImportPolyResp

type InnerImportRawPolyReq 

type InnerImportRawPolyReq = adaptor.InnerImportRawPolyReq

InnerImportRawPolyReq InnerImportRawPolyReq

type InnerImportRawPolyResp 

type InnerImportRawPolyResp = adaptor.InnerImportRawPolyResp

InnerImportRawPolyResp InnerImportRawPolyResp

type InnerImportRawReq 

type InnerImportRawReq = adaptor.InnerImportRawReq

InnerImportRawReq InnerImportRawReq

type InnerImportRawResp 

type InnerImportRawResp = adaptor.InnerImportRawResp

InnerImportRawResp InnerImportRawResp

type InnerImportServiceReq 

type InnerImportServiceReq = adaptor.InnerImportServiceReq

InnerImportServiceReq InnerImportServiceReq

type InnerImportServiceResp 

type InnerImportServiceResp = adaptor.InnerImportServiceResp

InnerImportServiceResp InnerImportServiceResp

type InnerUpdateRawInBatchReq 

type InnerUpdateRawInBatchReq = adaptor.InnerUpdateRawInBatchReq

InnerUpdateRawInBatchReq InnerUpdateRawInBatchReq

type InnerUpdateRawInBatchResp 

type InnerUpdateRawInBatchResp = adaptor.InnerUpdateRawInBatchResp

InnerUpdateRawInBatchResp InnerUpdateRawInBatchResp

type KMSAgent 

type KMSAgent interface {
	Proxy(c *gin.Context, proxy ProxyFunc) error
	Authorize(c context.Context, keyUUID string, body json.RawMessage, header http.Header) (*KMSAuthorizeResp, error)
	ListCustomerAPIKey(c context.Context, req *ListKMSCustomerKeyReq) (*ListKMSCustomerKeyResp, error)
	QueryCustomerAPIKey(c context.Context, keyUUID string) (*QueryKMSCustomerKeyResp, error)
	UpdateCustomerKeyInBatch(c context.Context, req *UpdateCustomerKeyInBatchReq) (*UpdateCustomerKeyInBatchResp, error)
	DeleteCustomerKeyInBatch(c context.Context, req *DeleteCustomerKeyInBatchReq) (*DeleteCustomerKeyInBatchResp, error)
	DeleteCustomerKeyByPrefix(c context.Context, req *DeleteCustomerKeyByPrefixReq) (*DeleteCustomerKeyByPrefixResp, error)
}

KMSAgent represents the kms agent

func CreateKMSAgent 

func CreateKMSAgent(conf *config.Config) (KMSAgent, error)

CreateKMSAgent CreateKMSAgent

type KMSAuthorizeResp 

type KMSAuthorizeResp = adaptor.KMSAuthorizeResp

KMSAuthorizeResp exports

type KMSCustomerKey 

type KMSCustomerKey = adaptor.KMSCustomerKey

KMSCustomerKey key info except secret

type ListInServiceReq 

type ListInServiceReq = adaptor.ListInServiceReq

ListInServiceReq ListInServiceReq

type ListInServiceResp 

type ListInServiceResp = adaptor.ListInServiceResp

ListInServiceResp ListInServiceResp

type ListKMSCustomerKeyReq 

type ListKMSCustomerKeyReq = adaptor.ListKMSCustomerKeyReq

ListKMSCustomerKeyReq req

type ListKMSCustomerKeyResp 

type ListKMSCustomerKeyResp = adaptor.ListKMSCustomerKeyResp

ListKMSCustomerKeyResp resp

type ListNsByPrefixPathReq 

type ListNsByPrefixPathReq = adaptor.ListNsByPrefixPathReq

ListNsByPrefixPathReq ListNsByPrefixPathReq

type ListNsByPrefixPathResp 

type ListNsByPrefixPathResp = adaptor.ListNsByPrefixPathResp

ListNsByPrefixPathResp ListNsByPrefixPathResp

type ListNsReq 

type ListNsReq = adaptor.ListNsReq

ListNsReq ListNsReq

type ListNsResp 

type ListNsResp = adaptor.ListNsResp

ListNsResp ListNsResp

type ListPermitElemReq 

type ListPermitElemReq struct {
	GroupPath string `json:"-"`
	Page      int    `json:"page"`
	PageSize  int    `json:"pageSize"`
}

ListPermitElemReq ListPermitElemReq

type ListPermitElemResp 

type ListPermitElemResp struct {
	Total int               `json:"total"`
	Page  int               `json:"page"`
	List  []*PermitElemResp `json:"list"`
}

ListPermitElemResp ListPermitElemResp

type ListPermitGrantReq 

type ListPermitGrantReq struct {
	GroupPath string `json:"-"`
	Page      int    `json:"page"`
	PageSize  int    `json:"pageSize"`
}

ListPermitGrantReq ListPermitGrantReq

type ListPermitGrantResp 

type ListPermitGrantResp struct {
	Total int                `json:"total"`
	Page  int                `json:"page"`
	List  []*PermitGrantResp `json:"list"`
}

ListPermitGrantResp ListPermitGrantResp

type ListPermitGroupNode 

type ListPermitGroupNode = PermitGroupResp

ListPermitGroupNode listPermitGroupNode

type ListPermitGroupReq 

type ListPermitGroupReq struct {
	Namespace string `json:"-"`
	Page      int    `json:"page"`
	PageSize  int    `json:"pageSize"`
}

ListPermitGroupReq ListPermitGroupReq

type ListPermitGroupResp 

type ListPermitGroupResp struct {
	Total int                    `json:"total"`
	Page  int                    `json:"page"`
	List  []*ListPermitGroupNode `json:"list"`
}

ListPermitGroupResp ListPermitGroupResp

type ListPolyByPrefixPathReq 

type ListPolyByPrefixPathReq = adaptor.ListPolyByPrefixPathReq

ListPolyByPrefixPathReq ListPolyByPrefixPathReq

type ListPolyByPrefixPathResp 

type ListPolyByPrefixPathResp = adaptor.ListPolyByPrefixPathResp

ListPolyByPrefixPathResp ListPolyByPrefixPathResp

type ListRawByPrefixPathReq 

type ListRawByPrefixPathReq = adaptor.ListRawByPrefixPathReq

ListRawByPrefixPathReq ListRawByPrefixPathReq

type ListRawByPrefixPathResp 

type ListRawByPrefixPathResp = adaptor.ListRawByPrefixPathResp

ListRawByPrefixPathResp ListRawByPrefixPathResp

type ListRawPolyByPrefixPathReq 

type ListRawPolyByPrefixPathReq = adaptor.ListRawPolyByPrefixPathReq

ListRawPolyByPrefixPathReq ListRawPolyByPrefixPathReq

type ListRawPolyByPrefixPathResp 

type ListRawPolyByPrefixPathResp = adaptor.ListRawPolyByPrefixPathResp

ListRawPolyByPrefixPathResp ListRawPolyByPrefixPathResp

type ListSchemaNode 

type ListSchemaNode = adaptor.APISchema

ListSchemaNode ListSchemaNode

type ListSchemaReq 

type ListSchemaReq struct {
	NamespacePath string `json:"-"`
	WithSub       bool   `json:"withSub"`
	Page          int    `json:"page"`
	PageSize      int    `json:"pageSize"`
}

ListSchemaReq ListSchemaReq

type ListSchemaResp 

type ListSchemaResp struct {
	Total int64             `json:"total"`
	List  []*ListSchemaNode `json:"list"`
}

ListSchemaResp ListSchemaResp

type ListServiceByPrefixReq 

type ListServiceByPrefixReq = adaptor.ListServiceByPrefixReq

ListServiceByPrefixReq ListServiceByPrefixReq

type ListServiceByPrefixResp 

type ListServiceByPrefixResp = adaptor.ListServiceByPrefixResp

ListServiceByPrefixResp ListServiceByPrefixResp

type ListServiceReq 

type ListServiceReq = adaptor.ListServiceReq

ListServiceReq ListServiceReq

type ListServiceResp 

type ListServiceResp = adaptor.ListServiceResp

ListServiceResp ListServiceResp

type NamespaceAPI 

type NamespaceAPI interface {
	Create(c context.Context, req *CreateNsReq) (*CreateNsResp, error)
	Delete(c context.Context, req *DeleteNsReq) (*DeleteNsResp, error)
	InnerDelete(c context.Context, req *DeleteNsReq) (*DeleteNsResp, error)
	Update(c context.Context, req *UpdateNsReq) (*UpdateNsResp, error)
	Active(c context.Context, req *ActiveNsReq) (*ActiveNsResp, error)
	List(c context.Context, req *ListNsReq) (*ListNsResp, error)
	Query(c context.Context, namespace string) (*NamespaceResp, error)
	Check(c context.Context, namespace string, owner string, op Operation) (*NamespaceResp, error)
	APPPath(c context.Context, req *AppPathReq) (*AppPathResp, error)
	InitAPPPath(c context.Context, req *InitAppPathReq) (*InitAppPathResp, error)
	Search(c context.Context, req *SearchNsReq) (*SearchNsResp, error)
	Tree(c context.Context, req *NsTreeReq) (*NsTreeResp, error)
}

NamespaceAPI represents the namespace api operator

func CreateNamespaceOper 

func CreateNamespaceOper(conf *config.Config) (NamespaceAPI, error)

CreateNamespaceOper create a namespace API operater

type NamespaceResp 

type NamespaceResp = adaptor.NamespaceResp

NamespaceResp export

type NsTreeNode 

type NsTreeNode struct {
	NamespaceResp
	Children []*NsTreeNode `json:"children"`
}

NsTreeNode NsTreeNode

type NsTreeReq 

type NsTreeReq struct {
	RootPath string `json:"-"`
	Active   int    `json:"active"`
}

NsTreeReq NsTreeReq

type NsTreeResp 

type NsTreeResp struct {
	Root NsTreeNode `json:"root"`
}

NsTreeResp NsTreeResp

type Operation 

type Operation = adaptor.Operation

Operation exports

type PathOperator 

type PathOperator interface {
	UpdateAppValid(ctx context.Context, req *UpdateAppValidReq) (*UpdateAppValidResp, error)
	UpdateValidByPath(ctx context.Context, req *UpdateValidByPathReq) (*UpdateValidByPathResp, error)
	DelApp(ctx context.Context, req *DelAppReq) (*DelAppResp, error)
	DelPath(ctx context.Context, req *DelPathReq) (*DelPathResp, error)
	ExportApp(ctx context.Context, req *ExportAppReq) (*ExportAppResp, error)
	ExportPath(ctx context.Context, req *ExportPathReq) (*ExportPathResp, error)
	Import(ctx context.Context, req *ImportReq) (*ImportResp, error)
}

PathOperator PathOperator

func CreateOperator 

func CreateOperator(conf *config.Config) (PathOperator, error)

CreateOperator create operator

type PermitElemResp 

type PermitElemResp struct {
	ID        string `json:"id"`
	Owner     string `json:"owner"`
	OwnerName string `json:"ownerName"`
	GroupPath string `json:"groupPath"`
	ElemType  string `json:"elemType"`
	ElemID    string `json:"elemID"`
	ElemPath  string `json:"elemPath"`
	Desc      string `json:"desc"`
	ElemPri   uint   `json:"elemPri"`
	Content   string `json:"content"`
	Active    uint   `json:"active"`
	CreateAt  int64  `json:"createAt"`
	UpdateAt  int64  `json:"updateAt"`
}

PermitElemResp PermitElemResp

type PermitGrantResp 

type PermitGrantResp struct {
	ID        string `json:"id"`
	Owner     string `json:"owner"`
	OwnerName string `json:"ownerName"`
	GroupPath string `json:"groupPath"`
	GrantType string `json:"grantType"`
	GrantID   string `json:"grantID"`
	GrantName string `json:"grantName"`
	GrantPri  uint   `json:"grantPri"`
	Active    uint   `json:"active"`
	Desc      string `json:"desc"`
	CreateAt  int64  `json:"createAt"`
	UpdateAt  int64  `json:"updateAt"`
}

PermitGrantResp PermitGrantResp

type PermitGroupResp 

type PermitGroupResp struct {
	ID        string `json:"id"`
	Owner     string `json:"owner"`
	OwnerName string `json:"ownerName"`
	Namespace string `json:"namespace"`
	Name      string `json:"name"`
	Title     string `json:"title"`
	Desc      string `json:"desc"`
	Access    uint   `json:"access"`
	Active    uint   `json:"active"`
	CreateAt  int64  `json:"createAt"`
	UpdateAt  int64  `json:"updateAt"`
}

PermitGroupResp PermitGroupResp

type PolyAPI 

type PolyAPI interface {
	Create(c context.Context, req *PolyCreateReq) (*PolyCreateResp, error)
	Delete(c context.Context, req *PolyDeleteReq) (*PolyDeleteResp, error)
	// InnerDelete(c context.Context, req *PolyDeleteReq) (*PolyDeleteResp, error)
	UpdateArrange(c context.Context, req *PolyUpdateArrangeReq) (*PolyUpdateArrangeResp, error)
	UpdateScript(c context.Context, req *PolyUpdateScriptReq) (*PolyUpdateScriptResp, error)
	GetArrange(c context.Context, req *PolyGetArrangeReq) (*PolyGetArrangeResp, error)
	GetScript(c context.Context, req *PolyGetScriptReq) (*PolyGetScriptResp, error)
	Build(c context.Context, req *PolyBuildReq) (*PolyBuildResp, error)
	ShowEnum(c context.Context, req *PolyEnumReq) (*PolyEnumResp, error)
	List(c context.Context, req *PolyListReq) (*PolyListResp, error)
	Active(c context.Context, req *PolyActiveReq) (*PolyActiveResp, error)
	Search(c context.Context, req *SearchPolyReq) (*SearchPolyResp, error)

	QuerySwagger(ctx context.Context, req *QueryPolySwaggerReq) (*QueryPolySwaggerResp, error)

	apiprovider.Provider
}

PolyAPI represents the service of poly api operator

func CreatePoly 

func CreatePoly(conf *config.Config) (PolyAPI, error)

CreatePoly create poly api operator

type PolyActiveReq 

type PolyActiveReq struct {
	APIPath string
	Active  uint `json:"active"`
}

PolyActiveReq PolyActiveReq

type PolyActiveResp 

type PolyActiveResp struct {
	FullPath string `json:"fullPath"`
	Active   uint   `json:"active"`
}

PolyActiveResp PolyActiveResp

type PolyBuildReq 

type PolyBuildReq struct {
	Owner   string `json:"-"`
	APIPath string `json:"-" binding:"-"`               //
	Arrange string `json:"arrange"  binding:"required"` // arrange info
}

PolyBuildReq PolyBuildReq

type PolyBuildResp 

type PolyBuildResp struct {
	APIPath string `json:"apiPath"` //
}

PolyBuildResp PolyBuildResp

type PolyCreateReq 

type PolyCreateReq struct {
	Namespace string `json:"-" binding:"-"`
	Owner     string `json:"-" binding:"-"` // owner
	OwnerName string `json:"-" binding:"-"` // owner

	Name  string `json:"name" binding:"required,max=128"` // name
	Title string `json:"title" binding:"max=64"`
	Desc  string `json:"desc" binding:"max=4096"`
	//Access          []string `json:"access" binding:"max=64"`
	Method          string `json:"method" binding:"max=64"`
	TemplateAPIPath string `json:"templateAPIPath" binding:"max=512"` // template poly API path
}

PolyCreateReq PolyCreateReq

type PolyCreateResp 

type PolyCreateResp struct {
	ID      string `json:"id"`      // uuid
	APIPath string `json:"apiPath"` //
	//Access    []string  `json:"access"`
	Active    uint   `json:"active"`
	Method    string `json:"method"`
	Owner     string `json:"owner"`
	OwnerName string `json:"ownerName"`
	Arrange   string `json:"arrange"`  // arrange info
	CreateAt  int64  `json:"createAt"` // create time
	UpdateAt  int64  `json:"updateAt"` // update time
}

PolyCreateResp PolyCreateResp

type PolyDeleteReq 

type PolyDeleteReq = adaptor.PolyDeleteReq

PolyDeleteReq PolyDeleteReq

type PolyDeleteResp 

type PolyDeleteResp = adaptor.PolyDeleteResp

PolyDeleteResp PolyDeleteResp

type PolyEnumElem 

type PolyEnumElem struct {
	Name   string      `json:"name"`
	View   string      `json:"view"`
	Sample interface{} `json:"sample"`
}

PolyEnumElem PolyEnumElem

type PolyEnumReq 

type PolyEnumReq struct {
	Type   string `json:"-" binding:"-"`
	Sample bool   `json:"sample"`
}

PolyEnumReq PolyEnumReq

type PolyEnumResp 

type PolyEnumResp struct {
	EnumType string         `json:"enumType"`
	List     []PolyEnumElem `json:"list"`
}

PolyEnumResp PolyEnumResp

type PolyGetArrangeReq 

type PolyGetArrangeReq struct {
	APIPath string `json:"-" binding:"-"` //
}

PolyGetArrangeReq PolyGetArrangeReq

type PolyGetArrangeResp 

type PolyGetArrangeResp struct {
	ID        string `json:"id"`        // uuid
	Namespace string `json:"namespace"` //
	Name      string `json:"name"`      //
	Title     string `json:"title"`     //
	Desc      string `json:"desc"`      //
	Owner     string `json:"owner"`
	OwnerName string `json:"ownerName"`
	//Access    []string       `json:"access"` //
	Active   uint   `json:"active"`
	Method   string `json:"method"`   //
	Arrange  string `json:"arrange"`  // arrange info
	CreateAt int64  `json:"createAt"` // create time
	UpdateAt int64  `json:"updateAt"` // update time
	BuildAt  int64  `json:"buildAt"`  // build time
}

PolyGetArrangeResp PolyGetArrangeResp

type PolyGetScriptReq 

type PolyGetScriptReq struct {
	APIPath string `json:"-" binding:"-"` //
}

PolyGetScriptReq PolyGetScriptReq

type PolyGetScriptResp 

type PolyGetScriptResp struct {
	ID      string `json:"id"`      // uuid
	APIPath string `json:"apiPath"` //
	Script  string `json:"-"`       // js script
	BuildAt int64  `json:"buildAt"` // build time
}

PolyGetScriptResp PolyGetScriptResp

type PolyListNode 

type PolyListNode = adaptor.PolyListNode

PolyListNode node

type PolyListReq 

type PolyListReq = adaptor.PolyListReq

PolyListReq polyListReq

type PolyListResp 

type PolyListResp = adaptor.PolyListResp

PolyListResp PolyListResp

type PolyUpdateArrangeReq 

type PolyUpdateArrangeReq struct {
	Owner   string `json:"-"`
	APIPath string `json:"-" binding:"-"` //
	Title   string `json:"title" binding:"max=64"`
	Desc    string `json:"desc" binding:"max=4096"`
	Arrange string `json:"arrange" binding:"required"` // arrange info
}

PolyUpdateArrangeReq PolyUpdateArrangeReq

type PolyUpdateArrangeResp 

type PolyUpdateArrangeResp struct {
	APIPath string `json:"apiPath"`
}

PolyUpdateArrangeResp PolyUpdateArrangeResp

type PolyUpdateScriptReq 

type PolyUpdateScriptReq struct {
	APIPath string `json:"-" binding:"-"`             //
	Script  string `json:"script" binding:"required"` // arrange info
	Doc     string `json:"doc"`                       // api doc
}

PolyUpdateScriptReq PolyUpdateScriptReq

type PolyUpdateScriptResp 

type PolyUpdateScriptResp struct {
	APIPath string `json:"apiPath"`
}

PolyUpdateScriptResp PolyUpdateScriptResp

type PolyValidByPrefixPathReq 

type PolyValidByPrefixPathReq = adaptor.PolyValidByPrefixPathReq

PolyValidByPrefixPathReq PolyValidByPrefixPathReq

type PolyValidByPrefixPathResp 

type PolyValidByPrefixPathResp = adaptor.PolyValidByPrefixPathResp

PolyValidByPrefixPathResp PolyValidByPrefixPathResp

type PolyValidInBatchesReq 

type PolyValidInBatchesReq = adaptor.PolyValidInBatchesReq

PolyValidInBatchesReq PolyValidInBatchesReq

type PolyValidInBatchesResp 

type PolyValidInBatchesResp = adaptor.PolyValidInBatchesResp

PolyValidInBatchesResp PolyValidInBatchesResp

type PolyValidReq 

type PolyValidReq struct {
	APIPath string `json:"-"`
	Valid   uint   `json:"valid"`
}

PolyValidReq PolyValidReq

type PolyValidResp 

type PolyValidResp struct {
	FullPath string `json:"fullPath"`
	Valid    uint   `json:"valid"`
}

PolyValidResp PolyValidResp

type ProxyFunc 

type ProxyFunc func(c *gin.Context) (io.ReadCloser, error)

ProxyFunc is the function to make proxy body

type QueryAPISwaggerReq 

type QueryAPISwaggerReq struct {
	APIPath []string `json:"apiPath"`
}

QueryAPISwaggerReq QueryAPISwaggerReq

type QueryAPISwaggerResp 

type QueryAPISwaggerResp struct {
	Swag *swagger.SwagDoc `json:"swag"`
}

QueryAPISwaggerResp QueryAPISwaggerResp

type QueryByPolyAPIReq 

type QueryByPolyAPIReq = adaptor.QueryByPolyAPIReq

QueryByPolyAPIReq QueryByPolyAPIReq

type QueryByPolyAPIResp 

type QueryByPolyAPIResp = adaptor.QueryByPolyAPIResp

QueryByPolyAPIResp QueryByPolyAPIResp

type QueryByRawAPIReq 

type QueryByRawAPIReq = adaptor.QueryByRawAPIReq

QueryByRawAPIReq QueryByRawAPIReq

type QueryByRawAPIResp 

type QueryByRawAPIResp = adaptor.QueryByRawAPIResp

QueryByRawAPIResp QueryByRawAPIResp

type QueryInBatchesReq 

type QueryInBatchesReq = adaptor.QueryRawAPIInBatchesReq

QueryInBatchesReq QueryInBatchesReq

type QueryInBatchesResp 

type QueryInBatchesResp = adaptor.QueryRawAPIInBatchesResp

QueryInBatchesResp QueryInBatchesResp

type QueryKMSCustomerKeyResp 

type QueryKMSCustomerKeyResp = adaptor.QueryKMSCustomerKeyResp

QueryKMSCustomerKeyResp resp

type QueryPermitElemReq 

type QueryPermitElemReq struct {
	ID string `json:"id"`
}

QueryPermitElemReq QueryPermitElemReq

type QueryPermitElemResp 

type QueryPermitElemResp = PermitElemResp

QueryPermitElemResp QueryPermitElemResp

type QueryPermitGrantReq 

type QueryPermitGrantReq struct {
	ID string `json:"id"`
}

QueryPermitGrantReq QueryPermitGrantReq

type QueryPermitGrantResp 

type QueryPermitGrantResp = PermitGrantResp

QueryPermitGrantResp QueryPermitGrantResp

type QueryPermitGroupReq 

type QueryPermitGroupReq struct {
	GroupPath string `json:"-"`
}

QueryPermitGroupReq QueryPermitGroupReq

type QueryPermitGroupResp 

type QueryPermitGroupResp = PermitGroupResp

QueryPermitGroupResp QueryPermitGroupResp

type QueryPolySwaggerReq 

type QueryPolySwaggerReq = adaptor.QueryPolySwaggerReq

QueryPolySwaggerReq QueryPolySwaggerReq

type QueryPolySwaggerResp 

type QueryPolySwaggerResp = adaptor.QueryPolySwaggerResp

QueryPolySwaggerResp QueryPolySwaggerResp

type QueryRawSwaggerReq 

type QueryRawSwaggerReq = adaptor.QueryRawSwaggerReq

QueryRawSwaggerReq QueryRawSwaggerReq

type QueryRawSwaggerResp 

type QueryRawSwaggerResp = adaptor.QueryRawSwaggerResp

QueryRawSwaggerResp QueryRawSwaggerResp

type QueryReq 

type QueryReq = adaptor.QueryRawAPIReq

QueryReq QueryReq

type QueryResp 

type QueryResp = adaptor.QueryRawAPIResp

QueryResp QueryResp

type QuerySchemaReq 

type QuerySchemaReq struct {
	APIPath string `json:"-"`
}

QuerySchemaReq QuerySchemaReq

type QuerySchemaResp 

type QuerySchemaResp struct {
	ID           string          `json:"id"`
	Namespace    string          `json:"namespace"`
	Service      string          `json:"serivce"`
	Name         string          `json:"name"`
	Title        string          `json:"title"`
	Desc         string          `json:"desc"`
	InputSchema  json.RawMessage `json:"inputSchema"`
	OutputSchema json.RawMessage `json:"outputSchema"`
	CreateAt     int64           `json:"createAt"`
	UpdateAt     int64           `json:"updateAt"`
}

QuerySchemaResp QuerySchemaResp

type RawAPI 

type RawAPI interface {
	RegSwagger(c context.Context, req *RegReq) (*RegResp, error)
	Del(c context.Context, req *DelReq) (*DelResp, error)
	// InnerDel(c context.Context, req *DelReq) (*DelResp, error)
	List(c context.Context, req *RawListReq) (*RawListResp, error)
	ListInService(c context.Context, req *ListInServiceReq) (*ListInServiceResp, error)
	Active(c context.Context, req *ActiveReq) (*ActiveResp, error)
	Query(c context.Context, req *QueryReq) (*QueryResp, error)
	Search(c context.Context, req *SearchRawReq) (*SearchRawResp, error)

	QuerySwagger(ctx context.Context, req *QueryRawSwaggerReq) (*QueryRawSwaggerResp, error)

	apiprovider.Provider
}

RawAPI represents the raw api operator

func CreateRaw 

func CreateRaw(conf *config.Config) (RawAPI, error)

CreateRaw create a raw API operater

type RawListNode 

type RawListNode = adaptor.RawListNode

RawListNode RawListNode

type RawListReq 

type RawListReq = adaptor.RawListReq

RawListReq RawListReq

type RawListResp 

type RawListResp = adaptor.RawListResp

RawListResp RawListResp

type RawPoly 

type RawPoly interface {
	CreateInBatches(ctx context.Context, req *CreateRawPolyReq) (*CreateRawPolyResp, error)
	DeleteByRawAPI(ctx context.Context, req *DeleteByRawAPIReq) (*DeleteByRawAPIResp, error)
	DeleteByPolyAPI(ctx context.Context, req *DeleteByPolyAPIReq) (*DeleteByPolyAPIResp, error)
	QueryByRawAPI(ctx context.Context, req *QueryByRawAPIReq) (*QueryByRawAPIResp, error)
	QueryByPolyAPI(ctx context.Context, req *QueryByPolyAPIReq) (*QueryByPolyAPIResp, error)
	UpdateRawPoly(ctx context.Context, req *UpdateRawPolyReq) (*UpdateRawPolyResp, error)
}

RawPoly is the raw_poly operator

func CreateRawPoly 

func CreateRawPoly(conf *config.Config) (RawPoly, error)

CreateRawPoly create raw_poly operator

type RawPolyResp 

type RawPolyResp = adaptor.RawPolyResp

RawPolyResp RawPolyResp

type RawValidByPrefixPathReq 

type RawValidByPrefixPathReq = adaptor.RawValidByPrefixPathReq

RawValidByPrefixPathReq RawValidByPrefixPathReq

type RawValidByPrefixPathResp 

type RawValidByPrefixPathResp = adaptor.RawValidByPrefixPathResp

RawValidByPrefixPathResp RawValidByPrefixPathResp

type RawValidInBatchesReq 

type RawValidInBatchesReq = adaptor.RawValidInBatchesReq

RawValidInBatchesReq RawValidInBatchesReq

type RawValidInBatchesResp 

type RawValidInBatchesResp = adaptor.RawValidInBatchesResp

RawValidInBatchesResp RawValidInBatchesResp

type RawValidReq 

type RawValidReq = struct {
	APIPath string
	Valid   uint `json:"valid"`
}

RawValidReq RawValidReq

type RawValidResp 

type RawValidResp struct {
	FullPath string `json:"fullPath"`
	Valid    uint   `json:"valid"`
}

RawValidResp RawValidResp

type RegID 

type RegID struct {
	Path string `json:"path"`
}

RegID RegID

type RegReq 

type RegReq struct {
	Service   string `json:"-" binding:"-"`
	Owner     string `json:"-" binding:"-"`
	OwnerName string `json:"-" binding:"-"`

	Namespace  string `json:"namespace" binding:"max=384"`
	Swagger    string `json:"swagger" binding:"max=4096000"`
	Version    string `json:"version" binding:"max=32"`
	SingleName string `json:"singleName" binding:"max=64"` // api name when has only 1 api in swagger

	Schema   string `json:"schema" binding:"max=64"`
	Host     string `json:"host" binding:"max=64"`
	AuthType string `json:"authType" binding:"max=64"` //system, none, signature

	// auto create leaf namespace
	AutoCreateNamespaceTitle string `json:"autoCreateNamespaceTitle" binding:"max=64"`
}

RegReq RegReq

type RegResp 

type RegResp struct {
	List []RegID `json:"list"`
}

RegResp RegResp

type SchemaRequestReq 

type SchemaRequestReq struct {
	Owner   string          `json:"-"`
	APIPath string          `json:"-"`
	APIType string          `json:"-"`
	Method  string          `json:"-"`
	Entity  json.RawMessage `json:"entity"`
	Header  http.Header     `json:"-"`
}

SchemaRequestReq SchemaRequestReq

type SchemaRequestResp 

type SchemaRequestResp = apiprovider.RequestResp

SchemaRequestResp SchemaRequestResp

type SearchNsReq 

type SearchNsReq struct {
	NamespacePath string `json:"-"`
	Namespace     string `json:"namespace"`
	Title         string `json:"title"`
	Active        int    `json:"active"`
	WithSub       bool   `json:"withSub"`
	Page          int    `json:"page"`
	PageSize      int    `json:"pageSize"`
}

SearchNsReq SearchNsReq

type SearchNsResp 

type SearchNsResp struct {
	Total int              `json:"total"`
	Page  int              `json:"page"`
	List  []*NamespaceResp `json:"list"`
}

SearchNsResp SearchNsResp

type SearchPolyReq 

type SearchPolyReq struct {
	Namespace string `json:"namespace"`
	Name      string `json:"name"`
	Title     string `json:"title"`
	Active    int    `json:"active"`
	Page      int    `json:"page"`
	PageSize  int    `json:"pageSize"`
	WithSub   bool   `json:"withSub"`
}

SearchPolyReq SearchPolyReq

type SearchPolyResp 

type SearchPolyResp struct {
	Total int             `json:"total"`
	Page  int             `json:"page"`
	List  []*PolyListNode `json:"list"`
}

SearchPolyResp SearchPolyResp

type SearchRawReq 

type SearchRawReq struct {
	NamespacePath string `json:"-"`
	Name          string `json:"name"`
	Title         string `json:"title"`
	Active        int    `json:"active"`
	Page          int    `json:"page"`
	PageSize      int    `json:"pageSize"`
	WithSub       bool   `json:"withSub"`
}

SearchRawReq SearchRawReq

type SearchRawResp 

type SearchRawResp struct {
	Total int            `json:"total"`
	Page  int            `json:"page"`
	List  []*RawListNode `json:"list"`
}

SearchRawResp SearchRawResp

type ServicesResp 

type ServicesResp = adaptor.ServicesResp

ServicesResp exports

type UpdateAppValidReq 

type UpdateAppValidReq struct {
	AppID string `json:"-"`
	Valid uint   `json:"valid"`
}

UpdateAppValidReq UpdateAppValidReq

type UpdateAppValidResp 

type UpdateAppValidResp struct {
	Errors []error `json:"errors"`
}

UpdateAppValidResp UpdateAppValidResp

type UpdateCustomerKeyInBatchReq 

type UpdateCustomerKeyInBatchReq = adaptor.UpdateCustomerKeyInBatchReq

UpdateCustomerKeyInBatchReq UpdateCustomerAPIKeyInBatchReq

type UpdateCustomerKeyInBatchResp 

type UpdateCustomerKeyInBatchResp = adaptor.UpdateCustomerKeyInBatchResp

UpdateCustomerKeyInBatchResp UpdateCustomerAPIKeyInBatchResp

type UpdateNsReq 

type UpdateNsReq = adaptor.UpdateNsReq

UpdateNsReq UpdateNsReq

type UpdateNsResp 

type UpdateNsResp = adaptor.UpdateNsResp

UpdateNsResp UpdateNsResp

type UpdateNsValidReq 

type UpdateNsValidReq = adaptor.UpdateNsValidReq

UpdateNsValidReq UpdateNsValidReq

type UpdateNsValidResp 

type UpdateNsValidResp = adaptor.UpdateNsValidResp

UpdateNsValidResp UpdateNsValidResp

type UpdatePermitElemReq 

type UpdatePermitElemReq struct {
	ID      string `json:"id"`
	Desc    string `json:"desc"`
	ElemPri uint   `json:"elemPri"`
}

UpdatePermitElemReq UpdatePermitElemReq

type UpdatePermitElemResp 

type UpdatePermitElemResp struct {
}

UpdatePermitElemResp UpdatePermitElemResp

type UpdatePermitGrantReq 

type UpdatePermitGrantReq struct {
	ID       string `json:"id"`
	GrantPri uint   `json:"grantPri"`
	Desc     string `json:"desc"`
}

UpdatePermitGrantReq UpdatePermitGrantReq

type UpdatePermitGrantResp 

type UpdatePermitGrantResp struct {
}

UpdatePermitGrantResp UpdatePermitGrantResp

type UpdatePermitGroupReq 

type UpdatePermitGroupReq struct {
	GroupPath string `json:"-"`
	Title     string `json:"title"`
	Desc      string `json:"desc"`
}

UpdatePermitGroupReq updatePermitGroupReq

type UpdatePermitGroupResp 

type UpdatePermitGroupResp struct {
	FullPath string `json:"fullPath"`
}

UpdatePermitGroupResp updatePermitGroupResp

type UpdatePropertyReq 

type UpdatePropertyReq struct {
	ServicePath string `json:"-"`
	Host        string `json:"host"`
	Schema      string `json:"schema"`
	AuthType    string `json:"authType"`
	Authorize   string `json:"authorize"`
}

UpdatePropertyReq UpdatePropertyReq

type UpdatePropertyResp 

type UpdatePropertyResp struct {
}

UpdatePropertyResp UpdatePropertyResp

type UpdateRawPolyReq 

type UpdateRawPolyReq = adaptor.UpdateRawPolyReq

UpdateRawPolyReq UpdateRawPolyReq

type UpdateRawPolyResp 

type UpdateRawPolyResp = adaptor.UpdateRawPolyResp

UpdateRawPolyResp UpdateRawPolyResp

type UpdateServiceReq 

type UpdateServiceReq struct {
	ServicePath string `json:"-"`
	Title       string `json:"title"`
	Desc        string `json:"desc"`
}

UpdateServiceReq UpdateServiceReq

type UpdateServiceResp 

type UpdateServiceResp struct {
	FullPath string `json:"fullPath"`
}

UpdateServiceResp UpdateServiceResp

type UpdateValidByPathReq 

type UpdateValidByPathReq struct {
	Path  string `json:"-"`
	Valid uint   `json:"valid"`
}

UpdateValidByPathReq UpdateValidByPathReq

type UpdateValidByPathResp 

type UpdateValidByPathResp struct {
	Errors []error `json:"errors"`
}

UpdateValidByPathResp UpdateValidByPathResp

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.