routes

package
v1.1.10 Latest Latest
Warning

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

 Go to latest Published: Sep 4, 2024 License: Apache-2.0 Imports: 95 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	EntityNamePostureResponse      = "posture-response"
	EntityNamePostureData          = "posture-data"
	EntityNameFailedServiceRequest = "failed-service-requests"
)
View Source 
const (
	EntityNameApiSession = "api-sessions"
)
View Source 
const EntityNameAuthPolicy = "auth-policies"
View Source 
const EntityNameAuthenticator = "authenticators"
View Source 
const EntityNameCa = "cas"
View Source 
const EntityNameConfig = "configs"
View Source 
const EntityNameConfigType = "config-types"
View Source 
const EntityNameController = "controllers"
View Source 
const EntityNameCurrentIdentity = "current-identity"
View Source 
const EntityNameCurrentSession = "current-api-session"
View Source 
const EntityNameCurrentSessionCertificates = "certificates"
View Source 
const (
	EntityNameEdgeRouter = "edge-routers"
)
View Source 
const EntityNameEdgeRouterPolicy = "edge-router-policies"
View Source 
const EntityNameEnrollment = "enrollments"
View Source 
const EntityNameExternalJwtSigner = "external-jwt-signers"
View Source 
const (
	EntityNameIdentity = "identities"
)
View Source 
const EntityNameIdentityType = "identity-types"
View Source 
const EntityNameMfa = "mfa"
View Source 
const EntityNamePostureCheck = "posture-checks"
View Source 
const EntityNamePostureCheckType = "posture-check-types"
View Source 
const EntityNameRoutePath = "route-path"
View Source 
const (
	EntityNameSelf = "self"
)
View Source 
const EntityNameService = "services"
View Source 
const EntityNameServiceEdgeRouterPolicy = "service-edge-router-policies"
View Source 
const EntityNameServicePolicy = "service-policies"
View Source 
const EntityNameSession = "sessions"
View Source 
const EntityNameSpecs = "specs"
View Source 
const EntityNameTerminator = "terminators"
View Source 
const EntityNameTransitRouter = "transit-routers"
View Source 
const (
	LimitMax = 500
)

Variables

View Source 
var AuthPolicyLinkFactory = NewBasicLinkFactory(EntityNameAuthPolicy)
View Source 
var AuthenticatorLinkFactory = NewAuthenticatorLinkFactory()
View Source 
var CaLinkFactory = NewCaLinkFactory()
View Source 
var ConfigLinkFactory = NewBasicLinkFactory(EntityNameConfig)
View Source 
var ConfigTypeLinkFactory = NewBasicLinkFactory(EntityNameConfigType)
View Source 
var ControllerLinkFactory = NewBasicLinkFactory(EntityNameController)
View Source 
var EdgeRouterLinkFactory = NewEdgeRouterLinkFactory()
View Source 
var EdgeRouterPolicyLinkFactory = NewEdgeRouterPolicyLinkFactory()
View Source 
var EnrollmentLinkFactory = NewBasicLinkFactory(EntityNameEnrollment)
View Source 
var ExternalJwtSignerLinkFactory = NewBasicLinkFactory(EntityNameExternalJwtSigner)
View Source 
var IdentityLinkFactory = NewIdentityLinkFactory(NewBasicLinkFactory(EntityNameIdentity))
View Source 
var IdentityTypeLinkFactory = NewBasicLinkFactory(EntityNameIdentityType)
View Source 
var PostureCheckLinkFactory = NewPostureCheckLinkFactory()
View Source 
var PostureCheckTypeLinkFactory = NewBasicLinkFactory(EntityNamePostureCheckType)
View Source 
var PostureResponseLinkFactory = NewBasicLinkFactory(EntityNamePostureResponse)
View Source 
var ServiceEdgeRouterPolicyLinkFactory = NewServiceEdgeRouterPolicyLinkFactory()
View Source 
var ServiceLinkFactory = NewServiceLinkFactory()
View Source 
var ServicePolicyLinkFactory = NewServicePolicyLinkFactory()
View Source 
var SessionLinkFactory = NewSessionLinkFactory()
View Source 
var SpecLinkFactory = NewSpecLinkFactory()
View Source 
var TerminatorLinkFactory = NewBasicLinkFactory(EntityNameTerminator)
View Source 
var TransitRouterLinkFactory = NewBasicLinkFactory(EntityNameTransitRouter)

Functions

func AttributesOrDefault 

func AttributesOrDefault(attributes *rest_model.Attributes) rest_model.Attributes

func BaseEntityToRestModel 

func BaseEntityToRestModel(entity models.Entity, linkFactory LinksFactory) rest_model.BaseEntity

func BoolOrDefault 

func BoolOrDefault(val *bool) bool

func Create 

func Create(rc *response.RequestContext, _ response.Responder, linkFactory CreateLinkFactory, creator ModelCreateF)

func CreateWithResponder 

func CreateWithResponder(rc *response.RequestContext, rsp response.Responder, linkFactory CreateLinkFactory, creator ModelCreateF)

func DateTimePtrOrNil 

func DateTimePtrOrNil(time *time.Time) *strfmt.DateTime

func Delete 

func Delete(rc *response.RequestContext, deleteF ModelDeleteF)

func DeleteWithHandler 

func DeleteWithHandler(rc *response.RequestContext, deleteHandler DeleteHandler)

func Detail 

func Detail(rc *response.RequestContext, f ModelDetailF)

func DetailWithHandler 

func DetailWithHandler[E models.Entity](ae *env.AppEnv, rc *response.RequestContext, loader models.EntityRetriever[E],
	mapper func(*env.AppEnv, *response.RequestContext, E) (interface{}, error))

func GetNamedEdgeRouterRoles 

func GetNamedEdgeRouterRoles(edgeRouterHandler *model.EdgeRouterManager, roles []string) rest_model.NamedRoles

func GetNamedIdentityRoles 

func GetNamedIdentityRoles(identityHandler *model.IdentityManager, roles []string) rest_model.NamedRoles

func GetNamedPostureCheckRoles 

func GetNamedPostureCheckRoles(postureCheckHandler *model.PostureCheckManager, roles []string) rest_model.NamedRoles

func GetNamedServiceRoles 

func GetNamedServiceRoles(serviceHandler *model.EdgeServiceManager, roles []string) rest_model.NamedRoles

func Int64OrDefault 

func Int64OrDefault(val *int64) int64

func List 

func List(rc *response.RequestContext, f modelListF)

func ListAssociationWithHandler 

func ListAssociationWithHandler[E models.Entity, A models.Entity](ae *env.AppEnv,
	rc *response.RequestContext,
	lister models.EntityRetriever[E],
	associationLoader AssociationLister[A],
	mapper func(*env.AppEnv, *response.RequestContext, A) (interface{}, error))

func ListAssociations 

func ListAssociations(rc *response.RequestContext, listF listAssocF)

func ListAssociationsWithFilter 

func ListAssociationsWithFilter[E models.Entity](ae *env.AppEnv,
	rc *response.RequestContext,
	filterTemplate string,
	entityController AssociationLister[E],
	mapper func(*env.AppEnv, *response.RequestContext, E) (interface{}, error))

func ListTerminatorAssociations 

func ListTerminatorAssociations(ae *env.AppEnv, rc *response.RequestContext,
	lister models.EntityRetriever[*model.EdgeService],
	associationLoader *model.TerminatorManager,
	mapper func(ae *env.AppEnv, _ *response.RequestContext, terminator *model.Terminator) (interface{}, error))

func ListWithEnvelopeFactory 

func ListWithEnvelopeFactory(rc *response.RequestContext, toEnvelope ApiListEnvelopeFactory, f modelListF)

func ListWithHandler 

func ListWithHandler[E models.Entity](ae *env.AppEnv, rc *response.RequestContext, lister models.EntityRetriever[E],
	mapper func(*env.AppEnv, *response.RequestContext, E) (interface{}, error))

func ListWithQueryF 

func ListWithQueryF[E models.Entity](ae *env.AppEnv,
	rc *response.RequestContext,
	lister models.EntityRetriever[E],
	mapper func(*env.AppEnv, *response.RequestContext, E) (interface{}, error),
	qf func(query ast.Query) (*models.EntityListResult[E], error))

func ListWithQueryFAndCollector 

func ListWithQueryFAndCollector[E models.Entity](ae *env.AppEnv,
	rc *response.RequestContext,
	lister models.EntityRetriever[E],
	mapper func(*env.AppEnv, *response.RequestContext, E) (interface{}, error),
	toEnvelope ApiListEnvelopeFactory,
	qf func(query ast.Query) (*models.EntityListResult[E], error))

func MapAdvisorServiceReachabilityToRestEntity 

func MapAdvisorServiceReachabilityToRestEntity(entity *model.AdvisorServiceReachability) *rest_model.PolicyAdvice

func MapApiSessionAuthQueriesToRestEntity 

func MapApiSessionAuthQueriesToRestEntity(ae *env.AppEnv, rc *response.RequestContext, detail *rest_model.APISessionDetail)

func MapApiSessionCertificateToRestEntity 

func MapApiSessionCertificateToRestEntity(appEnv *env.AppEnv, context *response.RequestContext, cert *model.ApiSessionCertificate) (interface{}, error)

func MapApiSessionCertificateToRestModel 

func MapApiSessionCertificateToRestModel(apiSessionCert *model.ApiSessionCertificate) (*rest_model.CurrentAPISessionCertificateDetail, error)

func MapApiSessionToRestInterface 

func MapApiSessionToRestInterface(ae *env.AppEnv, _ *response.RequestContext, apiSession *model.ApiSession) (interface{}, error)

func MapApiSessionToRestModel 

func MapApiSessionToRestModel(ae *env.AppEnv, apiSession *model.ApiSession) (*rest_model.APISessionDetail, error)

func MapAuthPolicyToRestEntity 

func MapAuthPolicyToRestEntity(_ *env.AppEnv, _ *response.RequestContext, authPolicyModel *model.AuthPolicy) (interface{}, error)

func MapAuthPolicyToRestModel 

func MapAuthPolicyToRestModel(model *model.AuthPolicy) (*rest_model.AuthPolicyDetail, error)

