You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
576 lines
17 KiB
576 lines
17 KiB
import ApiService from './serviceBase'
|
|
import { FullAuditedEntityDto, PagedResultDto, PagedAndSortedResultRequestDto, ListResultDto } from './types'
|
|
|
|
const serviceUrl = process.env.VUE_APP_BASE_API
|
|
|
|
export default class ApiGateWay {
|
|
public static getGlobalConfigurationByAppId(appId: string) {
|
|
let _url = '/api/ApiGateway/Globals/By-AppId/'
|
|
_url += appId
|
|
return ApiService.Get<GlobalConfigurationDto>(_url, serviceUrl)
|
|
}
|
|
|
|
public static getGlobalConfigurations(payload: GlobalGetByPagedDto) {
|
|
let _url = '/api/ApiGateway/Globals'
|
|
_url += '?filter=' + payload.filter
|
|
_url += '&sorting=' + payload.sorting
|
|
_url += '&skipCount=' + payload.skipCount
|
|
_url += '&maxResultCount=' + payload.maxResultCount
|
|
return ApiService.Get<PagedResultDto<GlobalConfigurationDto>>(_url, serviceUrl)
|
|
}
|
|
|
|
public static createGlobalConfiguration(payload: GlobalConfigurationCreateDto) {
|
|
const _url = '/api/ApiGateway/Globals'
|
|
return ApiService.Post<GlobalConfigurationDto>(_url, payload, serviceUrl)
|
|
}
|
|
|
|
public static updateGlobalConfiguration(payload: GlobalConfigurationUpdateDto) {
|
|
const _url = '/api/ApiGateway/Globals'
|
|
return ApiService.Put<GlobalConfigurationDto>(_url, payload, serviceUrl)
|
|
}
|
|
|
|
public static deleteGlobalConfiguration(appId: number) {
|
|
let _url = '/api/ApiGateway/Globals'
|
|
_url += '?appId=' + appId
|
|
return ApiService.Delete(_url, serviceUrl)
|
|
}
|
|
|
|
public static getRouteGroupAppIds() {
|
|
const _url = '/api/ApiGateway/RouteGroups/Actived'
|
|
return ApiService.Get<ListResultDto<RouteGroupAppIdDto>>(_url, serviceUrl)
|
|
}
|
|
|
|
public static getRouteGroupByAppId(appId: string) {
|
|
let _url = '/api/ApiGateway/RouteGroups/By-AppId/'
|
|
_url += appId
|
|
return ApiService.Get<RouteGroupDto>(_url, serviceUrl)
|
|
}
|
|
|
|
public static getRouteGroups(payload: RouteGroupGetByPagedDto) {
|
|
let _url = '/api/ApiGateway/RouteGroups'
|
|
_url += '?filter=' + payload.filter
|
|
_url += '&sorting=' + payload.sorting
|
|
_url += '&skipCount=' + payload.skipCount
|
|
_url += '&maxResultCount=' + payload.maxResultCount
|
|
return ApiService.Get<PagedResultDto<RouteGroupDto>>(_url, serviceUrl)
|
|
}
|
|
|
|
public static createRouteGroup(payload: RouteGroupCreateDto) {
|
|
const _url = '/api/ApiGateway/RouteGroups'
|
|
return ApiService.Post<RouteGroupDto>(_url, payload, serviceUrl)
|
|
}
|
|
|
|
public static updateRouteGroup(payload: RouteGroupUpdateDto) {
|
|
const _url = '/api/ApiGateway/RouteGroups'
|
|
return ApiService.Put<RouteGroupDto>(_url, payload, serviceUrl)
|
|
}
|
|
|
|
public static deleteRouteGroup(appId: string) {
|
|
let _url = '/api/ApiGateway/RouteGroups'
|
|
_url += '?appId=' + appId
|
|
return ApiService.Delete(_url, serviceUrl)
|
|
}
|
|
|
|
public static getReRouteByAppId(appId: string) {
|
|
let _url = '/api/ApiGateway/Routes/By-AppId/'
|
|
_url += appId
|
|
return ApiService.Get<ReRouteDto>(_url, serviceUrl)
|
|
}
|
|
|
|
public static getReRouteByRouteId(routeId: number) {
|
|
let _url = '/api/ApiGateway/Routes/By-RouteId/'
|
|
_url += routeId
|
|
return ApiService.Get<ReRouteDto>(_url, serviceUrl)
|
|
}
|
|
|
|
public static getReRouteByRouteName(routeName: string) {
|
|
let _url = '/api/ApiGateway/Routes/By-RouteName/'
|
|
_url += routeName
|
|
return ApiService.Get<ReRouteDto>(_url, serviceUrl)
|
|
}
|
|
|
|
public static getReRoutes(payload: ReRouteGetByPagedDto) {
|
|
let _url = '/api/ApiGateway/Routes'
|
|
_url += '?appId=' + payload.appId
|
|
_url += '&filter=' + payload.filter
|
|
_url += '&sorting=' + payload.sorting
|
|
_url += '&skipCount=' + payload.skipCount
|
|
_url += '&maxResultCount=' + payload.maxResultCount
|
|
return ApiService.Get<PagedResultDto<ReRouteDto>>(_url, serviceUrl)
|
|
}
|
|
|
|
public static createReRoute(payload: ReRouteCreateDto) {
|
|
const _url = '/api/ApiGateway/Routes'
|
|
return ApiService.Post<ReRouteDto>(_url, payload, serviceUrl)
|
|
}
|
|
|
|
public static updateReRoute(payload: ReRouteUpdateDto) {
|
|
const _url = '/api/ApiGateway/Routes'
|
|
return ApiService.Put<ReRouteDto>(_url, payload, serviceUrl)
|
|
}
|
|
|
|
public static deleteReRoute(routeId: number) {
|
|
let _url = '/api/ApiGateway/Routes'
|
|
_url += '?routeId=' + routeId
|
|
return ApiService.Delete(_url, serviceUrl)
|
|
}
|
|
|
|
public static clearReRoute(appId: string) {
|
|
let _url = '/api/ApiGateway/Routes/Clear'
|
|
_url += '?appId=' + appId
|
|
return ApiService.Delete(_url, serviceUrl)
|
|
}
|
|
|
|
public static getAggregateReRoutes(payload: AggregateReRouteGetByPaged) {
|
|
let _url = '/api/ApiGateway/Aggregates'
|
|
_url += '?appId=' + payload.appId
|
|
_url += '&filter=' + payload.filter
|
|
_url += '&sorting=' + payload.sorting
|
|
_url += '&skipCount=' + payload.skipCount
|
|
_url += '&maxResultCount=' + payload.maxResultCount
|
|
return ApiService.Get<PagedResultDto<AggregateReRoute>>(_url, serviceUrl)
|
|
}
|
|
|
|
public static getAggregateReRouteByRouteId(routeId: string) {
|
|
let _url = '/api/ApiGateway/Aggregates/'
|
|
_url += routeId
|
|
return ApiService.Get<AggregateReRoute>(_url, serviceUrl)
|
|
}
|
|
|
|
public static createAggregateReRoute(payload: AggregateReRouteCreate) {
|
|
const _url = '/api/ApiGateway/Aggregates'
|
|
return ApiService.Post<AggregateReRoute>(_url, payload, serviceUrl)
|
|
}
|
|
|
|
public static updateAggregateReRoute(payload: AggregateReRouteUpdate) {
|
|
const _url = '/api/ApiGateway/Aggregates'
|
|
return ApiService.Put<AggregateReRoute>(_url, payload, serviceUrl)
|
|
}
|
|
|
|
public static deleteAggregateReRoute(routeId: string) {
|
|
let _url = '/api/ApiGateway/Aggregates'
|
|
_url += '?routeId=' + routeId
|
|
return ApiService.Delete(_url, serviceUrl)
|
|
}
|
|
|
|
public static createAggregateRouteConfig(payload: AggregateReRouteConfigCreate) {
|
|
const _url = '/api/ApiGateway/Aggregates/RouteConfig'
|
|
return ApiService.Post<AggregateReRouteConfig>(_url, payload, serviceUrl)
|
|
}
|
|
|
|
public static deleteAggregateRouteConfig(routeId: string, routeKey: string) {
|
|
let _url = '/api/ApiGateway/Aggregates/RouteConfig'
|
|
_url += '?routeId=' + routeId
|
|
_url += '&ReRouteKey=' + routeKey
|
|
return ApiService.Delete(_url, serviceUrl)
|
|
}
|
|
|
|
public static getDefinedAggregatorProviders() {
|
|
const _url = '/api/ApiGateway/Basic/Aggregators'
|
|
return ApiService.Get<ListResultDto<string>>(_url, serviceUrl)
|
|
}
|
|
|
|
public static getLoadBalancerProviders() {
|
|
const _url = '/api/ApiGateway/Basic/LoadBalancers'
|
|
return ApiService.Get<ListResultDto<LoadBalancerDescriptor>>(_url, serviceUrl)
|
|
}
|
|
}
|
|
|
|
export class ServiceDiscoveryProvider {
|
|
host!: string
|
|
port?: number
|
|
type!: string
|
|
token?: string
|
|
configurationKey?: string
|
|
pollingInterval?: number
|
|
namespace?: string
|
|
scheme?: string
|
|
}
|
|
|
|
export class RateLimitOptions {
|
|
clientIdHeader?: string
|
|
httpStatusCode?: number
|
|
quotaExceededMessage?: string
|
|
rateLimitCounterPrefix?: string
|
|
disableRateLimitHeaders!: boolean
|
|
}
|
|
|
|
export class RateLimitRuleOptions {
|
|
clientWhitelist?: string[]
|
|
enableRateLimiting!: boolean
|
|
period?: string
|
|
periodTimespan?: boolean
|
|
limit?: number
|
|
constructor() {
|
|
this.clientWhitelist = new Array<string>()
|
|
}
|
|
}
|
|
|
|
export class QoSOptions {
|
|
timeoutValue?: number = 30000
|
|
durationOfBreak?: number = 60000
|
|
exceptionsAllowedBeforeBreaking?: number = 50
|
|
}
|
|
|
|
export class LoadBalancerOptions {
|
|
type?: string = ''
|
|
key?: string = ''
|
|
expiry?: number = 0
|
|
}
|
|
|
|
export class HostAndPort {
|
|
host = ''
|
|
port?: number = 80
|
|
}
|
|
|
|
export class HttpHandlerOptions {
|
|
useProxy = false
|
|
useTracing = false
|
|
allowAutoRedirect = false
|
|
useCookieContainer = false
|
|
maxConnectionsPerServer?: number = 0
|
|
}
|
|
|
|
export class FileCacheOptions {
|
|
ttlSeconds?: number = 0
|
|
region?: string = ''
|
|
}
|
|
|
|
export class AuthenticationOptions {
|
|
authenticationProviderKey?: string = ''
|
|
allowedScopes?: string[]
|
|
constructor() {
|
|
this.allowedScopes = new Array<string>()
|
|
}
|
|
}
|
|
|
|
export class SecurityOptions {
|
|
ipAllowedList?: string[]
|
|
ipBlockedList?: string[]
|
|
constructor() {
|
|
this.ipAllowedList = new Array<string>()
|
|
this.ipBlockedList = new Array<string>()
|
|
}
|
|
}
|
|
|
|
export class GlobalConfigurationBase {
|
|
baseUrl = ''
|
|
requestIdKey?: string = ''
|
|
downstreamScheme?: string = ''
|
|
downstreamHttpVersion?: string = ''
|
|
qoSOptions!: QoSOptions
|
|
rateLimitOptions!: RateLimitOptions
|
|
httpHandlerOptions!: HttpHandlerOptions
|
|
loadBalancerOptions!: LoadBalancerOptions
|
|
serviceDiscoveryProvider!: ServiceDiscoveryProvider
|
|
|
|
constructor() {
|
|
this.qoSOptions = new QoSOptions()
|
|
this.rateLimitOptions = new RateLimitOptions()
|
|
this.httpHandlerOptions = new HttpHandlerOptions()
|
|
this.loadBalancerOptions = new LoadBalancerOptions()
|
|
this.serviceDiscoveryProvider = new ServiceDiscoveryProvider()
|
|
}
|
|
|
|
public setBasicGlobalConfiguration(configuration: GlobalConfigurationBase) {
|
|
this.baseUrl = configuration.baseUrl
|
|
this.requestIdKey = configuration.requestIdKey
|
|
this.downstreamScheme = configuration.downstreamScheme
|
|
this.downstreamHttpVersion = configuration.downstreamHttpVersion
|
|
this.qoSOptions = configuration.qoSOptions
|
|
this.rateLimitOptions = configuration.rateLimitOptions
|
|
this.httpHandlerOptions = configuration.httpHandlerOptions
|
|
this.loadBalancerOptions = configuration.loadBalancerOptions
|
|
this.serviceDiscoveryProvider = configuration.serviceDiscoveryProvider
|
|
}
|
|
}
|
|
|
|
export class GlobalConfigurationDto extends GlobalConfigurationBase {
|
|
appId!: string
|
|
itemId!: string
|
|
}
|
|
|
|
export class GlobalConfigurationCreateDto extends GlobalConfigurationBase {
|
|
appId = ''
|
|
}
|
|
|
|
export class GlobalConfigurationUpdateDto extends GlobalConfigurationBase {
|
|
itemId!: string
|
|
}
|
|
|
|
export class GlobalGetByPagedDto extends PagedAndSortedResultRequestDto {
|
|
filter?: string
|
|
constructor() {
|
|
super()
|
|
this.filter = ''
|
|
}
|
|
}
|
|
|
|
export class RouteGroupAppIdDto {
|
|
appId!: string
|
|
appName!: string
|
|
}
|
|
|
|
export class RouteGroupDto extends FullAuditedEntityDto {
|
|
id!: string
|
|
name!: string
|
|
appId!: string
|
|
appName!: string
|
|
appIpAddress?: string
|
|
description?: string
|
|
isActive!: boolean
|
|
}
|
|
|
|
export class RouteGroupCreateDto {
|
|
name = ''
|
|
appId = ''
|
|
appName = ''
|
|
isActive = true
|
|
appIpAddress?: string = ''
|
|
description?: string = ''
|
|
constructor() {
|
|
this.isActive = true
|
|
}
|
|
}
|
|
|
|
export class RouteGroupUpdateDto {
|
|
name = ''
|
|
appId = ''
|
|
appName = ''
|
|
isActive = true
|
|
appIpAddress?: string = ''
|
|
description?: string = ''
|
|
}
|
|
|
|
export class RouteGroupGetByPagedDto extends PagedAndSortedResultRequestDto {
|
|
filter!: string
|
|
constructor() {
|
|
super()
|
|
this.filter = ''
|
|
this.sorting = 'AppId'
|
|
}
|
|
}
|
|
|
|
export class ReRouteBase {
|
|
reRouteName = ''
|
|
downstreamPathTemplate = ''
|
|
changeDownstreamPathTemplate?: {[key: string]: string}
|
|
upstreamPathTemplate = ''
|
|
upstreamHttpMethod!: string[]
|
|
addHeadersToRequest?: {[key: string]: string}
|
|
upstreamHeaderTransform?: {[key: string]: string}
|
|
downstreamHeaderTransform?: {[key: string]: string}
|
|
addClaimsToRequest?: {[key: string]: string}
|
|
routeClaimsRequirement?: {[key: string]: string}
|
|
addQueriesToRequest?: {[key: string]: string}
|
|
requestIdKey? = ''
|
|
reRouteIsCaseSensitive? = true
|
|
serviceName? = ''
|
|
serviceNamespace? = ''
|
|
downstreamScheme? = 'HTTP'
|
|
downstreamHostAndPorts!: HostAndPort[]
|
|
upstreamHost = ''
|
|
key? = ''
|
|
delegatingHandlers?: string[]
|
|
priority? = 0
|
|
timeout? = 30000
|
|
dangerousAcceptAnyServerCertificateValidator?: boolean = true
|
|
downstreamHttpVersion? = ''
|
|
downstreamHttpMethod? = ''
|
|
securityOptions?: SecurityOptions
|
|
qoSOptions?: QoSOptions
|
|
rateLimitOptions?: RateLimitRuleOptions
|
|
loadBalancerOptions?: LoadBalancerOptions
|
|
fileCacheOptions?: FileCacheOptions
|
|
authenticationOptions?: AuthenticationOptions
|
|
httpHandlerOptions?: HttpHandlerOptions
|
|
|
|
constructor() {
|
|
this.upstreamHttpMethod = new Array<string>()
|
|
this.downstreamHostAndPorts = new Array<HostAndPort>()
|
|
|
|
this.changeDownstreamPathTemplate = {}
|
|
this.addHeadersToRequest = {}
|
|
this.upstreamHeaderTransform = {}
|
|
this.downstreamHeaderTransform = {}
|
|
this.addClaimsToRequest = {}
|
|
this.routeClaimsRequirement = {}
|
|
this.addQueriesToRequest = {}
|
|
this.delegatingHandlers = new Array<string>()
|
|
|
|
this.qoSOptions = new QoSOptions()
|
|
this.fileCacheOptions = new FileCacheOptions()
|
|
this.securityOptions = new SecurityOptions()
|
|
this.rateLimitOptions = new RateLimitRuleOptions()
|
|
this.loadBalancerOptions = new LoadBalancerOptions()
|
|
this.httpHandlerOptions = new HttpHandlerOptions()
|
|
this.authenticationOptions = new AuthenticationOptions()
|
|
}
|
|
|
|
public setBasicRoute(route: ReRouteBase) {
|
|
this.reRouteName = route.reRouteName
|
|
this.downstreamPathTemplate = route.downstreamPathTemplate
|
|
this.changeDownstreamPathTemplate = route.changeDownstreamPathTemplate
|
|
this.upstreamPathTemplate = route.upstreamPathTemplate
|
|
this.upstreamHttpMethod = route.upstreamHttpMethod
|
|
this.addHeadersToRequest = route.addHeadersToRequest
|
|
this.upstreamHeaderTransform = route.upstreamHeaderTransform
|
|
this.downstreamHeaderTransform = route.downstreamHeaderTransform
|
|
this.addClaimsToRequest = route.addClaimsToRequest
|
|
this.routeClaimsRequirement = route.routeClaimsRequirement
|
|
this.addQueriesToRequest = route.addQueriesToRequest
|
|
this.requestIdKey = route.requestIdKey
|
|
this.reRouteIsCaseSensitive = route.reRouteIsCaseSensitive
|
|
this.serviceName = route.serviceName
|
|
this.serviceNamespace = route.serviceNamespace
|
|
this.downstreamScheme = route.downstreamScheme
|
|
this.downstreamHostAndPorts = route.downstreamHostAndPorts
|
|
this.upstreamHost = route.upstreamHost
|
|
this.key = route.key
|
|
this.delegatingHandlers = route.delegatingHandlers
|
|
this.priority = route.priority
|
|
this.timeout = route.timeout
|
|
this.dangerousAcceptAnyServerCertificateValidator = route.dangerousAcceptAnyServerCertificateValidator
|
|
this.downstreamHttpVersion = route.downstreamHttpVersion
|
|
this.downstreamHttpMethod = route.downstreamHttpMethod
|
|
this.securityOptions = route.securityOptions
|
|
this.qoSOptions = route.qoSOptions
|
|
this.rateLimitOptions = route.rateLimitOptions
|
|
this.loadBalancerOptions = route.loadBalancerOptions
|
|
this.fileCacheOptions = route.fileCacheOptions
|
|
this.authenticationOptions = route.authenticationOptions
|
|
this.httpHandlerOptions = route.httpHandlerOptions
|
|
}
|
|
}
|
|
|
|
export class ReRouteDto extends ReRouteBase {
|
|
id!: number
|
|
appId!: string
|
|
reRouteId!: string
|
|
concurrencyStamp!: string
|
|
}
|
|
|
|
export class ReRouteCreateDto extends ReRouteBase {
|
|
appId = ''
|
|
}
|
|
|
|
export class ReRouteUpdateDto extends ReRouteBase {
|
|
reRouteId = ''
|
|
concurrencyStamp!: string
|
|
}
|
|
|
|
export class ReRouteGetByPagedDto extends PagedAndSortedResultRequestDto {
|
|
appId!: string
|
|
filter?: string
|
|
constructor() {
|
|
super()
|
|
this.filter = ''
|
|
this.sorting = 'ReRouteName'
|
|
}
|
|
}
|
|
|
|
export class AggregateReRouteConfig {
|
|
reRouteKey = ''
|
|
parameter = ''
|
|
jsonPath = ''
|
|
}
|
|
|
|
export class AggregateReRouteConfigCreate extends AggregateReRouteConfig {
|
|
routeId = ''
|
|
|
|
public static empty() {
|
|
return new AggregateReRouteConfigCreate()
|
|
}
|
|
}
|
|
|
|
export class AggregateReRouteBase {
|
|
reRouteKeys!: string[]
|
|
upstreamPathTemplate = ''
|
|
upstreamHost = ''
|
|
reRouteIsCaseSensitive = true
|
|
aggregator = ''
|
|
priority?: number
|
|
upstreamHttpMethod!: string[]
|
|
|
|
constructor() {
|
|
this.reRouteKeys = new Array<string>()
|
|
this.upstreamHttpMethod = new Array<string>()
|
|
}
|
|
}
|
|
|
|
export class AggregateReRoute extends AggregateReRouteBase {
|
|
appId = ''
|
|
name = ''
|
|
reRouteId = ''
|
|
concurrencyStamp = ''
|
|
reRouteKeysConfig!: AggregateReRouteConfig[]
|
|
|
|
constructor() {
|
|
super()
|
|
this.reRouteKeysConfig = new Array<AggregateReRouteConfig>()
|
|
}
|
|
|
|
public static empty() {
|
|
return new AggregateReRoute()
|
|
}
|
|
}
|
|
|
|
export class AggregateReRouteCreate extends AggregateReRouteBase {
|
|
appId = ''
|
|
name = ''
|
|
|
|
public static empty() {
|
|
return new AggregateReRouteCreate()
|
|
}
|
|
|
|
public static create(route: AggregateReRoute) {
|
|
const aggregateRoute = new AggregateReRouteCreate()
|
|
aggregateRoute.appId = route.appId
|
|
aggregateRoute.name = route.name
|
|
aggregateRoute.aggregator = route.aggregator
|
|
aggregateRoute.priority = route.priority
|
|
aggregateRoute.reRouteIsCaseSensitive = route.reRouteIsCaseSensitive
|
|
aggregateRoute.reRouteKeys = route.reRouteKeys
|
|
aggregateRoute.upstreamHost = route.upstreamHost
|
|
aggregateRoute.upstreamHttpMethod = route.upstreamHttpMethod
|
|
aggregateRoute.upstreamPathTemplate = route.upstreamPathTemplate
|
|
return aggregateRoute
|
|
}
|
|
}
|
|
|
|
export class AggregateReRouteUpdate extends AggregateReRouteBase {
|
|
routeId = ''
|
|
concurrencyStamp = ''
|
|
|
|
public static empty() {
|
|
return new AggregateReRouteUpdate()
|
|
}
|
|
|
|
public static create(route: AggregateReRoute) {
|
|
const aggregateRoute = new AggregateReRouteUpdate()
|
|
aggregateRoute.aggregator = route.aggregator
|
|
aggregateRoute.concurrencyStamp = route.concurrencyStamp
|
|
aggregateRoute.priority = route.priority
|
|
aggregateRoute.reRouteIsCaseSensitive = route.reRouteIsCaseSensitive
|
|
aggregateRoute.reRouteKeys = route.reRouteKeys
|
|
aggregateRoute.routeId = route.reRouteId
|
|
aggregateRoute.upstreamHost = route.upstreamHost
|
|
aggregateRoute.upstreamHttpMethod = route.upstreamHttpMethod
|
|
aggregateRoute.upstreamPathTemplate = route.upstreamPathTemplate
|
|
return aggregateRoute
|
|
}
|
|
}
|
|
|
|
export class AggregateReRouteGetByPaged extends PagedAndSortedResultRequestDto {
|
|
appId = ''
|
|
filter = ''
|
|
|
|
public static empty() {
|
|
return new AggregateReRouteGetByPaged()
|
|
}
|
|
}
|
|
|
|
export class LoadBalancerDescriptor {
|
|
type!: string
|
|
displayName!: string
|
|
}
|
|
|