func MapAuthenticatorToRestEntity 

func MapAuthenticatorToRestEntity(ae *env.AppEnv, _ *response.RequestContext, e *model.Authenticator) (interface{}, error)

func MapAuthenticatorToRestModel 

func MapAuthenticatorToRestModel(ae *env.AppEnv, i *model.Authenticator) (*rest_model.AuthenticatorDetail, error)

func MapAuthenticatorsToRestEntities 

func MapAuthenticatorsToRestEntities(ae *env.AppEnv, _ *response.RequestContext, es []*model.Authenticator) ([]*rest_model.AuthenticatorDetail, error)

func MapCaToRestEntity 

func MapCaToRestEntity(_ *env.AppEnv, _ *response.RequestContext, e *model.Ca) (interface{}, error)

func MapCaToRestModel 

func MapCaToRestModel(i *model.Ca) (*rest_model.CaDetail, error)

func MapClientExtJwtSignersToRestEntity 

func MapClientExtJwtSignersToRestEntity(_ *env.AppEnv, _ *response.RequestContext, signers []*model.ExternalJwtSigner) ([]*rest_model.ClientExternalJWTSignerDetail, error)

func MapClientExternalJwtSignerToRestModel 

func MapClientExternalJwtSignerToRestModel(externalJwtSigner *model.ExternalJwtSigner) *rest_model.ClientExternalJWTSignerDetail

func MapClientTerminatorToRestEntity 

func MapClientTerminatorToRestEntity(ae *env.AppEnv, _ *response.RequestContext, terminator *model.Terminator) (interface{}, error)

func MapConfigToRestEntity 

func MapConfigToRestEntity(ae *env.AppEnv, _ *response.RequestContext, config *model.Config) (interface{}, error)

func MapConfigToRestModel 

func MapConfigToRestModel(ae *env.AppEnv, config *model.Config) (*rest_model.ConfigDetail, error)

func MapConfigTypeToRestEntity 

func MapConfigTypeToRestEntity(_ *env.AppEnv, _ *response.RequestContext, configType *model.ConfigType) (interface{}, error)

func MapConfigTypeToRestModel 

func MapConfigTypeToRestModel(configType *model.ConfigType) (*rest_model.ConfigTypeDetail, error)

func MapControllerToClientRestEntity added in v0.34.2 

func MapControllerToClientRestEntity(_ *env.AppEnv, _ *response.RequestContext, Controller *model.Controller) (interface{}, error)

func MapControllerToClientRestModel added in v0.34.2 

func MapControllerToClientRestModel(controller *model.Controller) (*rest_model.ControllerDetail, error)

func MapControllerToManagementRestEntity added in v0.34.2 

func MapControllerToManagementRestEntity(_ *env.AppEnv, _ *response.RequestContext, Controller *model.Controller) (interface{}, error)

func MapControllerToManagementRestModel added in v0.34.2 

func MapControllerToManagementRestModel(controller *model.Controller) (*rest_model.ControllerDetail, error)

func MapCreate 

func MapCreate[T models.Entity](f func(T, *change.Context) error, entity T, rc *response.RequestContext) (string, error)

func MapCreateAuthPolicyToModel 

func MapCreateAuthPolicyToModel(authPolicy *rest_model.AuthPolicyCreate) *model.AuthPolicy

func MapCreateCaToModel 

func MapCreateCaToModel(ca *rest_model.CaCreate) *model.Ca

func MapCreateConfigToModel 

func MapCreateConfigToModel(config *rest_model.ConfigCreate) (*model.Config, error)

func MapCreateConfigTypeToModel 

func MapCreateConfigTypeToModel(configType *rest_model.ConfigTypeCreate) *model.ConfigType

func MapCreateEdgeRouterPolicyToModel 

func MapCreateEdgeRouterPolicyToModel(policy *rest_model.EdgeRouterPolicyCreate) *model.EdgeRouterPolicy

func MapCreateEdgeRouterToModel 

func MapCreateEdgeRouterToModel(router *rest_model.EdgeRouterCreate) *model.EdgeRouter

func MapCreateEnrollmentToModel 

func MapCreateEnrollmentToModel(create *rest_model.EnrollmentCreate) *model.Enrollment

func MapCreateExternalJwtSignerToModel 

func MapCreateExternalJwtSignerToModel(signer *rest_model.ExternalJWTSignerCreate) *model.ExternalJwtSigner

func MapCreateIdentityToModel 

func MapCreateIdentityToModel(identity *rest_model.IdentityCreate, identityTypeId string) (*model.Identity, []*model.Enrollment)

func MapCreatePostureCheckToModel 

func MapCreatePostureCheckToModel(postureCheck rest_model.PostureCheckCreate) *model.PostureCheck

func MapCreateRouterToModel 

func MapCreateRouterToModel(router *rest_model.RouterCreate) *model.TransitRouter

func MapCreateServiceEdgeRouterPolicyToModel 

func MapCreateServiceEdgeRouterPolicyToModel(policy *rest_model.ServiceEdgeRouterPolicyCreate) *model.ServiceEdgeRouterPolicy

func MapCreateServicePolicyToModel 

func MapCreateServicePolicyToModel(policy *rest_model.ServicePolicyCreate) *model.ServicePolicy

func MapCreateServiceToModel 

func MapCreateServiceToModel(service *rest_model.ServiceCreate) *model.EdgeService

func MapCreateSessionToModel 

func MapCreateSessionToModel(identityId, apiSessionId string, session *rest_model.SessionCreate) *model.Session

func MapCreateTerminatorToModel 

func MapCreateTerminatorToModel(terminator *rest_model.TerminatorCreate) *model.Terminator

func MapCreateToAuthenticatorModel 

func MapCreateToAuthenticatorModel(in *rest_model.AuthenticatorCreate) (*model.Authenticator, error)

func MapCurrentIdentityEdgeRouterToRestEntity 

func MapCurrentIdentityEdgeRouterToRestEntity(ae *env.AppEnv, _ *response.RequestContext, router *model.EdgeRouter) (interface{}, error)

func MapCurrentIdentityEdgeRouterToRestModel 

func MapCurrentIdentityEdgeRouterToRestModel(ae *env.AppEnv, router *model.EdgeRouter) (*rest_model.CurrentIdentityEdgeRouterDetail, error)

func MapEdgeRouterPolicyToRestEntity 

func MapEdgeRouterPolicyToRestEntity(ae *env.AppEnv, _ *response.RequestContext, policy *model.EdgeRouterPolicy) (interface{}, error)

func MapEdgeRouterPolicyToRestModel 

func MapEdgeRouterPolicyToRestModel(ae *env.AppEnv, policy *model.EdgeRouterPolicy) (*rest_model.EdgeRouterPolicyDetail, error)

func MapEdgeRouterToRestEntity 

func MapEdgeRouterToRestEntity(ae *env.AppEnv, _ *response.RequestContext, router *model.EdgeRouter) (interface{}, error)

func MapEdgeRouterToRestModel 

func MapEdgeRouterToRestModel(ae *env.AppEnv, router *model.EdgeRouter) (*rest_model.EdgeRouterDetail, error)

func MapEnrollmentToRestEntity 

func MapEnrollmentToRestEntity(ae *env.AppEnv, _ *response.RequestContext, enrollment *model.Enrollment) (interface{}, error)

func MapEnrollmentToRestModel 

func MapEnrollmentToRestModel(ae *env.AppEnv, enrollment *model.Enrollment) (*rest_model.EnrollmentDetail, error)

func MapExternalJwtSignerToRestEntity 

func MapExternalJwtSignerToRestEntity(_ *env.AppEnv, _ *response.RequestContext, externalJwtSigner *model.ExternalJwtSigner) (interface{}, error)

func MapExternalJwtSignerToRestModel 

func MapExternalJwtSignerToRestModel(externalJwtSigner *model.ExternalJwtSigner) *rest_model.ExternalJWTSignerDetail

func MapIdentityToRestEntity 

func MapIdentityToRestEntity(ae *env.AppEnv, _ *response.RequestContext, entity *model.Identity) (interface{}, error)

func MapIdentityToRestModel 

func MapIdentityToRestModel(ae *env.AppEnv, identity *model.Identity) (*rest_model.IdentityDetail, error)

func MapIdentityTypeToRestEntity 

func MapIdentityTypeToRestEntity(_ *env.AppEnv, _ *response.RequestContext, identityType *model.IdentityType) (interface{}, error)

func MapIdentityTypeToRestModel 

func MapIdentityTypeToRestModel(identityType *model.IdentityType) *rest_model.IdentityTypeDetail

func MapLimitedTerminatorToRestModel 

func MapLimitedTerminatorToRestModel(ae *env.AppEnv, terminator *model.Terminator) (*rest_model.TerminatorClientDetail, error)

func MapMfaToRestEntity 

func MapMfaToRestEntity(ae *env.AppEnv, _ *response.RequestContext, e models.Entity) (interface{}, error)

func MapMfaToRestModel 

func MapMfaToRestModel(ae *env.AppEnv, mfa *model.Mfa) (*rest_model.DetailMfa, error)

func MapPatchAuthPolicyToModel 

func MapPatchAuthPolicyToModel(id string, authPolicy *rest_model.AuthPolicyPatch) *model.AuthPolicy

func MapPatchAuthenticatorToModel 

func MapPatchAuthenticatorToModel(id string, in *rest_model.AuthenticatorPatch) *model.Authenticator

func MapPatchAuthenticatorWithCurrentToModel 

func MapPatchAuthenticatorWithCurrentToModel(id, identityId string, authenticator *rest_model.AuthenticatorPatchWithCurrent) *model.AuthenticatorSelf

func MapPatchCaToModel 

func MapPatchCaToModel(id string, ca *rest_model.CaPatch) *model.Ca

func MapPatchConfigToModel 

func MapPatchConfigToModel(id string, config *rest_model.ConfigPatch) (*model.Config, error)

func MapPatchConfigTypeToModel 

func MapPatchConfigTypeToModel(id string, configType *rest_model.ConfigTypePatch) *model.ConfigType

func MapPatchEdgeRouterPolicyToModel 

func MapPatchEdgeRouterPolicyToModel(id string, policy *rest_model.EdgeRouterPolicyPatch) *model.EdgeRouterPolicy

func MapPatchEdgeRouterToModel 

func MapPatchEdgeRouterToModel(id string, router *rest_model.EdgeRouterPatch) *model.EdgeRouter

func MapPatchExternalJwtSignerToModel 

func MapPatchExternalJwtSignerToModel(id string, signer *rest_model.ExternalJWTSignerPatch) *model.ExternalJwtSigner

func MapPatchIdentityToModel 

func MapPatchIdentityToModel(id string, identity *rest_model.IdentityPatch, identityTypeId string) *model.Identity

func MapPatchPostureCheckToModel 

func MapPatchPostureCheckToModel(id string, postureCheck rest_model.PostureCheckPatch) *model.PostureCheck

func MapPatchServiceEdgeRouterPolicyToModel 

func MapPatchServiceEdgeRouterPolicyToModel(id string, policy *rest_model.ServiceEdgeRouterPolicyPatch) *model.ServiceEdgeRouterPolicy

func MapPatchServicePolicyToModel 

func MapPatchServicePolicyToModel(id string, policy *rest_model.ServicePolicyPatch) *model.ServicePolicy

func MapPatchServiceToModel 

func MapPatchServiceToModel(id string, service *rest_model.ServicePatch) *model.EdgeService

func MapPatchTerminatorToModel 

func MapPatchTerminatorToModel(id string, terminator *rest_model.TerminatorPatch) *model.Terminator

func MapPatchTransitRouterToModel 

func MapPatchTransitRouterToModel(id string, router *rest_model.RouterPatch) *model.TransitRouter

func MapPostureCheckFailureDomainToRestModel 

func MapPostureCheckFailureDomainToRestModel(failure *model.PostureCheckFailure) *rest_model.PostureCheckFailureDomain

func MapPostureCheckFailureMacToRestModel 

func MapPostureCheckFailureMacToRestModel(failure *model.PostureCheckFailure) *rest_model.PostureCheckFailureMacAddress

func MapPostureCheckFailureMfaToRestModel 

func MapPostureCheckFailureMfaToRestModel(failure *model.PostureCheckFailure) *rest_model.PostureCheckFailureMfa

func MapPostureCheckFailureOsToRestModel 

func MapPostureCheckFailureOsToRestModel(failure *model.PostureCheckFailure) *rest_model.PostureCheckFailureOperatingSystem

func MapPostureCheckFailureProcessMultiToRestModel 

func MapPostureCheckFailureProcessMultiToRestModel(failure *model.PostureCheckFailure) *rest_model.PostureCheckFailureProcessMulti

func MapPostureCheckFailureProcessToRestModel 

func MapPostureCheckFailureProcessToRestModel(failure *model.PostureCheckFailure) *rest_model.PostureCheckFailureProcess

func MapPostureCheckToRestEntity 

func MapPostureCheckToRestEntity(ae *env.AppEnv, rc *response.RequestContext, i *model.PostureCheck) (interface{}, error)

func MapPostureCheckToRestModel 

func MapPostureCheckToRestModel(ae *env.AppEnv, rc *response.RequestContext, i *model.PostureCheck) (rest_model.PostureCheckDetail, error)

func MapPostureCheckTypeToRestEntity 

func MapPostureCheckTypeToRestEntity(_ *env.AppEnv, _ *response.RequestContext, postureCheckType *model.PostureCheckType) (interface{}, error)

func MapPostureCheckTypeToRestModel 

func MapPostureCheckTypeToRestModel(postureCheckType *model.PostureCheckType) *rest_model.PostureCheckTypeDetail

func MapPostureChecksToRestEntity 

func MapPostureChecksToRestEntity(ae *env.AppEnv, rc *response.RequestContext, es []*model.PostureCheck) ([]interface{}, error)

func MapPostureDataApiSessionDataToRestModel 

func MapPostureDataApiSessionDataToRestModel(apiSessionData map[string]*model.ApiSessionPostureData) map[string]rest_model.APISessionPostureData

func MapPostureDataDomainToRestModel 

func MapPostureDataDomainToRestModel(domain *model.PostureResponseDomain) *rest_model.PostureDataDomain

func MapPostureDataFailedSessionRequestToRestModel 

func MapPostureDataFailedSessionRequestToRestModel(modelFailedSessionRequests []*model.PostureSessionRequestFailure) []*rest_model.FailedServiceRequest

func MapPostureDataMacToRestModel 

func MapPostureDataMacToRestModel(mac *model.PostureResponseMac) *rest_model.PostureDataMac

func MapPostureDataOsToRestModel 

func MapPostureDataOsToRestModel(os *model.PostureResponseOs) *rest_model.PostureDataOs

func MapPostureDataProcessesToRestModel 

func MapPostureDataProcessesToRestModel(postureData *model.PostureData) []*rest_model.PostureDataProcess

func MapPostureDataToRestModel 

func MapPostureDataToRestModel(_ *env.AppEnv, postureData *model.PostureData) *rest_model.PostureData

func MapServiceConfigToModel 

func MapServiceConfigToModel(config rest_model.ServiceConfigAssign) model.ServiceConfig

func MapServiceEdgeRouterPolicyToRestEntity 

func MapServiceEdgeRouterPolicyToRestEntity(ae *env.AppEnv, _ *response.RequestContext, policy *model.ServiceEdgeRouterPolicy) (interface{}, error)

func MapServiceEdgeRouterPolicyToRestModel 

func MapServiceEdgeRouterPolicyToRestModel(ae *env.AppEnv, policy *model.ServiceEdgeRouterPolicy) (*rest_model.ServiceEdgeRouterPolicyDetail, error)

func MapServicePolicyToRestEntity 

func MapServicePolicyToRestEntity(ae *env.AppEnv, _ *response.RequestContext, policy *model.ServicePolicy) (interface{}, error)

func MapServicePolicyToRestModel 

func MapServicePolicyToRestModel(ae *env.AppEnv, policy *model.ServicePolicy) *rest_model.ServicePolicyDetail

func MapServiceToRestEntity 

func MapServiceToRestEntity(ae *env.AppEnv, rc *response.RequestContext, service *model.ServiceDetail) (interface{}, error)

func MapServiceToRestModel 

func MapServiceToRestModel(ae *env.AppEnv, rc *response.RequestContext, service *model.ServiceDetail) (*rest_model.ServiceDetail, error)

func MapServicesToRestEntity 

func MapServicesToRestEntity(ae *env.AppEnv, rc *response.RequestContext, es []*model.ServiceDetail) ([]interface{}, error)

func MapSessionToRestEntity 

func MapSessionToRestEntity(ae *env.AppEnv, _ *response.RequestContext, session *model.Session) (interface{}, error)

func MapSessionToRestModel 

func MapSessionToRestModel(ae *env.AppEnv, sessionModel *model.Session) (*rest_model.SessionManagementDetail, error)

func MapSessionsToRestEntities 

func MapSessionsToRestEntities(ae *env.AppEnv, rc *response.RequestContext, sessions []*model.Session) ([]interface{}, error)

func MapTerminatorToRestEntity 

func MapTerminatorToRestEntity(ae *env.AppEnv, _ *response.RequestContext, terminator *model.Terminator) (interface{}, error)

func MapTerminatorToRestModel 

func MapTerminatorToRestModel(n *network.Network, terminator *model.Terminator) (*rest_model.TerminatorDetail, error)

func MapToCurrentApiSessionRestModel 

func MapToCurrentApiSessionRestModel(ae *env.AppEnv, rc *response.RequestContext, sessionTimeout time.Duration) *rest_model.CurrentAPISessionDetail

func MapTransitRouterToRestEntity 

func MapTransitRouterToRestEntity(ae *env.AppEnv, _ *response.RequestContext, router *model.TransitRouter) (interface{}, error)

func MapTransitRouterToRestModel 

func MapTransitRouterToRestModel(ae *env.AppEnv, router *model.TransitRouter) (*rest_model.RouterDetail, error)

func MapUpdateAuthPolicyToModel 

func MapUpdateAuthPolicyToModel(id string, authPolicy *rest_model.AuthPolicyUpdate) *model.AuthPolicy

func MapUpdateAuthenticatorToModel 

func MapUpdateAuthenticatorToModel(id string, in *rest_model.AuthenticatorUpdate) *model.Authenticator

func MapUpdateAuthenticatorWithCurrentToModel 

func MapUpdateAuthenticatorWithCurrentToModel(id, identityId string, authenticator *rest_model.AuthenticatorUpdateWithCurrent) *model.AuthenticatorSelf

func MapUpdateCaToModel 

func MapUpdateCaToModel(id string, ca *rest_model.CaUpdate) *model.Ca

func MapUpdateConfigToModel 

func MapUpdateConfigToModel(id string, config *rest_model.ConfigUpdate) (*model.Config, error)

func MapUpdateConfigTypeToModel 

func MapUpdateConfigTypeToModel(id string, configType *rest_model.ConfigTypeUpdate) *model.ConfigType

func MapUpdateEdgeRouterPolicyToModel 

func MapUpdateEdgeRouterPolicyToModel(id string, policy *rest_model.EdgeRouterPolicyUpdate) *model.EdgeRouterPolicy

func MapUpdateEdgeRouterToModel 

func MapUpdateEdgeRouterToModel(id string, router *rest_model.EdgeRouterUpdate) *model.EdgeRouter

func MapUpdateExternalJwtSignerToModel 

func MapUpdateExternalJwtSignerToModel(id string, signer *rest_model.ExternalJWTSignerUpdate) *model.ExternalJwtSigner

func MapUpdateIdentityToModel 

func MapUpdateIdentityToModel(id string, identity *rest_model.IdentityUpdate, identityTypeId string) *model.Identity

func MapUpdatePostureCheckToModel 

func MapUpdatePostureCheckToModel(id string, postureCheck rest_model.PostureCheckUpdate) *model.PostureCheck

func MapUpdateServiceEdgeRouterPolicyToModel 

func MapUpdateServiceEdgeRouterPolicyToModel(id string, policy *rest_model.ServiceEdgeRouterPolicyUpdate) *model.ServiceEdgeRouterPolicy

func MapUpdateServicePolicyToModel 

func MapUpdateServicePolicyToModel(id string, policy *rest_model.ServicePolicyUpdate) *model.ServicePolicy

func MapUpdateServiceToModel 

func MapUpdateServiceToModel(id string, service *rest_model.ServiceUpdate) *model.EdgeService

func MapUpdateTerminatorToModel 

func MapUpdateTerminatorToModel(id string, terminator *rest_model.TerminatorUpdate) *model.Terminator

func MapUpdateTransitRouterToModel 

func MapUpdateTransitRouterToModel(id string, router *rest_model.RouterUpdate) *model.TransitRouter

func MapVersionInfoToRestModel 

func MapVersionInfoToRestModel(versionInfo versions.VersionInfo) *rest_model.VersionInfo
func NewLink(path string) rest_model.Link

func Patch 

func Patch(rc *response.RequestContext, patchF ModelPatchF)

func PostureCheckToQueries 

func PostureCheckToQueries(check *model.PostureCheck) *rest_model.PostureQuery

func TagsOrDefault 

func TagsOrDefault(tags *rest_model.Tags) map[string]interface{}

func ToEntityRef 

func ToEntityRef(name string, entity models.Entity, factory LinksFactory) *rest_model.EntityRef

func Update 

func Update(rc *response.RequestContext, updateF ModelUpdateF)

func UpdateAllowEmptyBody 

func UpdateAllowEmptyBody(rc *response.RequestContext, updateF ModelUpdateF)

Types

type ApiEntityEnvelopeFactory 

type ApiEntityEnvelopeFactory func(data interface{}, meta *rest_model.Meta) interface{}

type ApiListEnvelopeFactory 

type ApiListEnvelopeFactory func(data []interface{}, meta *rest_model.Meta) interface{}

type ApiSessionCertificateCreateResponder 

type ApiSessionCertificateCreateResponder struct {
	response.Responder
	ApiSessionCertificate *model.ApiSessionCertificate
	// contains filtered or unexported fields
}

func (*ApiSessionCertificateCreateResponder) RespondWithCreatedId 

func (nsr *ApiSessionCertificateCreateResponder) RespondWithCreatedId(id string, _ rest_model.Link)

type ApiSessionHandler 

type ApiSessionHandler struct {
	BasePath string
}

func NewApiSessionRouter 

func NewApiSessionRouter() *ApiSessionHandler

func (*ApiSessionHandler) Delete 

func (ir *ApiSessionHandler) Delete(ae *env.AppEnv, rc *response.RequestContext)

func (*ApiSessionHandler) Detail 

func (ir *ApiSessionHandler) Detail(ae *env.AppEnv, rc *response.RequestContext)

func (*ApiSessionHandler) List 

func (ir *ApiSessionHandler) List(ae *env.AppEnv, rc *response.RequestContext)

func (*ApiSessionHandler) Register 

func (ir *ApiSessionHandler) Register(ae *env.AppEnv)

type ApiSessionLinkFactoryImpl 

type ApiSessionLinkFactoryImpl struct {
	BasicLinkFactory
}

func NewApiSessionLinkFactory 

func NewApiSessionLinkFactory() *ApiSessionLinkFactoryImpl
func (factory *ApiSessionLinkFactoryImpl) Links(entity models.Entity) rest_model.Links
func (factory ApiSessionLinkFactoryImpl) NewNestedLink(entity models.Entity, elem ...string) rest_model.Link

type AssociationLister 

type AssociationLister[E models.Entity] interface {
	GetListStore() boltz.Store
	BasePreparedList(query ast.Query) (*models.EntityListResult[E], error)
	BaseLoadInTx(tx *bbolt.Tx, id string) (E, error)
}

type AuthPolicyRouter 

type AuthPolicyRouter struct {
	BasePath string
}

func NewAuthPolicyRouter 

func NewAuthPolicyRouter() *AuthPolicyRouter

func (*AuthPolicyRouter) Create 

func (r *AuthPolicyRouter) Create(ae *env.AppEnv, rc *response.RequestContext, params auth_policy.CreateAuthPolicyParams)

func (*AuthPolicyRouter) Delete 

func (r *AuthPolicyRouter) Delete(ae *env.AppEnv, rc *response.RequestContext)

func (*AuthPolicyRouter) Detail 

func (r *AuthPolicyRouter) Detail(ae *env.AppEnv, rc *response.RequestContext)

func (*AuthPolicyRouter) List 

func (r *AuthPolicyRouter) List(ae *env.AppEnv, rc *response.RequestContext)

func (*AuthPolicyRouter) Patch 

func (r *AuthPolicyRouter) Patch(ae *env.AppEnv, rc *response.RequestContext, params auth_policy.PatchAuthPolicyParams)

func (*AuthPolicyRouter) Register 

func (r *AuthPolicyRouter) Register(ae *env.AppEnv)

func (*AuthPolicyRouter) Update 

func (r *AuthPolicyRouter) Update(ae *env.AppEnv, rc *response.RequestContext, params auth_policy.UpdateAuthPolicyParams)

type AuthRouter 

type AuthRouter struct {
	// contains filtered or unexported fields
}

func NewAuthRouter 

func NewAuthRouter() *AuthRouter

func (*AuthRouter) Register 

func (ro *AuthRouter) Register(ae *env.AppEnv)

type AuthenticatorLinkFactoryImpl 

type AuthenticatorLinkFactoryImpl struct {
	BasicLinkFactory
}

func NewAuthenticatorLinkFactory 

func NewAuthenticatorLinkFactory() *AuthenticatorLinkFactoryImpl
func (factory *AuthenticatorLinkFactoryImpl) Links(entity models.Entity) rest_model.Links

type AuthenticatorRouter 

type AuthenticatorRouter struct {
	BasePath string
}

func NewAuthenticatorRouter 

func NewAuthenticatorRouter() *AuthenticatorRouter

func (*AuthenticatorRouter) Create 

func (r *AuthenticatorRouter) Create(ae *env.AppEnv, rc *response.RequestContext, params authenticator.CreateAuthenticatorParams)

func (*AuthenticatorRouter) Delete 

func (r *AuthenticatorRouter) Delete(ae *env.AppEnv, rc *response.RequestContext)

func (*AuthenticatorRouter) Detail 

func (r *AuthenticatorRouter) Detail(ae *env.AppEnv, rc *response.RequestContext)

func (*AuthenticatorRouter) List 

func (r *AuthenticatorRouter) List(ae *env.AppEnv, rc *response.RequestContext)

func (*AuthenticatorRouter) Patch 

func (r *AuthenticatorRouter) Patch(ae *env.AppEnv, rc *response.RequestContext, params authenticator.PatchAuthenticatorParams)

func (*AuthenticatorRouter) ReEnroll 

func (r *AuthenticatorRouter) ReEnroll(ae *env.AppEnv, rc *response.RequestContext, params authenticator.ReEnrollAuthenticatorParams)

func (*AuthenticatorRouter) Register 

func (r *AuthenticatorRouter) Register(ae *env.AppEnv)

func (*AuthenticatorRouter) Update 

func (r *AuthenticatorRouter) Update(ae *env.AppEnv, rc *response.RequestContext, params authenticator.UpdateAuthenticatorParams)

type BasicLinkFactory 

type BasicLinkFactory struct {
	// contains filtered or unexported fields
}
var CurrentApiSessionCertificateLinkFactory *BasicLinkFactory = NewBasicLinkFactory(EntityNameCurrentSession + "/" + EntityNameCurrentSessionCertificates)

func NewBasicLinkFactory 

func NewBasicLinkFactory(entityName string) *BasicLinkFactory

func (*BasicLinkFactory) EntityName 

func (factory *BasicLinkFactory) EntityName() string
func (factory *BasicLinkFactory) Links(entity models.Entity) rest_model.Links
func (factory BasicLinkFactory) NewNestedLink(entity models.Entity, elem ...string) rest_model.Link
func (factory *BasicLinkFactory) SelfLink(entity models.Entity) rest_model.Link

func (*BasicLinkFactory) SelfLinkFromId 

func (factory *BasicLinkFactory) SelfLinkFromId(id string) rest_model.Link

func (*BasicLinkFactory) SelfUrlString 

func (factory *BasicLinkFactory) SelfUrlString(id string) string

type CaLinkFactoryImpl 

type CaLinkFactoryImpl struct {
	BasicLinkFactory
}

func NewCaLinkFactory 

func NewCaLinkFactory() *CaLinkFactoryImpl
func (factory *CaLinkFactoryImpl) Links(entity models.Entity) rest_model.Links

type CaRouter 

type CaRouter struct {
	BasePath string
}

func NewCaRouter 

func NewCaRouter() *CaRouter

func (*CaRouter) Create 

func (r *CaRouter) Create(ae *env.AppEnv, rc *response.RequestContext, params certificate_authority.CreateCaParams)

func (*CaRouter) Delete 

func (r *CaRouter) Delete(ae *env.AppEnv, rc *response.RequestContext)

func (*CaRouter) Detail 

func (r *CaRouter) Detail(ae *env.AppEnv, rc *response.RequestContext)

func (*CaRouter) List 

func (r *CaRouter) List(ae *env.AppEnv, rc *response.RequestContext)

func (*CaRouter) Patch 

func (r *CaRouter) Patch(ae *env.AppEnv, rc *response.RequestContext, params certificate_authority.PatchCaParams)

func (*CaRouter) Register 

func (r *CaRouter) Register(ae *env.AppEnv)

func (*CaRouter) Update 

func (r *CaRouter) Update(ae *env.AppEnv, rc *response.RequestContext, params certificate_authority.UpdateCaParams)

func (*CaRouter) VerifyCert 

func (r *CaRouter) VerifyCert(ae *env.AppEnv, rc *response.RequestContext, params certificate_authority.VerifyCaParams)

type ConfigRouter 

type ConfigRouter struct {
	BasePath string
}

func NewConfigRouter 

func NewConfigRouter() *ConfigRouter

func (*ConfigRouter) Create 

func (r *ConfigRouter) Create(ae *env.AppEnv, rc *response.RequestContext, params config.CreateConfigParams)

func (*ConfigRouter) Delete 

func (r *ConfigRouter) Delete(ae *env.AppEnv, rc *response.RequestContext)

func (*ConfigRouter) Detail 

func (r *ConfigRouter) Detail(ae *env.AppEnv, rc *response.RequestContext)

func (*ConfigRouter) List 

func (r *ConfigRouter) List(ae *env.AppEnv, rc *response.RequestContext)

func (*ConfigRouter) ListServices added in v1.1.8 

func (r *ConfigRouter) ListServices(ae *env.AppEnv, rc *response.RequestContext)

func (*ConfigRouter) Patch 

func (r *ConfigRouter) Patch(ae *env.AppEnv, rc *response.RequestContext, params config.PatchConfigParams)

func (*ConfigRouter) Register 

func (r *ConfigRouter) Register(ae *env.AppEnv)

func (*ConfigRouter) Update 

func (r *ConfigRouter) Update(ae *env.AppEnv, rc *response.RequestContext, params config.UpdateConfigParams)

type ConfigTypeRouter 

type ConfigTypeRouter struct {
	BasePath string
}

func NewConfigTypeRouter 

func NewConfigTypeRouter() *ConfigTypeRouter

func (*ConfigTypeRouter) Create 

func (r *ConfigTypeRouter) Create(ae *env.AppEnv, rc *response.RequestContext, params config.CreateConfigTypeParams)

func (*ConfigTypeRouter) Delete 

func (r *ConfigTypeRouter) Delete(ae *env.AppEnv, rc *response.RequestContext)

func (*ConfigTypeRouter) Detail 

func (r *ConfigTypeRouter) Detail(ae *env.AppEnv, rc *response.RequestContext)

func (*ConfigTypeRouter) List 

func (r *ConfigTypeRouter) List(ae *env.AppEnv, rc *response.RequestContext)

func (*ConfigTypeRouter) ListConfigs 

func (r *ConfigTypeRouter) ListConfigs(ae *env.AppEnv, rc *response.RequestContext, params config.ListConfigsForConfigTypeParams)

func (*ConfigTypeRouter) Patch 

func (r *ConfigTypeRouter) Patch(ae *env.AppEnv, rc *response.RequestContext, params config.PatchConfigTypeParams)

func (*ConfigTypeRouter) Register 

func (r *ConfigTypeRouter) Register(ae *env.AppEnv)

func (*ConfigTypeRouter) Update 

func (r *ConfigTypeRouter) Update(ae *env.AppEnv, rc *response.RequestContext, params config.UpdateConfigTypeParams)

type ControllerRouter added in v0.34.0 

type ControllerRouter struct {
	BasePath string
}

func NewControllerRouter added in v0.34.0 

func NewControllerRouter() *ControllerRouter

func (*ControllerRouter) ListClient added in v0.34.2 

func (r *ControllerRouter) ListClient(ae *env.AppEnv, rc *response.RequestContext)

func (*ControllerRouter) ListManagement added in v0.34.2 

func (r *ControllerRouter) ListManagement(ae *env.AppEnv, rc *response.RequestContext)

func (*ControllerRouter) Register added in v0.34.0 

func (r *ControllerRouter) Register(ae *env.AppEnv)

type CreateLinkFactory 

type CreateLinkFactory interface {
	SelfLinkFromId(id string) rest_model.Link
}

type CurrentApiSessionLinkFactoryImpl 

type CurrentApiSessionLinkFactoryImpl struct {
	BasicLinkFactory
}

func NewCurrentApiSessionLinkFactory 

func NewCurrentApiSessionLinkFactory() *CurrentApiSessionLinkFactoryImpl
func (factory *CurrentApiSessionLinkFactoryImpl) Links(entity models.Entity) rest_model.Links
func (factory *CurrentApiSessionLinkFactoryImpl) SelfLink(entity models.Entity) rest_model.Link

type CurrentIdentityAuthenticatorLinkFactoryImpl 

type CurrentIdentityAuthenticatorLinkFactoryImpl struct {
	BasicLinkFactory
}

func NewCurrentIdentityAuthenticatorLinkFactory 

func NewCurrentIdentityAuthenticatorLinkFactory() *CurrentIdentityAuthenticatorLinkFactoryImpl
func (factory *CurrentIdentityAuthenticatorLinkFactoryImpl) Links(entity models.Entity) rest_model.Links
func (factory CurrentIdentityAuthenticatorLinkFactoryImpl) NewNestedLink(entity models.Entity, elem ...string) rest_model.Link
func (factory *CurrentIdentityAuthenticatorLinkFactoryImpl) SelfLink(entity models.Entity) rest_model.Link

func (*CurrentIdentityAuthenticatorLinkFactoryImpl) SelfUrlString 

func (factory *CurrentIdentityAuthenticatorLinkFactoryImpl) SelfUrlString(id string) string

type CurrentIdentityAuthenticatorRouter 

type CurrentIdentityAuthenticatorRouter struct {
	BasePath string
}

func NewCurrentIdentityAuthenticatorRouter 

func NewCurrentIdentityAuthenticatorRouter() *CurrentIdentityAuthenticatorRouter

func (*CurrentIdentityAuthenticatorRouter) Detail 

func (r *CurrentIdentityAuthenticatorRouter) Detail(ae *env.AppEnv, rc *response.RequestContext)

func (*CurrentIdentityAuthenticatorRouter) Extend 

func (r *CurrentIdentityAuthenticatorRouter) Extend(ae *env.AppEnv, rc *response.RequestContext, extend *rest_model.IdentityExtendEnrollmentRequest)

func (*CurrentIdentityAuthenticatorRouter) ExtendVerify 

func (r *CurrentIdentityAuthenticatorRouter) ExtendVerify(ae *env.AppEnv, rc *response.RequestContext, extend *rest_model.IdentityExtendValidateEnrollmentRequest)

func (*CurrentIdentityAuthenticatorRouter) List 

func (r *CurrentIdentityAuthenticatorRouter) List(ae *env.AppEnv, rc *response.RequestContext)

func (*CurrentIdentityAuthenticatorRouter) Patch 

func (r *CurrentIdentityAuthenticatorRouter) Patch(ae *env.AppEnv, rc *response.RequestContext, authenticator *rest_model.AuthenticatorPatchWithCurrent)

func (*CurrentIdentityAuthenticatorRouter) Register 

func (r *CurrentIdentityAuthenticatorRouter) Register(ae *env.AppEnv)

func (*CurrentIdentityAuthenticatorRouter) Update 

func (r *CurrentIdentityAuthenticatorRouter) Update(ae *env.AppEnv, rc *response.RequestContext, authenticator *rest_model.AuthenticatorUpdateWithCurrent)

type CurrentIdentityLinkFactoryImpl 

type CurrentIdentityLinkFactoryImpl struct {
	BasicLinkFactory
}

func NewCurrentIdentityLinkFactory 

func NewCurrentIdentityLinkFactory() *CurrentIdentityLinkFactoryImpl
func (factory *CurrentIdentityLinkFactoryImpl) Links(entity models.Entity) rest_model.Links
func (factory CurrentIdentityLinkFactoryImpl) NewNestedLink(_ models.Entity, elem ...string) rest_model.Link
func (factory *CurrentIdentityLinkFactoryImpl) SelfLink(_ models.Entity) rest_model.Link

func (*CurrentIdentityLinkFactoryImpl) SelfUrlString 

func (factory *CurrentIdentityLinkFactoryImpl) SelfUrlString(_ string) string

type CurrentIdentityMfaLinkFactoryImpl 

type CurrentIdentityMfaLinkFactoryImpl struct {
	BasicLinkFactory
}

func NewCurrentIdentityMfaLinkFactory 

func NewCurrentIdentityMfaLinkFactory() *CurrentIdentityMfaLinkFactoryImpl
func (factory *CurrentIdentityMfaLinkFactoryImpl) Links(entity models.Entity) rest_model.Links
func (factory CurrentIdentityMfaLinkFactoryImpl) NewNestedLink(_ models.Entity, elem ...string) rest_model.Link
func (factory *CurrentIdentityMfaLinkFactoryImpl) SelfLink(_ models.Entity) rest_model.Link

func (*CurrentIdentityMfaLinkFactoryImpl) SelfUrlString 

func (factory *CurrentIdentityMfaLinkFactoryImpl) SelfUrlString(_ string) string

type CurrentIdentityRouter 

type CurrentIdentityRouter struct {
	BasePath string
}

func NewCurrentIdentityRouter 

func NewCurrentIdentityRouter() *CurrentIdentityRouter

func (*CurrentIdentityRouter) Register 

func (r *CurrentIdentityRouter) Register(ae *env.AppEnv)

type CurrentSessionRouter 

type CurrentSessionRouter struct {
}

func NewCurrentSessionRouter 

func NewCurrentSessionRouter() *CurrentSessionRouter

func (*CurrentSessionRouter) CreateCertificate 

func (router *CurrentSessionRouter) CreateCertificate(ae *env.AppEnv, rc *response.RequestContext, params clientCurrentApiSession.CreateCurrentAPISessionCertificateParams)

func (*CurrentSessionRouter) Delete 

func (router *CurrentSessionRouter) Delete(ae *env.AppEnv, rc *response.RequestContext)

func (*CurrentSessionRouter) DeleteCertificate 

func (router *CurrentSessionRouter) DeleteCertificate(ae *env.AppEnv, rc *response.RequestContext)

func (*CurrentSessionRouter) Detail 

func (router *CurrentSessionRouter) Detail(ae *env.AppEnv, rc *response.RequestContext)

func (*CurrentSessionRouter) DetailCertificate 

func (router *CurrentSessionRouter) DetailCertificate(ae *env.AppEnv, rc *response.RequestContext)

func (*CurrentSessionRouter) ListCertificates 

func (router *CurrentSessionRouter) ListCertificates(ae *env.AppEnv, rc *response.RequestContext)

func (*CurrentSessionRouter) ListServiceUpdates 

func (router *CurrentSessionRouter) ListServiceUpdates(ae *env.AppEnv, rc *response.RequestContext)

func (*CurrentSessionRouter) Register 

func (router *CurrentSessionRouter) Register(ae *env.AppEnv)

type DatabaseRouter 

type DatabaseRouter struct {
	// contains filtered or unexported fields
}

func NewDatabaseRouter 

func NewDatabaseRouter() *DatabaseRouter

func (*DatabaseRouter) CheckDatastoreIntegrity 

func (r *DatabaseRouter) CheckDatastoreIntegrity(ae *env.AppEnv, rc *response.RequestContext, fixErrors bool)

func (*DatabaseRouter) CreateSnapshot 

func (r *DatabaseRouter) CreateSnapshot(ae *env.AppEnv, rc *response.RequestContext)

func (*DatabaseRouter) GetCheckProgress 

func (r *DatabaseRouter) GetCheckProgress(rc *response.RequestContext)

func (*DatabaseRouter) Register 

func (r *DatabaseRouter) Register(ae *env.AppEnv)

type DeleteHandler 

type DeleteHandler interface {
	Delete(id string, ctx *change.Context) error
}

type EdgeRouterLinkFactoryImpl 

type EdgeRouterLinkFactoryImpl struct {
	BasicLinkFactory
}

func NewEdgeRouterLinkFactory 

func NewEdgeRouterLinkFactory() *EdgeRouterLinkFactoryImpl
func (factory *EdgeRouterLinkFactoryImpl) Links(entity models.Entity) rest_model.Links

type EdgeRouterPolicyLinkFactoryImpl 

type EdgeRouterPolicyLinkFactoryImpl struct {
	BasicLinkFactory
}

func NewEdgeRouterPolicyLinkFactory 

func NewEdgeRouterPolicyLinkFactory() *EdgeRouterPolicyLinkFactoryImpl
func (factory *EdgeRouterPolicyLinkFactoryImpl) Links(entity models.Entity) rest_model.Links

type EdgeRouterPolicyRouter 

type EdgeRouterPolicyRouter struct {
	BasePath string
}

func NewEdgeRouterPolicyRouter 

func NewEdgeRouterPolicyRouter() *EdgeRouterPolicyRouter

func (*EdgeRouterPolicyRouter) Create 

func (r *EdgeRouterPolicyRouter) Create(ae *env.AppEnv, rc *response.RequestContext, params edge_router_policy.CreateEdgeRouterPolicyParams)

func (*EdgeRouterPolicyRouter) Delete 

func (r *EdgeRouterPolicyRouter) Delete(ae *env.AppEnv, rc *response.RequestContext)

func (*EdgeRouterPolicyRouter) Detail 

func (r *EdgeRouterPolicyRouter) Detail(ae *env.AppEnv, rc *response.RequestContext)

func (*EdgeRouterPolicyRouter) List 

func (r *EdgeRouterPolicyRouter) List(ae *env.AppEnv, rc *response.RequestContext)

func (*EdgeRouterPolicyRouter) ListEdgeRouters 

func (r *EdgeRouterPolicyRouter) ListEdgeRouters(ae *env.AppEnv, rc *response.RequestContext)

func (*EdgeRouterPolicyRouter) ListIdentities 

func (r *EdgeRouterPolicyRouter) ListIdentities(ae *env.AppEnv, rc *response.RequestContext)

func (*EdgeRouterPolicyRouter) Patch 

func (r *EdgeRouterPolicyRouter) Patch(ae *env.AppEnv, rc *response.RequestContext, params edge_router_policy.PatchEdgeRouterPolicyParams)

func (*EdgeRouterPolicyRouter) Register 

func (r *EdgeRouterPolicyRouter) Register(ae *env.AppEnv)

func (*EdgeRouterPolicyRouter) Update 

func (r *EdgeRouterPolicyRouter) Update(ae *env.AppEnv, rc *response.RequestContext, params edge_router_policy.UpdateEdgeRouterPolicyParams)

type EdgeRouterRouter 

type EdgeRouterRouter struct {
	BasePath string
}

func NewEdgeRouterRouter 

func NewEdgeRouterRouter() *EdgeRouterRouter

func (*EdgeRouterRouter) Create 

func (r *EdgeRouterRouter) Create(ae *env.AppEnv, rc *response.RequestContext, params edge_router.CreateEdgeRouterParams)

func (*EdgeRouterRouter) Delete 

func (r *EdgeRouterRouter) Delete(ae *env.AppEnv, rc *response.RequestContext)

func (*EdgeRouterRouter) Detail 

func (r *EdgeRouterRouter) Detail(ae *env.AppEnv, rc *response.RequestContext)

func (*EdgeRouterRouter) List 

func (r *EdgeRouterRouter) List(ae *env.AppEnv, rc *response.RequestContext)

func (*EdgeRouterRouter) Patch 

func (r *EdgeRouterRouter) Patch(ae *env.AppEnv, rc *response.RequestContext, params edge_router.PatchEdgeRouterParams)

func (*EdgeRouterRouter) ReEnroll 

func (r *EdgeRouterRouter) ReEnroll(ae *env.AppEnv, rc *response.RequestContext)

func (*EdgeRouterRouter) Register 

func (r *EdgeRouterRouter) Register(ae *env.AppEnv)

func (*EdgeRouterRouter) Update 

func (r *EdgeRouterRouter) Update(ae *env.AppEnv, rc *response.RequestContext, params edge_router.UpdateEdgeRouterParams)

type EnrollRouter 

type EnrollRouter struct {
}

func NewEnrollRouter 

func NewEnrollRouter() *EnrollRouter

func (*EnrollRouter) Register 

func (ro *EnrollRouter) Register(ae *env.AppEnv)

type EnrollmentRouter 

type EnrollmentRouter struct {
	BasePath string
}

func NewEnrollmentRouter 

func NewEnrollmentRouter() *EnrollmentRouter

func (*EnrollmentRouter) Create 

func (r *EnrollmentRouter) Create(ae *env.AppEnv, rc *response.RequestContext, params enrollment.CreateEnrollmentParams)

func (*EnrollmentRouter) Delete 

func (r *EnrollmentRouter) Delete(ae *env.AppEnv, rc *response.RequestContext)

func (*EnrollmentRouter) Detail 

func (r *EnrollmentRouter) Detail(ae *env.AppEnv, rc *response.RequestContext)

func (*EnrollmentRouter) List 

func (r *EnrollmentRouter) List(ae *env.AppEnv, rc *response.RequestContext)

func (*EnrollmentRouter) Refresh 

func (r *EnrollmentRouter) Refresh(ae *env.AppEnv, rc *response.RequestContext, params enrollment.RefreshEnrollmentParams)

func (*EnrollmentRouter) Register 

func (r *EnrollmentRouter) Register(ae *env.AppEnv)

type ExternalJwtSignerRouter 

type ExternalJwtSignerRouter struct {
	BasePath string
}

func NewExternalJwtSignerRouter 

func NewExternalJwtSignerRouter() *ExternalJwtSignerRouter

func (*ExternalJwtSignerRouter) Create 

func (r *ExternalJwtSignerRouter) Create(ae *env.AppEnv, rc *response.RequestContext, params external_jwt_signer.CreateExternalJWTSignerParams)

func (*ExternalJwtSignerRouter) Delete 

func (r *ExternalJwtSignerRouter) Delete(ae *env.AppEnv, rc *response.RequestContext)

func (*ExternalJwtSignerRouter) Detail 

func (r *ExternalJwtSignerRouter) Detail(ae *env.AppEnv, rc *response.RequestContext)

func (*ExternalJwtSignerRouter) List 

func (r *ExternalJwtSignerRouter) List(ae *env.AppEnv, rc *response.RequestContext)

func (*ExternalJwtSignerRouter) ListClient 

func (r *ExternalJwtSignerRouter) ListClient(ae *env.AppEnv, rc *response.RequestContext)

func (*ExternalJwtSignerRouter) Patch 

func (r *ExternalJwtSignerRouter) Patch(ae *env.AppEnv, rc *response.RequestContext, params external_jwt_signer.PatchExternalJWTSignerParams)

func (*ExternalJwtSignerRouter) Register 

func (r *ExternalJwtSignerRouter) Register(ae *env.AppEnv)

func (*ExternalJwtSignerRouter) Update 

func (r *ExternalJwtSignerRouter) Update(ae *env.AppEnv, rc *response.RequestContext, params external_jwt_signer.UpdateExternalJWTSignerParams)

type FullLinkFactory 

type FullLinkFactory interface {
	LinksFactory
	SelfLinkFactory
}
var CurrentIdentityLinkFactory FullLinkFactory = NewCurrentIdentityLinkFactory()
var CurrentIdentityMfaLinkFactory FullLinkFactory = NewCurrentIdentityMfaLinkFactory()

type IdentityLinkFactoryImpl 

type IdentityLinkFactoryImpl struct {
	BasicLinkFactory
}

func NewIdentityLinkFactory 

func NewIdentityLinkFactory(selfFactory *BasicLinkFactory) *IdentityLinkFactoryImpl
func (factory *IdentityLinkFactoryImpl) Links(entity models.Entity) rest_model.Links

type IdentityRouter 

type IdentityRouter struct {
	BasePath string
}

func NewIdentityRouter 

func NewIdentityRouter() *IdentityRouter

func (*IdentityRouter) Create 

func (r *IdentityRouter) Create(ae *env.AppEnv, rc *response.RequestContext, params identity.CreateIdentityParams)

func (*IdentityRouter) Delete 

func (r *IdentityRouter) Delete(ae *env.AppEnv, rc *response.RequestContext)

func (*IdentityRouter) Detail 

func (r *IdentityRouter) Detail(ae *env.AppEnv, rc *response.RequestContext)

func (*IdentityRouter) Disable 

func (r *IdentityRouter) Disable(ae *env.AppEnv, rc *response.RequestContext, params identity.DisableIdentityParams)

func (*IdentityRouter) Enable 

func (r *IdentityRouter) Enable(ae *env.AppEnv, rc *response.RequestContext, params identity.EnableIdentityParams)

func (*IdentityRouter) List 

func (r *IdentityRouter) List(ae *env.AppEnv, rc *response.RequestContext)

func (*IdentityRouter) Patch 

func (r *IdentityRouter) Patch(ae *env.AppEnv, rc *response.RequestContext, params identity.PatchIdentityParams)

func (*IdentityRouter) Register 

func (r *IdentityRouter) Register(ae *env.AppEnv)

func (*IdentityRouter) Update 

func (r *IdentityRouter) Update(ae *env.AppEnv, rc *response.RequestContext, params identity.UpdateIdentityParams)

type IdentityTypeRouter 

type IdentityTypeRouter struct {
	BasePath string
}

func NewIdentityTypeRouter 

func NewIdentityTypeRouter() *IdentityTypeRouter

func (*IdentityTypeRouter) Detail 

func (r *IdentityTypeRouter) Detail(ae *env.AppEnv, rc *response.RequestContext)

func (*IdentityTypeRouter) List 

func (r *IdentityTypeRouter) List(ae *env.AppEnv, rc *response.RequestContext)

func (*IdentityTypeRouter) Register 

func (r *IdentityTypeRouter) Register(ae *env.AppEnv)

type LinksFactory 

type LinksFactory interface {
	Links(entity models.Entity) rest_model.Links
	EntityName() string
}
var ApiSessionLinkFactory LinksFactory = NewApiSessionLinkFactory()
var CurrentApiSessionLinkFactory LinksFactory = NewCurrentApiSessionLinkFactory()
var CurrentIdentityAuthenticatorLinkFactory LinksFactory = NewCurrentIdentityAuthenticatorLinkFactory()

type ModelCreateF 

type ModelCreateF func() (string, error)

type ModelDeleteF 

type ModelDeleteF func(rc *response.RequestContext, id string) error

type ModelDetailF 

type ModelDetailF func(rc *response.RequestContext, id string) (interface{}, error)

type ModelPatchF 

type ModelPatchF func(id string, fields fields.UpdatedFields) error

type ModelToApiMapper 

type ModelToApiMapper func(*env.AppEnv, *response.RequestContext, models.Entity) (interface{}, error)

type ModelUpdateF 

type ModelUpdateF func(id string) error

type Paging 

type Paging struct {
	Offset    int64
	Limit     int64
	ReturnAll bool
}

func GetRequestPaging 

func GetRequestPaging(r *http.Request) (*Paging, error)

func (*Paging) String 

func (paging *Paging) String() string

type ParsedNumber 

type ParsedNumber interface {
	String() string
	Float64() (float64, error)
	Int64() (int64, error)
}

type PermissionsApi 

type PermissionsApi []string

type PostureCheckLinkFactoryImpl 

type PostureCheckLinkFactoryImpl struct {
	BasicLinkFactory
}

func NewPostureCheckLinkFactory 

func NewPostureCheckLinkFactory() *PostureCheckLinkFactoryImpl
func (factory *PostureCheckLinkFactoryImpl) Links(entity models.Entity) rest_model.Links

type PostureCheckRouter 

type PostureCheckRouter struct {
	BasePath string
}

func NewPostureCheckRouter 

func NewPostureCheckRouter() *PostureCheckRouter

func (*PostureCheckRouter) Create 

func (r *PostureCheckRouter) Create(ae *env.AppEnv, rc *response.RequestContext, params posture_checks.CreatePostureCheckParams)

func (*PostureCheckRouter) Delete 

func (r *PostureCheckRouter) Delete(ae *env.AppEnv, rc *response.RequestContext)

func (*PostureCheckRouter) Detail 

func (r *PostureCheckRouter) Detail(ae *env.AppEnv, rc *response.RequestContext)

func (*PostureCheckRouter) List 

func (r *PostureCheckRouter) List(ae *env.AppEnv, rc *response.RequestContext)

func (*PostureCheckRouter) Patch 

func (r *PostureCheckRouter) Patch(ae *env.AppEnv, rc *response.RequestContext, params posture_checks.PatchPostureCheckParams)

func (*PostureCheckRouter) Register 

func (r *PostureCheckRouter) Register(ae *env.AppEnv)

func (*PostureCheckRouter) Update 

func (r *PostureCheckRouter) Update(ae *env.AppEnv, rc *response.RequestContext, params posture_checks.UpdatePostureCheckParams)

type PostureCheckTypeRouter 

type PostureCheckTypeRouter struct {
	BasePath string
}

func NewPostureCheckTypeRouter 

func NewPostureCheckTypeRouter() *PostureCheckTypeRouter

func (*PostureCheckTypeRouter) Detail 

func (r *PostureCheckTypeRouter) Detail(ae *env.AppEnv, rc *response.RequestContext)

func (*PostureCheckTypeRouter) List 

func (r *PostureCheckTypeRouter) List(ae *env.AppEnv, rc *response.RequestContext)

func (*PostureCheckTypeRouter) Register 

func (r *PostureCheckTypeRouter) Register(ae *env.AppEnv)

type PostureResponseResponder 

type PostureResponseResponder struct {
	response.Responder
	// contains filtered or unexported fields
}

func (*PostureResponseResponder) RespondWithCreatedId 

func (responder *PostureResponseResponder) RespondWithCreatedId(id string, _ rest_model.Link)

type PostureResponseRouter 

type PostureResponseRouter struct {
	BasePath string
}

func NewPostureResponseRouter 

func NewPostureResponseRouter() *PostureResponseRouter

func (*PostureResponseRouter) Create 

func (r *PostureResponseRouter) Create(ae *env.AppEnv, rc *response.RequestContext, params posture_checks.CreatePostureResponseParams)

func (*PostureResponseRouter) CreateBulk 

func (r *PostureResponseRouter) CreateBulk(ae *env.AppEnv, rc *response.RequestContext, params posture_checks.CreatePostureResponseBulkParams)

func (*PostureResponseRouter) Register 

func (r *PostureResponseRouter) Register(ae *env.AppEnv)

type ProtocolRouter 

type ProtocolRouter struct {
	BasePath string
}

func NewProtocolRouter 

func NewProtocolRouter() *ProtocolRouter

func (*ProtocolRouter) List 

func (router *ProtocolRouter) List(ae *env.AppEnv, rc *response.RequestContext)

func (*ProtocolRouter) Register 

func (router *ProtocolRouter) Register(ae *env.AppEnv)

type PublicQueryOptions 

type PublicQueryOptions struct {
	Predicate string
	Sort      string
	Paging    *Paging
}

PublicQueryOptions represents external query options, which limits some query options (i.e. return all vs max limit). PublicQueryOptions can be used internally as long as the public option limitations are fitting.

func GetModelQueryOptionsFromRequest 

func GetModelQueryOptionsFromRequest(r *http.Request) (*PublicQueryOptions, error)

func (*PublicQueryOptions) String 

func (qo *PublicQueryOptions) String() string

type QueryResult 

type QueryResult struct {
	Result           interface{}
	Count            int64
	Limit            int64
	Offset           int64
	FilterableFields []string
}

func NewQueryResult 

func NewQueryResult(result interface{}, metadata *models.QueryMetaData) *QueryResult

type RoleAttributesRouter 

type RoleAttributesRouter struct{}

func NewRoleAttributesRouter 

func NewRoleAttributesRouter() *RoleAttributesRouter

func (*RoleAttributesRouter) Register 

func (r *RoleAttributesRouter) Register(ae *env.AppEnv)

type SelfLinkFactory 

type SelfLinkFactory interface {
	SelfLink(entity models.Entity) rest_model.Link
}

type ServiceEdgeRouterPolicyLinkFactoryImpl 

type ServiceEdgeRouterPolicyLinkFactoryImpl struct {
	BasicLinkFactory
}

func NewServiceEdgeRouterPolicyLinkFactory 

func NewServiceEdgeRouterPolicyLinkFactory() *ServiceEdgeRouterPolicyLinkFactoryImpl
func (factory *ServiceEdgeRouterPolicyLinkFactoryImpl) Links(entity models.Entity) rest_model.Links

type ServiceEdgeRouterPolicyRouter 

type ServiceEdgeRouterPolicyRouter struct {
	BasePath string
}

func NewServiceEdgeRouterPolicyRouter 

func NewServiceEdgeRouterPolicyRouter() *ServiceEdgeRouterPolicyRouter

func (*ServiceEdgeRouterPolicyRouter) Create 

func (r *ServiceEdgeRouterPolicyRouter) Create(ae *env.AppEnv, rc *response.RequestContext, params service_edge_router_policy.CreateServiceEdgeRouterPolicyParams)

func (*ServiceEdgeRouterPolicyRouter) Delete 

func (r *ServiceEdgeRouterPolicyRouter) Delete(ae *env.AppEnv, rc *response.RequestContext)

func (*ServiceEdgeRouterPolicyRouter) Detail 

func (r *ServiceEdgeRouterPolicyRouter) Detail(ae *env.AppEnv, rc *response.RequestContext)

func (*ServiceEdgeRouterPolicyRouter) List 

func (r *ServiceEdgeRouterPolicyRouter) List(ae *env.AppEnv, rc *response.RequestContext)

func (*ServiceEdgeRouterPolicyRouter) ListEdgeRouters 

func (r *ServiceEdgeRouterPolicyRouter) ListEdgeRouters(ae *env.AppEnv, rc *response.RequestContext)

func (*ServiceEdgeRouterPolicyRouter) ListServices 

func (r *ServiceEdgeRouterPolicyRouter) ListServices(ae *env.AppEnv, rc *response.RequestContext)

func (*ServiceEdgeRouterPolicyRouter) Patch 

func (r *ServiceEdgeRouterPolicyRouter) Patch(ae *env.AppEnv, rc *response.RequestContext, params service_edge_router_policy.PatchServiceEdgeRouterPolicyParams)

func (*ServiceEdgeRouterPolicyRouter) Register 

func (r *ServiceEdgeRouterPolicyRouter) Register(ae *env.AppEnv)

func (*ServiceEdgeRouterPolicyRouter) Update 

func (r *ServiceEdgeRouterPolicyRouter) Update(ae *env.AppEnv, rc *response.RequestContext, params service_edge_router_policy.UpdateServiceEdgeRouterPolicyParams)

type ServiceLinkFactoryIml 

type ServiceLinkFactoryIml struct {
	BasicLinkFactory
}

func NewServiceLinkFactory 

func NewServiceLinkFactory() *ServiceLinkFactoryIml
func (factory *ServiceLinkFactoryIml) Links(entity models.Entity) rest_model.Links

type ServicePolicyLinkFactoryImpl 

type ServicePolicyLinkFactoryImpl struct {
	BasicLinkFactory
}

func NewServicePolicyLinkFactory 

func NewServicePolicyLinkFactory() *ServicePolicyLinkFactoryImpl
func (factory *ServicePolicyLinkFactoryImpl) Links(entity models.Entity) rest_model.Links

type ServicePolicyRouter 

type ServicePolicyRouter struct {
	BasePath string
}

func NewServicePolicyRouter 

func NewServicePolicyRouter() *ServicePolicyRouter

func (*ServicePolicyRouter) Create 

func (r *ServicePolicyRouter) Create(ae *env.AppEnv, rc *response.RequestContext, params service_policy.CreateServicePolicyParams)

func (*ServicePolicyRouter) Delete 

func (r *ServicePolicyRouter) Delete(ae *env.AppEnv, rc *response.RequestContext)

func (*ServicePolicyRouter) Detail 

func (r *ServicePolicyRouter) Detail(ae *env.AppEnv, rc *response.RequestContext)

func (*ServicePolicyRouter) List 

func (r *ServicePolicyRouter) List(ae *env.AppEnv, rc *response.RequestContext)

func (*ServicePolicyRouter) ListIdentities 

func (r *ServicePolicyRouter) ListIdentities(ae *env.AppEnv, rc *response.RequestContext)

func (*ServicePolicyRouter) ListPostureChecks 

func (r *ServicePolicyRouter) ListPostureChecks(ae *env.AppEnv, rc *response.RequestContext)

func (*ServicePolicyRouter) ListServices 

func (r *ServicePolicyRouter) ListServices(ae *env.AppEnv, rc *response.RequestContext)

func (*ServicePolicyRouter) Patch 

func (r *ServicePolicyRouter) Patch(ae *env.AppEnv, rc *response.RequestContext, params service_policy.PatchServicePolicyParams)

func (*ServicePolicyRouter) Register 

func (r *ServicePolicyRouter) Register(ae *env.AppEnv)

func (*ServicePolicyRouter) Update 

func (r *ServicePolicyRouter) Update(ae *env.AppEnv, rc *response.RequestContext, params service_policy.UpdateServicePolicyParams)

type ServiceRouter 

type ServiceRouter struct {
	BasePath string
	// contains filtered or unexported fields
}

func NewServiceRouter 

func NewServiceRouter() *ServiceRouter

func (*ServiceRouter) Create 

func (r *ServiceRouter) Create(ae *env.AppEnv, rc *response.RequestContext, params managementService.CreateServiceParams)

func (*ServiceRouter) Delete 

func (r *ServiceRouter) Delete(ae *env.AppEnv, rc *response.RequestContext)

func (*ServiceRouter) Detail 

func (r *ServiceRouter) Detail(ae *env.AppEnv, rc *response.RequestContext)

func (*ServiceRouter) ListClientServices 

func (r *ServiceRouter) ListClientServices(ae *env.AppEnv, rc *response.RequestContext, params clientService.ListServicesParams)

func (*ServiceRouter) ListManagementServices 

func (r *ServiceRouter) ListManagementServices(ae *env.AppEnv, rc *response.RequestContext)

func (*ServiceRouter) Patch 

func (r *ServiceRouter) Patch(ae *env.AppEnv, rc *response.RequestContext, params managementService.PatchServiceParams)

func (*ServiceRouter) Register 

func (r *ServiceRouter) Register(ae *env.AppEnv)

func (*ServiceRouter) Update 

func (r *ServiceRouter) Update(ae *env.AppEnv, rc *response.RequestContext, params managementService.UpdateServiceParams)

type SessionLinkFactoryImpl 

type SessionLinkFactoryImpl struct {
	BasicLinkFactory
}

func NewSessionLinkFactory 

func NewSessionLinkFactory() *SessionLinkFactoryImpl
func (factory *SessionLinkFactoryImpl) Links(entity models.Entity) rest_model.Links

type SessionRequestResponder 

type SessionRequestResponder struct {
	response.Responder
	// contains filtered or unexported fields
}

func (*SessionRequestResponder) RespondWithCreatedId 

func (nsr *SessionRequestResponder) RespondWithCreatedId(id string, _ rest_model.Link)

type SessionRouter 

type SessionRouter struct {
	BasePath string
	// contains filtered or unexported fields
}

func NewSessionRouter 

func NewSessionRouter() *SessionRouter

func (*SessionRouter) Create 

func (r *SessionRouter) Create(ae *env.AppEnv, rc *response.RequestContext, params session.CreateSessionParams)

func (*SessionRouter) Delete 

func (r *SessionRouter) Delete(ae *env.AppEnv, rc *response.RequestContext)

func (*SessionRouter) Detail 

func (r *SessionRouter) Detail(ae *env.AppEnv, rc *response.RequestContext)

func (*SessionRouter) DetailRoutePath 

func (r *SessionRouter) DetailRoutePath(ae *env.AppEnv, rc *response.RequestContext, params managementSession.DetailSessionRoutePathParams)

func (*SessionRouter) List 

func (r *SessionRouter) List(ae *env.AppEnv, rc *response.RequestContext)

func (*SessionRouter) Register 

func (r *SessionRouter) Register(ae *env.AppEnv)

type Spec 

type Spec struct {
	models.BaseEntity
	// contains filtered or unexported fields
}

type SpecLinkFactoryImpl 

type SpecLinkFactoryImpl struct {
	BasicLinkFactory
}

func NewSpecLinkFactory 

func NewSpecLinkFactory() *SpecLinkFactoryImpl
func (factory *SpecLinkFactoryImpl) Links(entity models.Entity) rest_model.Links

type SpecRouter 

type SpecRouter struct {
	BasePath string
}

func NewSpecRouter 

func NewSpecRouter() *SpecRouter

func (*SpecRouter) Detail 

func (r *SpecRouter) Detail(_ *env.AppEnv, rc *response.RequestContext)

func (*SpecRouter) DetailBody 

func (r *SpecRouter) DetailBody(_ *env.AppEnv, rc *response.RequestContext)

func (*SpecRouter) List 

func (r *SpecRouter) List(_ *env.AppEnv, rc *response.RequestContext)

func (*SpecRouter) Register 

func (r *SpecRouter) Register(ae *env.AppEnv)

type SummaryRouter 

type SummaryRouter struct {
	BasePath string
}

func NewSummaryRouter 

func NewSummaryRouter() *SummaryRouter

func (*SummaryRouter) List 

func (r *SummaryRouter) List(ae *env.AppEnv, rc *response.RequestContext)

func (*SummaryRouter) Register 

func (r *SummaryRouter) Register(ae *env.AppEnv)

type TerminatorModelMapper 

type TerminatorModelMapper struct{}

func (TerminatorModelMapper) ToApi 

func (TerminatorModelMapper) ToApi(n *network.Network, _ api.RequestContext, terminator *model.Terminator) (interface{}, error)

type TerminatorRouter 

type TerminatorRouter struct {
	BasePath string
}

func NewTerminatorRouter 

func NewTerminatorRouter() *TerminatorRouter

func (*TerminatorRouter) Create 

func (r *TerminatorRouter) Create(ae *env.AppEnv, rc *response.RequestContext, params terminator.CreateTerminatorParams)

func (*TerminatorRouter) Delete 

func (r *TerminatorRouter) Delete(ae *env.AppEnv, rc *response.RequestContext)

func (*TerminatorRouter) Detail 

func (r *TerminatorRouter) Detail(ae *env.AppEnv, rc *response.RequestContext)

func (*TerminatorRouter) List 

func (r *TerminatorRouter) List(ae *env.AppEnv, rc *response.RequestContext)

func (*TerminatorRouter) Patch 

func (r *TerminatorRouter) Patch(ae *env.AppEnv, rc *response.RequestContext, params terminator.PatchTerminatorParams)

func (*TerminatorRouter) Register 

func (r *TerminatorRouter) Register(ae *env.AppEnv)

func (*TerminatorRouter) Update 

func (r *TerminatorRouter) Update(ae *env.AppEnv, rc *response.RequestContext, params terminator.UpdateTerminatorParams)

type TransitRouterRouter 

type TransitRouterRouter struct {
	BasePath string
}

func NewTransitRouterRouter 

func NewTransitRouterRouter() *TransitRouterRouter

func (*TransitRouterRouter) Create 

func (r *TransitRouterRouter) Create(ae *env.AppEnv, rc *response.RequestContext, router *rest_model.RouterCreate)

func (*TransitRouterRouter) Delete 

func (r *TransitRouterRouter) Delete(ae *env.AppEnv, rc *response.RequestContext)

func (*TransitRouterRouter) Detail 

func (r *TransitRouterRouter) Detail(ae *env.AppEnv, rc *response.RequestContext)

func (*TransitRouterRouter) List 

func (r *TransitRouterRouter) List(ae *env.AppEnv, rc *response.RequestContext)

func (*TransitRouterRouter) Patch 

func (r *TransitRouterRouter) Patch(ae *env.AppEnv, rc *response.RequestContext, routerId string, router *rest_model.RouterPatch)

func (*TransitRouterRouter) Register 

func (r *TransitRouterRouter) Register(ae *env.AppEnv)

func (*TransitRouterRouter) Update 

func (r *TransitRouterRouter) Update(ae *env.AppEnv, rc *response.RequestContext, routerId string, router *rest_model.RouterUpdate)

type VersionRouter 

type VersionRouter struct {
	BasePath string
	// contains filtered or unexported fields
}

func NewVersionRouter 

func NewVersionRouter() *VersionRouter

func (*VersionRouter) List 

func (ir *VersionRouter) List(ae *env.AppEnv, rc *response.RequestContext)

func (*VersionRouter) ListCapabilities added in v0.31.0 

func (ir *VersionRouter) ListCapabilities(_ *env.AppEnv, rc *response.RequestContext)

func (*VersionRouter) Register 

func (ir *VersionRouter) Register(ae *env.AppEnv)

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.