mirror of
https://github.com/hanzo-go/sdk.git
synced 2026-11-20 20:13:42 +00:00
1808 lines
60 KiB
Go
1808 lines
60 KiB
Go
/*
|
||
Hanzo Cloud API
|
||
|
||
The Hanzo Cloud API as a customer calls it: every operation under /v1/ except the operator's admin product, relay routes, legacy spellings and capabilities still reached by flag. Tagged by product: the first path segment after /v1/.
|
||
|
||
API version: v1
|
||
*/
|
||
|
||
// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
|
||
|
||
package hanzoai
|
||
|
||
import (
|
||
"bytes"
|
||
"context"
|
||
"io"
|
||
"net/http"
|
||
"net/url"
|
||
"strings"
|
||
)
|
||
|
||
// MqAPIService MqAPI service
|
||
type MqAPIService service
|
||
|
||
type MqAPIDeleteMqStreamByNameRequest struct {
|
||
ctx context.Context
|
||
ApiService *MqAPIService
|
||
name string
|
||
}
|
||
|
||
func (r MqAPIDeleteMqStreamByNameRequest) Execute() (*http.Response, error) {
|
||
return r.ApiService.DeleteMqStreamByNameExecute(r)
|
||
}
|
||
|
||
/*
|
||
DeleteMqStreamByName Removes a stream with all its messages and consumers.
|
||
|
||
Removes a stream with all its messages and consumers. Irreversible.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@param name Name is the stream name, from the path.
|
||
@return MqAPIDeleteMqStreamByNameRequest
|
||
*/
|
||
func (a *MqAPIService) DeleteMqStreamByName(ctx context.Context, name string) MqAPIDeleteMqStreamByNameRequest {
|
||
return MqAPIDeleteMqStreamByNameRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
name: name,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
func (a *MqAPIService) DeleteMqStreamByNameExecute(r MqAPIDeleteMqStreamByNameRequest) (*http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodDelete
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "MqAPIService.DeleteMqStreamByName")
|
||
if err != nil {
|
||
return nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/mq/stream/{name}"
|
||
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
|
||
// to determine the Content-Type header
|
||
localVarHTTPContentTypes := []string{}
|
||
|
||
// set Content-Type header
|
||
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
||
if localVarHTTPContentType != "" {
|
||
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
||
}
|
||
|
||
// to determine the Accept header
|
||
localVarHTTPHeaderAccepts := []string{"application/problem+json"}
|
||
|
||
// set Accept header
|
||
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
||
if localVarHTTPHeaderAccept != "" {
|
||
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
||
}
|
||
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
localVarHTTPResponse, err := a.client.callAPI(req)
|
||
if err != nil || localVarHTTPResponse == nil {
|
||
return localVarHTTPResponse, err
|
||
}
|
||
|
||
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
||
localVarHTTPResponse.Body.Close()
|
||
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
||
if err != nil {
|
||
return localVarHTTPResponse, err
|
||
}
|
||
|
||
if localVarHTTPResponse.StatusCode >= 300 {
|
||
newErr := &GenericOpenAPIError{
|
||
body: localVarBody,
|
||
error: localVarHTTPResponse.Status,
|
||
}
|
||
var v ProblemDetails
|
||
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
||
if err != nil {
|
||
newErr.error = err.Error()
|
||
return localVarHTTPResponse, newErr
|
||
}
|
||
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
||
newErr.model = v
|
||
return localVarHTTPResponse, newErr
|
||
}
|
||
|
||
return localVarHTTPResponse, nil
|
||
}
|
||
|
||
type MqAPIDeleteMqStreamByNameMessageBySeqRequest struct {
|
||
ctx context.Context
|
||
ApiService *MqAPIService
|
||
name string
|
||
seq int32
|
||
}
|
||
|
||
func (r MqAPIDeleteMqStreamByNameMessageBySeqRequest) Execute() (*http.Response, error) {
|
||
return r.ApiService.DeleteMqStreamByNameMessageBySeqExecute(r)
|
||
}
|
||
|
||
/*
|
||
DeleteMqStreamByNameMessageBySeq Erases one message by sequence; the sequence gap remains.
|
||
|
||
Erases one message by sequence; the sequence gap remains.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@param name Name is the stream name, from the path.
|
||
@param seq Seq is the message's stream sequence, from the path.
|
||
@return MqAPIDeleteMqStreamByNameMessageBySeqRequest
|
||
*/
|
||
func (a *MqAPIService) DeleteMqStreamByNameMessageBySeq(ctx context.Context, name string, seq int32) MqAPIDeleteMqStreamByNameMessageBySeqRequest {
|
||
return MqAPIDeleteMqStreamByNameMessageBySeqRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
name: name,
|
||
seq: seq,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
func (a *MqAPIService) DeleteMqStreamByNameMessageBySeqExecute(r MqAPIDeleteMqStreamByNameMessageBySeqRequest) (*http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodDelete
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "MqAPIService.DeleteMqStreamByNameMessageBySeq")
|
||
if err != nil {
|
||
return nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/mq/stream/{name}/message/{seq}"
|
||
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
|
||
localVarPath = strings.Replace(localVarPath, "{"+"seq"+"}", url.PathEscape(parameterValueToString(r.seq, "seq")), -1)
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
|
||
// to determine the Content-Type header
|
||
localVarHTTPContentTypes := []string{}
|
||
|
||
// set Content-Type header
|
||
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
||
if localVarHTTPContentType != "" {
|
||
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
||
}
|
||
|
||
// to determine the Accept header
|
||
localVarHTTPHeaderAccepts := []string{"application/problem+json"}
|
||
|
||
// set Accept header
|
||
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
||
if localVarHTTPHeaderAccept != "" {
|
||
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
||
}
|
||
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
localVarHTTPResponse, err := a.client.callAPI(req)
|
||
if err != nil || localVarHTTPResponse == nil {
|
||
return localVarHTTPResponse, err
|
||
}
|
||
|
||
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
||
localVarHTTPResponse.Body.Close()
|
||
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
||
if err != nil {
|
||
return localVarHTTPResponse, err
|
||
}
|
||
|
||
if localVarHTTPResponse.StatusCode >= 300 {
|
||
newErr := &GenericOpenAPIError{
|
||
body: localVarBody,
|
||
error: localVarHTTPResponse.Status,
|
||
}
|
||
var v ProblemDetails
|
||
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
||
if err != nil {
|
||
newErr.error = err.Error()
|
||
return localVarHTTPResponse, newErr
|
||
}
|
||
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
||
newErr.model = v
|
||
return localVarHTTPResponse, newErr
|
||
}
|
||
|
||
return localVarHTTPResponse, nil
|
||
}
|
||
|
||
type MqAPIDeleteMqStreamByStreamConsumerByNameRequest struct {
|
||
ctx context.Context
|
||
ApiService *MqAPIService
|
||
stream string
|
||
name string
|
||
}
|
||
|
||
func (r MqAPIDeleteMqStreamByStreamConsumerByNameRequest) Execute() (*http.Response, error) {
|
||
return r.ApiService.DeleteMqStreamByStreamConsumerByNameExecute(r)
|
||
}
|
||
|
||
/*
|
||
DeleteMqStreamByStreamConsumerByName Removes a consumer and its delivery state; unacknowledged messages stay in the stream.
|
||
|
||
Removes a consumer and its delivery state; unacknowledged messages
|
||
stay in the stream.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@param stream Stream is the stream name, from the path.
|
||
@param name Name is the consumer name, from the path.
|
||
@return MqAPIDeleteMqStreamByStreamConsumerByNameRequest
|
||
*/
|
||
func (a *MqAPIService) DeleteMqStreamByStreamConsumerByName(ctx context.Context, stream string, name string) MqAPIDeleteMqStreamByStreamConsumerByNameRequest {
|
||
return MqAPIDeleteMqStreamByStreamConsumerByNameRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
stream: stream,
|
||
name: name,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
func (a *MqAPIService) DeleteMqStreamByStreamConsumerByNameExecute(r MqAPIDeleteMqStreamByStreamConsumerByNameRequest) (*http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodDelete
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "MqAPIService.DeleteMqStreamByStreamConsumerByName")
|
||
if err != nil {
|
||
return nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/mq/stream/{stream}/consumer/{name}"
|
||
localVarPath = strings.Replace(localVarPath, "{"+"stream"+"}", url.PathEscape(parameterValueToString(r.stream, "stream")), -1)
|
||
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
|
||
// to determine the Content-Type header
|
||
localVarHTTPContentTypes := []string{}
|
||
|
||
// set Content-Type header
|
||
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
||
if localVarHTTPContentType != "" {
|
||
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
||
}
|
||
|
||
// to determine the Accept header
|
||
localVarHTTPHeaderAccepts := []string{"application/problem+json"}
|
||
|
||
// set Accept header
|
||
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
||
if localVarHTTPHeaderAccept != "" {
|
||
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
||
}
|
||
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
localVarHTTPResponse, err := a.client.callAPI(req)
|
||
if err != nil || localVarHTTPResponse == nil {
|
||
return localVarHTTPResponse, err
|
||
}
|
||
|
||
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
||
localVarHTTPResponse.Body.Close()
|
||
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
||
if err != nil {
|
||
return localVarHTTPResponse, err
|
||
}
|
||
|
||
if localVarHTTPResponse.StatusCode >= 300 {
|
||
newErr := &GenericOpenAPIError{
|
||
body: localVarBody,
|
||
error: localVarHTTPResponse.Status,
|
||
}
|
||
var v ProblemDetails
|
||
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
||
if err != nil {
|
||
newErr.error = err.Error()
|
||
return localVarHTTPResponse, newErr
|
||
}
|
||
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
||
newErr.model = v
|
||
return localVarHTTPResponse, newErr
|
||
}
|
||
|
||
return localVarHTTPResponse, nil
|
||
}
|
||
|
||
type MqAPIGetMqHealthRequest struct {
|
||
ctx context.Context
|
||
ApiService *MqAPIService
|
||
}
|
||
|
||
func (r MqAPIGetMqHealthRequest) Execute() (*MqHealth, *http.Response, error) {
|
||
return r.ApiService.GetMqHealthExecute(r)
|
||
}
|
||
|
||
/*
|
||
GetMqHealth Reports whether the message plane behind this surface answers.
|
||
|
||
Reports whether the message plane behind this surface answers.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return MqAPIGetMqHealthRequest
|
||
*/
|
||
func (a *MqAPIService) GetMqHealth(ctx context.Context) MqAPIGetMqHealthRequest {
|
||
return MqAPIGetMqHealthRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return MqHealth
|
||
func (a *MqAPIService) GetMqHealthExecute(r MqAPIGetMqHealthRequest) (*MqHealth, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodGet
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *MqHealth
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "MqAPIService.GetMqHealth")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/mq/health"
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
|
||
// to determine the Content-Type header
|
||
localVarHTTPContentTypes := []string{}
|
||
|
||
// set Content-Type header
|
||
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
||
if localVarHTTPContentType != "" {
|
||
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
||
}
|
||
|
||
// to determine the Accept header
|
||
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
||
|
||
// set Accept header
|
||
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
||
if localVarHTTPHeaderAccept != "" {
|
||
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
||
}
|
||
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
||
if err != nil {
|
||
return localVarReturnValue, nil, err
|
||
}
|
||
|
||
localVarHTTPResponse, err := a.client.callAPI(req)
|
||
if err != nil || localVarHTTPResponse == nil {
|
||
return localVarReturnValue, localVarHTTPResponse, err
|
||
}
|
||
|
||
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
||
localVarHTTPResponse.Body.Close()
|
||
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
||
if err != nil {
|
||
return localVarReturnValue, localVarHTTPResponse, err
|
||
}
|
||
|
||
if localVarHTTPResponse.StatusCode >= 300 {
|
||
newErr := &GenericOpenAPIError{
|
||
body: localVarBody,
|
||
error: localVarHTTPResponse.Status,
|
||
}
|
||
var v ProblemDetails
|
||
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
||
if err != nil {
|
||
newErr.error = err.Error()
|
||
return localVarReturnValue, localVarHTTPResponse, newErr
|
||
}
|
||
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
||
newErr.model = v
|
||
return localVarReturnValue, localVarHTTPResponse, newErr
|
||
}
|
||
|
||
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
||
if err != nil {
|
||
newErr := &GenericOpenAPIError{
|
||
body: localVarBody,
|
||
error: err.Error(),
|
||
}
|
||
return localVarReturnValue, localVarHTTPResponse, newErr
|
||
}
|
||
|
||
return localVarReturnValue, localVarHTTPResponse, nil
|
||
}
|
||
|
||
type MqAPIGetMqInfoRequest struct {
|
||
ctx context.Context
|
||
ApiService *MqAPIService
|
||
}
|
||
|
||
func (r MqAPIGetMqInfoRequest) Execute() (*MqInfoOut, *http.Response, error) {
|
||
return r.ApiService.GetMqInfoExecute(r)
|
||
}
|
||
|
||
/*
|
||
GetMqInfo Returns the broker's identity and the org's stream count.
|
||
|
||
Returns the broker's identity and the org's stream count.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return MqAPIGetMqInfoRequest
|
||
*/
|
||
func (a *MqAPIService) GetMqInfo(ctx context.Context) MqAPIGetMqInfoRequest {
|
||
return MqAPIGetMqInfoRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return MqInfoOut
|
||
func (a *MqAPIService) GetMqInfoExecute(r MqAPIGetMqInfoRequest) (*MqInfoOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodGet
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *MqInfoOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "MqAPIService.GetMqInfo")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/mq/info"
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
|
||
// to determine the Content-Type header
|
||
localVarHTTPContentTypes := []string{}
|
||
|
||
// set Content-Type header
|
||
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
||
if localVarHTTPContentType != "" {
|
||
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
||
}
|
||
|
||
// to determine the Accept header
|
||
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
||
|
||
// set Accept header
|
||
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
||
if localVarHTTPHeaderAccept != "" {
|
||
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
||
}
|
||
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
||
if err != nil {
|
||
return localVarReturnValue, nil, err
|
||
}
|
||
|
||
localVarHTTPResponse, err := a.client.callAPI(req)
|
||
if err != nil || localVarHTTPResponse == nil {
|
||
return localVarReturnValue, localVarHTTPResponse, err
|
||
}
|
||
|
||
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
||
localVarHTTPResponse.Body.Close()
|
||
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
||
if err != nil {
|
||
return localVarReturnValue, localVarHTTPResponse, err
|
||
}
|
||
|
||
if localVarHTTPResponse.StatusCode >= 300 {
|
||
newErr := &GenericOpenAPIError{
|
||
body: localVarBody,
|
||
error: localVarHTTPResponse.Status,
|
||
}
|
||
var v ProblemDetails
|
||
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
||
if err != nil {
|
||
newErr.error = err.Error()
|
||
return localVarReturnValue, localVarHTTPResponse, newErr
|
||
}
|
||
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
||
newErr.model = v
|
||
return localVarReturnValue, localVarHTTPResponse, newErr
|
||
}
|
||
|
||
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
||
if err != nil {
|
||
newErr := &GenericOpenAPIError{
|
||
body: localVarBody,
|
||
error: err.Error(),
|
||
}
|
||
return localVarReturnValue, localVarHTTPResponse, newErr
|
||
}
|
||
|
||
return localVarReturnValue, localVarHTTPResponse, nil
|
||
}
|
||
|
||
type MqAPIGetMqStreamRequest struct {
|
||
ctx context.Context
|
||
ApiService *MqAPIService
|
||
limit *int64
|
||
offset *int64
|
||
}
|
||
|
||
// Limit caps the streams returned (1–1000, default 100).
|
||
func (r MqAPIGetMqStreamRequest) Limit(limit int64) MqAPIGetMqStreamRequest {
|
||
r.limit = &limit
|
||
return r
|
||
}
|
||
|
||
// Offset skips that many streams, name-ordered.
|
||
func (r MqAPIGetMqStreamRequest) Offset(offset int64) MqAPIGetMqStreamRequest {
|
||
r.offset = &offset
|
||
return r
|
||
}
|
||
|
||
func (r MqAPIGetMqStreamRequest) Execute() (*MqStreams, *http.Response, error) {
|
||
return r.ApiService.GetMqStreamExecute(r)
|
||
}
|
||
|
||
/*
|
||
GetMqStream Returns the org's streams, name-ordered, with their live state.
|
||
|
||
Returns the org's streams, name-ordered, with their live state.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return MqAPIGetMqStreamRequest
|
||
*/
|
||
func (a *MqAPIService) GetMqStream(ctx context.Context) MqAPIGetMqStreamRequest {
|
||
return MqAPIGetMqStreamRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return MqStreams
|
||
func (a *MqAPIService) GetMqStreamExecute(r MqAPIGetMqStreamRequest) (*MqStreams, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodGet
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *MqStreams
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "MqAPIService.GetMqStream")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/mq/stream"
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
|
||
if r.limit != nil {
|
||
parameterAddToHeaderOrQuery(localVarQueryParams, "limit", r.limit, "form", "")
|
||
}
|
||
if r.offset != nil {
|
||
parameterAddToHeaderOrQuery(localVarQueryParams, "offset", r.offset, "form", "")
|
||
}
|
||
// to determine the Content-Type header
|
||
localVarHTTPContentTypes := []string{}
|
||
|
||
// set Content-Type header
|
||
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
||
if localVarHTTPContentType != "" {
|
||
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
||
}
|
||
|
||
// to determine the Accept header
|
||
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
||
|
||
// set Accept header
|
||
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
||
if localVarHTTPHeaderAccept != "" {
|
||
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
||
}
|
||
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
||
if err != nil {
|
||
return localVarReturnValue, nil, err
|
||
}
|
||
|
||
localVarHTTPResponse, err := a.client.callAPI(req)
|
||
if err != nil || localVarHTTPResponse == nil {
|
||
return localVarReturnValue, localVarHTTPResponse, err
|
||
}
|
||
|
||
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
||
localVarHTTPResponse.Body.Close()
|
||
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
||
if err != nil {
|
||
return localVarReturnValue, localVarHTTPResponse, err
|
||
}
|
||
|
||
if localVarHTTPResponse.StatusCode >= 300 {
|
||
newErr := &GenericOpenAPIError{
|
||
body: localVarBody,
|
||
error: localVarHTTPResponse.Status,
|
||
}
|
||
var v ProblemDetails
|
||
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
||
if err != nil {
|
||
newErr.error = err.Error()
|
||
return localVarReturnValue, localVarHTTPResponse, newErr
|
||
}
|
||
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
||
newErr.model = v
|
||
return localVarReturnValue, localVarHTTPResponse, newErr
|
||
}
|
||
|
||
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
||
if err != nil {
|
||
newErr := &GenericOpenAPIError{
|
||
body: localVarBody,
|
||
error: err.Error(),
|
||
}
|
||
return localVarReturnValue, localVarHTTPResponse, newErr
|
||
}
|
||
|
||
return localVarReturnValue, localVarHTTPResponse, nil
|
||
}
|
||
|
||
type MqAPIGetMqStreamByNameRequest struct {
|
||
ctx context.Context
|
||
ApiService *MqAPIService
|
||
name string
|
||
}
|
||
|
||
func (r MqAPIGetMqStreamByNameRequest) Execute() (*MqStream, *http.Response, error) {
|
||
return r.ApiService.GetMqStreamByNameExecute(r)
|
||
}
|
||
|
||
/*
|
||
GetMqStreamByName Returns one stream's configuration and live state.
|
||
|
||
Returns one stream's configuration and live state.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@param name Name is the stream name, from the path.
|
||
@return MqAPIGetMqStreamByNameRequest
|
||
*/
|
||
func (a *MqAPIService) GetMqStreamByName(ctx context.Context, name string) MqAPIGetMqStreamByNameRequest {
|
||
return MqAPIGetMqStreamByNameRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
name: name,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return MqStream
|
||
func (a *MqAPIService) GetMqStreamByNameExecute(r MqAPIGetMqStreamByNameRequest) (*MqStream, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodGet
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *MqStream
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "MqAPIService.GetMqStreamByName")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/mq/stream/{name}"
|
||
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
|
||
// to determine the Content-Type header
|
||
localVarHTTPContentTypes := []string{}
|
||
|
||
// set Content-Type header
|
||
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
||
if localVarHTTPContentType != "" {
|
||
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
||
}
|
||
|
||
// to determine the Accept header
|
||
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
||
|
||
// set Accept header
|
||
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
||
if localVarHTTPHeaderAccept != "" {
|
||
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
||
}
|
||
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
||
if err != nil {
|
||
return localVarReturnValue, nil, err
|
||
}
|
||
|
||
localVarHTTPResponse, err := a.client.callAPI(req)
|
||
if err != nil || localVarHTTPResponse == nil {
|
||
return localVarReturnValue, localVarHTTPResponse, err
|
||
}
|
||
|
||
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
||
localVarHTTPResponse.Body.Close()
|
||
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
||
if err != nil {
|
||
return localVarReturnValue, localVarHTTPResponse, err
|
||
}
|
||
|
||
if localVarHTTPResponse.StatusCode >= 300 {
|
||
newErr := &GenericOpenAPIError{
|
||
body: localVarBody,
|
||
error: localVarHTTPResponse.Status,
|
||
}
|
||
var v ProblemDetails
|
||
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
||
if err != nil {
|
||
newErr.error = err.Error()
|
||
return localVarReturnValue, localVarHTTPResponse, newErr
|
||
}
|
||
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
||
newErr.model = v
|
||
return localVarReturnValue, localVarHTTPResponse, newErr
|
||
}
|
||
|
||
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
||
if err != nil {
|
||
newErr := &GenericOpenAPIError{
|
||
body: localVarBody,
|
||
error: err.Error(),
|
||
}
|
||
return localVarReturnValue, localVarHTTPResponse, newErr
|
||
}
|
||
|
||
return localVarReturnValue, localVarHTTPResponse, nil
|
||
}
|
||
|
||
type MqAPIGetMqStreamByNameMessageRequest struct {
|
||
ctx context.Context
|
||
ApiService *MqAPIService
|
||
name string
|
||
seq *int32
|
||
lastBySubject *string
|
||
nextBySubject *string
|
||
limit *int64
|
||
}
|
||
|
||
// Seq reads the message at this sequence (with next_by_subject: the walk's start).
|
||
func (r MqAPIGetMqStreamByNameMessageRequest) Seq(seq int32) MqAPIGetMqStreamByNameMessageRequest {
|
||
r.seq = &seq
|
||
return r
|
||
}
|
||
|
||
// LastBySubject reads the newest message on this org-relative subject.
|
||
func (r MqAPIGetMqStreamByNameMessageRequest) LastBySubject(lastBySubject string) MqAPIGetMqStreamByNameMessageRequest {
|
||
r.lastBySubject = &lastBySubject
|
||
return r
|
||
}
|
||
|
||
// NextBySubject walks forward from seq collecting messages on this org-relative subject (wildcards supported).
|
||
func (r MqAPIGetMqStreamByNameMessageRequest) NextBySubject(nextBySubject string) MqAPIGetMqStreamByNameMessageRequest {
|
||
r.nextBySubject = &nextBySubject
|
||
return r
|
||
}
|
||
|
||
// Limit caps a next_by_subject walk (1–1000, default 100).
|
||
func (r MqAPIGetMqStreamByNameMessageRequest) Limit(limit int64) MqAPIGetMqStreamByNameMessageRequest {
|
||
r.limit = &limit
|
||
return r
|
||
}
|
||
|
||
func (r MqAPIGetMqStreamByNameMessageRequest) Execute() (*MqReadOut, *http.Response, error) {
|
||
return r.ApiService.GetMqStreamByNameMessageExecute(r)
|
||
}
|
||
|
||
/*
|
||
GetMqStreamByNameMessage Reads stored messages without a consumer: by sequence, by newest on a subject, or walking a subject forward from a sequence.
|
||
|
||
Reads stored messages without a consumer: by sequence, by newest on a
|
||
subject, or walking a subject forward from a sequence.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@param name Name is the stream name, from the path.
|
||
@return MqAPIGetMqStreamByNameMessageRequest
|
||
*/
|
||
func (a *MqAPIService) GetMqStreamByNameMessage(ctx context.Context, name string) MqAPIGetMqStreamByNameMessageRequest {
|
||
return MqAPIGetMqStreamByNameMessageRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
name: name,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return MqReadOut
|
||
func (a *MqAPIService) GetMqStreamByNameMessageExecute(r MqAPIGetMqStreamByNameMessageRequest) (*MqReadOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodGet
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *MqReadOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "MqAPIService.GetMqStreamByNameMessage")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/mq/stream/{name}/message"
|
||
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
|
||
if r.seq != nil {
|
||
parameterAddToHeaderOrQuery(localVarQueryParams, "seq", r.seq, "form", "")
|
||
}
|
||
if r.lastBySubject != nil {
|
||
parameterAddToHeaderOrQuery(localVarQueryParams, "last_by_subject", r.lastBySubject, "form", "")
|
||
}
|
||
if r.nextBySubject != nil {
|
||
parameterAddToHeaderOrQuery(localVarQueryParams, "next_by_subject", r.nextBySubject, "form", "")
|
||
}
|
||
if r.limit != nil {
|
||
parameterAddToHeaderOrQuery(localVarQueryParams, "limit", r.limit, "form", "")
|
||
}
|
||
// to determine the Content-Type header
|
||
localVarHTTPContentTypes := []string{}
|
||
|
||
// set Content-Type header
|
||
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
||
if localVarHTTPContentType != "" {
|
||
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
||
}
|
||
|
||
// to determine the Accept header
|
||
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
||
|
||
// set Accept header
|
||
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
||
if localVarHTTPHeaderAccept != "" {
|
||
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
||
}
|
||
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
||
if err != nil {
|
||
return localVarReturnValue, nil, err
|
||
}
|
||
|
||
localVarHTTPResponse, err := a.client.callAPI(req)
|
||
if err != nil || localVarHTTPResponse == nil {
|
||
return localVarReturnValue, localVarHTTPResponse, err
|
||
}
|
||
|
||
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
||
localVarHTTPResponse.Body.Close()
|
||
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
||
if err != nil {
|
||
return localVarReturnValue, localVarHTTPResponse, err
|
||
}
|
||
|
||
if localVarHTTPResponse.StatusCode >= 300 {
|
||
newErr := &GenericOpenAPIError{
|
||
body: localVarBody,
|
||
error: localVarHTTPResponse.Status,
|
||
}
|
||
var v ProblemDetails
|
||
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
||
if err != nil {
|
||
newErr.error = err.Error()
|
||
return localVarReturnValue, localVarHTTPResponse, newErr
|
||
}
|
||
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
||
newErr.model = v
|
||
return localVarReturnValue, localVarHTTPResponse, newErr
|
||
}
|
||
|
||
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
||
if err != nil {
|
||
newErr := &GenericOpenAPIError{
|
||
body: localVarBody,
|
||
error: err.Error(),
|
||
}
|
||
return localVarReturnValue, localVarHTTPResponse, newErr
|
||
}
|
||
|
||
return localVarReturnValue, localVarHTTPResponse, nil
|
||
}
|
||
|
||
type MqAPIGetMqStreamByStreamConsumerRequest struct {
|
||
ctx context.Context
|
||
ApiService *MqAPIService
|
||
stream string
|
||
limit *int64
|
||
offset *int64
|
||
}
|
||
|
||
// Limit caps the consumers returned (1–1000, default 100).
|
||
func (r MqAPIGetMqStreamByStreamConsumerRequest) Limit(limit int64) MqAPIGetMqStreamByStreamConsumerRequest {
|
||
r.limit = &limit
|
||
return r
|
||
}
|
||
|
||
// Offset skips that many consumers, name-ordered.
|
||
func (r MqAPIGetMqStreamByStreamConsumerRequest) Offset(offset int64) MqAPIGetMqStreamByStreamConsumerRequest {
|
||
r.offset = &offset
|
||
return r
|
||
}
|
||
|
||
func (r MqAPIGetMqStreamByStreamConsumerRequest) Execute() (*MqPickOut, *http.Response, error) {
|
||
return r.ApiService.GetMqStreamByStreamConsumerExecute(r)
|
||
}
|
||
|
||
/*
|
||
GetMqStreamByStreamConsumer Returns a stream's consumers, name-ordered, with delivery state.
|
||
|
||
Returns a stream's consumers, name-ordered, with delivery state.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@param stream Stream is the stream name, from the path.
|
||
@return MqAPIGetMqStreamByStreamConsumerRequest
|
||
*/
|
||
func (a *MqAPIService) GetMqStreamByStreamConsumer(ctx context.Context, stream string) MqAPIGetMqStreamByStreamConsumerRequest {
|
||
return MqAPIGetMqStreamByStreamConsumerRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
stream: stream,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return MqPickOut
|
||
func (a *MqAPIService) GetMqStreamByStreamConsumerExecute(r MqAPIGetMqStreamByStreamConsumerRequest) (*MqPickOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodGet
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *MqPickOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "MqAPIService.GetMqStreamByStreamConsumer")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/mq/stream/{stream}/consumer"
|
||
localVarPath = strings.Replace(localVarPath, "{"+"stream"+"}", url.PathEscape(parameterValueToString(r.stream, "stream")), -1)
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
|
||
if r.limit != nil {
|
||
parameterAddToHeaderOrQuery(localVarQueryParams, "limit", r.limit, "form", "")
|
||
}
|
||
if r.offset != nil {
|
||
parameterAddToHeaderOrQuery(localVarQueryParams, "offset", r.offset, "form", "")
|
||
}
|
||
// to determine the Content-Type header
|
||
localVarHTTPContentTypes := []string{}
|
||
|
||
// set Content-Type header
|
||
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
||
if localVarHTTPContentType != "" {
|
||
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
||
}
|
||
|
||
// to determine the Accept header
|
||
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
||
|
||
// set Accept header
|
||
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
||
if localVarHTTPHeaderAccept != "" {
|
||
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
||
}
|
||
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
||
if err != nil {
|
||
return localVarReturnValue, nil, err
|
||
}
|
||
|
||
localVarHTTPResponse, err := a.client.callAPI(req)
|
||
if err != nil || localVarHTTPResponse == nil {
|
||
return localVarReturnValue, localVarHTTPResponse, err
|
||
}
|
||
|
||
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
||
localVarHTTPResponse.Body.Close()
|
||
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
||
if err != nil {
|
||
return localVarReturnValue, localVarHTTPResponse, err
|
||
}
|
||
|
||
if localVarHTTPResponse.StatusCode >= 300 {
|
||
newErr := &GenericOpenAPIError{
|
||
body: localVarBody,
|
||
error: localVarHTTPResponse.Status,
|
||
}
|
||
var v ProblemDetails
|
||
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
||
if err != nil {
|
||
newErr.error = err.Error()
|
||
return localVarReturnValue, localVarHTTPResponse, newErr
|
||
}
|
||
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
||
newErr.model = v
|
||
return localVarReturnValue, localVarHTTPResponse, newErr
|
||
}
|
||
|
||
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
||
if err != nil {
|
||
newErr := &GenericOpenAPIError{
|
||
body: localVarBody,
|
||
error: err.Error(),
|
||
}
|
||
return localVarReturnValue, localVarHTTPResponse, newErr
|
||
}
|
||
|
||
return localVarReturnValue, localVarHTTPResponse, nil
|
||
}
|
||
|
||
type MqAPIGetMqStreamByStreamConsumerByNameRequest struct {
|
||
ctx context.Context
|
||
ApiService *MqAPIService
|
||
stream string
|
||
name string
|
||
}
|
||
|
||
func (r MqAPIGetMqStreamByStreamConsumerByNameRequest) Execute() (*MqConsumer, *http.Response, error) {
|
||
return r.ApiService.GetMqStreamByStreamConsumerByNameExecute(r)
|
||
}
|
||
|
||
/*
|
||
GetMqStreamByStreamConsumerByName Returns one consumer's configuration and delivery state.
|
||
|
||
Returns one consumer's configuration and delivery state.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@param stream Stream is the stream name, from the path.
|
||
@param name Name is the consumer name, from the path.
|
||
@return MqAPIGetMqStreamByStreamConsumerByNameRequest
|
||
*/
|
||
func (a *MqAPIService) GetMqStreamByStreamConsumerByName(ctx context.Context, stream string, name string) MqAPIGetMqStreamByStreamConsumerByNameRequest {
|
||
return MqAPIGetMqStreamByStreamConsumerByNameRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
stream: stream,
|
||
name: name,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return MqConsumer
|
||
func (a *MqAPIService) GetMqStreamByStreamConsumerByNameExecute(r MqAPIGetMqStreamByStreamConsumerByNameRequest) (*MqConsumer, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodGet
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *MqConsumer
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "MqAPIService.GetMqStreamByStreamConsumerByName")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/mq/stream/{stream}/consumer/{name}"
|
||
localVarPath = strings.Replace(localVarPath, "{"+"stream"+"}", url.PathEscape(parameterValueToString(r.stream, "stream")), -1)
|
||
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
|
||
// to determine the Content-Type header
|
||
localVarHTTPContentTypes := []string{}
|
||
|
||
// set Content-Type header
|
||
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
||
if localVarHTTPContentType != "" {
|
||
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
||
}
|
||
|
||
// to determine the Accept header
|
||
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
||
|
||
// set Accept header
|
||
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
||
if localVarHTTPHeaderAccept != "" {
|
||
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
||
}
|
||
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
||
if err != nil {
|
||
return localVarReturnValue, nil, err
|
||
}
|
||
|
||
localVarHTTPResponse, err := a.client.callAPI(req)
|
||
if err != nil || localVarHTTPResponse == nil {
|
||
return localVarReturnValue, localVarHTTPResponse, err
|
||
}
|
||
|
||
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
||
localVarHTTPResponse.Body.Close()
|
||
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
||
if err != nil {
|
||
return localVarReturnValue, localVarHTTPResponse, err
|
||
}
|
||
|
||
if localVarHTTPResponse.StatusCode >= 300 {
|
||
newErr := &GenericOpenAPIError{
|
||
body: localVarBody,
|
||
error: localVarHTTPResponse.Status,
|
||
}
|
||
var v ProblemDetails
|
||
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
||
if err != nil {
|
||
newErr.error = err.Error()
|
||
return localVarReturnValue, localVarHTTPResponse, newErr
|
||
}
|
||
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
||
newErr.model = v
|
||
return localVarReturnValue, localVarHTTPResponse, newErr
|
||
}
|
||
|
||
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
||
if err != nil {
|
||
newErr := &GenericOpenAPIError{
|
||
body: localVarBody,
|
||
error: err.Error(),
|
||
}
|
||
return localVarReturnValue, localVarHTTPResponse, newErr
|
||
}
|
||
|
||
return localVarReturnValue, localVarHTTPResponse, nil
|
||
}
|
||
|
||
type MqAPIPostMqStreamRequest struct {
|
||
ctx context.Context
|
||
ApiService *MqAPIService
|
||
mqConfig *MqConfig
|
||
}
|
||
|
||
func (r MqAPIPostMqStreamRequest) MqConfig(mqConfig MqConfig) MqAPIPostMqStreamRequest {
|
||
r.mqConfig = &mqConfig
|
||
return r
|
||
}
|
||
|
||
func (r MqAPIPostMqStreamRequest) Execute() (*MqStream, *http.Response, error) {
|
||
return r.ApiService.PostMqStreamExecute(r)
|
||
}
|
||
|
||
/*
|
||
PostMqStream Creates a durable stream in the org's namespace and returns it.
|
||
|
||
Creates a durable stream in the org's namespace and returns it.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@return MqAPIPostMqStreamRequest
|
||
*/
|
||
func (a *MqAPIService) PostMqStream(ctx context.Context) MqAPIPostMqStreamRequest {
|
||
return MqAPIPostMqStreamRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return MqStream
|
||
func (a *MqAPIService) PostMqStreamExecute(r MqAPIPostMqStreamRequest) (*MqStream, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodPost
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *MqStream
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "MqAPIService.PostMqStream")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/mq/stream"
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
if r.mqConfig == nil {
|
||
return localVarReturnValue, nil, reportError("mqConfig is required and must be specified")
|
||
}
|
||
|
||
// to determine the Content-Type header
|
||
localVarHTTPContentTypes := []string{"application/json"}
|
||
|
||
// set Content-Type header
|
||
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
||
if localVarHTTPContentType != "" {
|
||
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
||
}
|
||
|
||
// to determine the Accept header
|
||
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
||
|
||
// set Accept header
|
||
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
||
if localVarHTTPHeaderAccept != "" {
|
||
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
||
}
|
||
// body params
|
||
localVarPostBody = r.mqConfig
|
||
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
||
if err != nil {
|
||
return localVarReturnValue, nil, err
|
||
}
|
||
|
||
localVarHTTPResponse, err := a.client.callAPI(req)
|
||
if err != nil || localVarHTTPResponse == nil {
|
||
return localVarReturnValue, localVarHTTPResponse, err
|
||
}
|
||
|
||
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
||
localVarHTTPResponse.Body.Close()
|
||
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
||
if err != nil {
|
||
return localVarReturnValue, localVarHTTPResponse, err
|
||
}
|
||
|
||
if localVarHTTPResponse.StatusCode >= 300 {
|
||
newErr := &GenericOpenAPIError{
|
||
body: localVarBody,
|
||
error: localVarHTTPResponse.Status,
|
||
}
|
||
var v ProblemDetails
|
||
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
||
if err != nil {
|
||
newErr.error = err.Error()
|
||
return localVarReturnValue, localVarHTTPResponse, newErr
|
||
}
|
||
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
||
newErr.model = v
|
||
return localVarReturnValue, localVarHTTPResponse, newErr
|
||
}
|
||
|
||
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
||
if err != nil {
|
||
newErr := &GenericOpenAPIError{
|
||
body: localVarBody,
|
||
error: err.Error(),
|
||
}
|
||
return localVarReturnValue, localVarHTTPResponse, newErr
|
||
}
|
||
|
||
return localVarReturnValue, localVarHTTPResponse, nil
|
||
}
|
||
|
||
type MqAPIPostMqStreamByNamePurgeRequest struct {
|
||
ctx context.Context
|
||
ApiService *MqAPIService
|
||
name string
|
||
mqPurge *MqPurge
|
||
}
|
||
|
||
func (r MqAPIPostMqStreamByNamePurgeRequest) MqPurge(mqPurge MqPurge) MqAPIPostMqStreamByNamePurgeRequest {
|
||
r.mqPurge = &mqPurge
|
||
return r
|
||
}
|
||
|
||
func (r MqAPIPostMqStreamByNamePurgeRequest) Execute() (*MqPurgeOut, *http.Response, error) {
|
||
return r.ApiService.PostMqStreamByNamePurgeExecute(r)
|
||
}
|
||
|
||
/*
|
||
PostMqStreamByNamePurge Removes messages from a stream, leaving its consumers in place.
|
||
|
||
Removes messages from a stream, leaving its consumers in place.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@param name Name is the stream name, from the path.
|
||
@return MqAPIPostMqStreamByNamePurgeRequest
|
||
*/
|
||
func (a *MqAPIService) PostMqStreamByNamePurge(ctx context.Context, name string) MqAPIPostMqStreamByNamePurgeRequest {
|
||
return MqAPIPostMqStreamByNamePurgeRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
name: name,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return MqPurgeOut
|
||
func (a *MqAPIService) PostMqStreamByNamePurgeExecute(r MqAPIPostMqStreamByNamePurgeRequest) (*MqPurgeOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodPost
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *MqPurgeOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "MqAPIService.PostMqStreamByNamePurge")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/mq/stream/{name}/purge"
|
||
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
if r.mqPurge == nil {
|
||
return localVarReturnValue, nil, reportError("mqPurge is required and must be specified")
|
||
}
|
||
|
||
// to determine the Content-Type header
|
||
localVarHTTPContentTypes := []string{"application/json"}
|
||
|
||
// set Content-Type header
|
||
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
||
if localVarHTTPContentType != "" {
|
||
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
||
}
|
||
|
||
// to determine the Accept header
|
||
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
||
|
||
// set Accept header
|
||
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
||
if localVarHTTPHeaderAccept != "" {
|
||
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
||
}
|
||
// body params
|
||
localVarPostBody = r.mqPurge
|
||
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
||
if err != nil {
|
||
return localVarReturnValue, nil, err
|
||
}
|
||
|
||
localVarHTTPResponse, err := a.client.callAPI(req)
|
||
if err != nil || localVarHTTPResponse == nil {
|
||
return localVarReturnValue, localVarHTTPResponse, err
|
||
}
|
||
|
||
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
||
localVarHTTPResponse.Body.Close()
|
||
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
||
if err != nil {
|
||
return localVarReturnValue, localVarHTTPResponse, err
|
||
}
|
||
|
||
if localVarHTTPResponse.StatusCode >= 300 {
|
||
newErr := &GenericOpenAPIError{
|
||
body: localVarBody,
|
||
error: localVarHTTPResponse.Status,
|
||
}
|
||
var v ProblemDetails
|
||
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
||
if err != nil {
|
||
newErr.error = err.Error()
|
||
return localVarReturnValue, localVarHTTPResponse, newErr
|
||
}
|
||
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
||
newErr.model = v
|
||
return localVarReturnValue, localVarHTTPResponse, newErr
|
||
}
|
||
|
||
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
||
if err != nil {
|
||
newErr := &GenericOpenAPIError{
|
||
body: localVarBody,
|
||
error: err.Error(),
|
||
}
|
||
return localVarReturnValue, localVarHTTPResponse, newErr
|
||
}
|
||
|
||
return localVarReturnValue, localVarHTTPResponse, nil
|
||
}
|
||
|
||
type MqAPIPostMqStreamByStreamConsumerRequest struct {
|
||
ctx context.Context
|
||
ApiService *MqAPIService
|
||
stream string
|
||
mqMakeIn *MqMakeIn
|
||
}
|
||
|
||
func (r MqAPIPostMqStreamByStreamConsumerRequest) MqMakeIn(mqMakeIn MqMakeIn) MqAPIPostMqStreamByStreamConsumerRequest {
|
||
r.mqMakeIn = &mqMakeIn
|
||
return r
|
||
}
|
||
|
||
func (r MqAPIPostMqStreamByStreamConsumerRequest) Execute() (*MqConsumer, *http.Response, error) {
|
||
return r.ApiService.PostMqStreamByStreamConsumerExecute(r)
|
||
}
|
||
|
||
/*
|
||
PostMqStreamByStreamConsumer Creates a durable pull consumer on a stream and returns it.
|
||
|
||
Creates a durable pull consumer on a stream and returns it.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@param stream Stream is the stream name, from the path.
|
||
@return MqAPIPostMqStreamByStreamConsumerRequest
|
||
*/
|
||
func (a *MqAPIService) PostMqStreamByStreamConsumer(ctx context.Context, stream string) MqAPIPostMqStreamByStreamConsumerRequest {
|
||
return MqAPIPostMqStreamByStreamConsumerRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
stream: stream,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return MqConsumer
|
||
func (a *MqAPIService) PostMqStreamByStreamConsumerExecute(r MqAPIPostMqStreamByStreamConsumerRequest) (*MqConsumer, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodPost
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *MqConsumer
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "MqAPIService.PostMqStreamByStreamConsumer")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/mq/stream/{stream}/consumer"
|
||
localVarPath = strings.Replace(localVarPath, "{"+"stream"+"}", url.PathEscape(parameterValueToString(r.stream, "stream")), -1)
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
if r.mqMakeIn == nil {
|
||
return localVarReturnValue, nil, reportError("mqMakeIn is required and must be specified")
|
||
}
|
||
|
||
// to determine the Content-Type header
|
||
localVarHTTPContentTypes := []string{"application/json"}
|
||
|
||
// set Content-Type header
|
||
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
||
if localVarHTTPContentType != "" {
|
||
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
||
}
|
||
|
||
// to determine the Accept header
|
||
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
||
|
||
// set Accept header
|
||
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
||
if localVarHTTPHeaderAccept != "" {
|
||
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
||
}
|
||
// body params
|
||
localVarPostBody = r.mqMakeIn
|
||
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
||
if err != nil {
|
||
return localVarReturnValue, nil, err
|
||
}
|
||
|
||
localVarHTTPResponse, err := a.client.callAPI(req)
|
||
if err != nil || localVarHTTPResponse == nil {
|
||
return localVarReturnValue, localVarHTTPResponse, err
|
||
}
|
||
|
||
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
||
localVarHTTPResponse.Body.Close()
|
||
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
||
if err != nil {
|
||
return localVarReturnValue, localVarHTTPResponse, err
|
||
}
|
||
|
||
if localVarHTTPResponse.StatusCode >= 300 {
|
||
newErr := &GenericOpenAPIError{
|
||
body: localVarBody,
|
||
error: localVarHTTPResponse.Status,
|
||
}
|
||
var v ProblemDetails
|
||
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
||
if err != nil {
|
||
newErr.error = err.Error()
|
||
return localVarReturnValue, localVarHTTPResponse, newErr
|
||
}
|
||
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
||
newErr.model = v
|
||
return localVarReturnValue, localVarHTTPResponse, newErr
|
||
}
|
||
|
||
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
||
if err != nil {
|
||
newErr := &GenericOpenAPIError{
|
||
body: localVarBody,
|
||
error: err.Error(),
|
||
}
|
||
return localVarReturnValue, localVarHTTPResponse, newErr
|
||
}
|
||
|
||
return localVarReturnValue, localVarHTTPResponse, nil
|
||
}
|
||
|
||
type MqAPIPostMqStreamByStreamConsumerByNameNextRequest struct {
|
||
ctx context.Context
|
||
ApiService *MqAPIService
|
||
stream string
|
||
name string
|
||
mqNextIn *MqNextIn
|
||
}
|
||
|
||
func (r MqAPIPostMqStreamByStreamConsumerByNameNextRequest) MqNextIn(mqNextIn MqNextIn) MqAPIPostMqStreamByStreamConsumerByNameNextRequest {
|
||
r.mqNextIn = &mqNextIn
|
||
return r
|
||
}
|
||
|
||
func (r MqAPIPostMqStreamByStreamConsumerByNameNextRequest) Execute() (*MqReadOut, *http.Response, error) {
|
||
return r.ApiService.PostMqStreamByStreamConsumerByNameNextExecute(r)
|
||
}
|
||
|
||
/*
|
||
PostMqStreamByStreamConsumerByNameNext Pulls the consumer's next batch.
|
||
|
||
Pulls the consumer's next batch. Delivered messages are acknowledged on
|
||
delivery — the broker will not redeliver what this call returns; an empty
|
||
wait answers 408.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@param stream Stream is the stream name, from the path.
|
||
@param name Name is the consumer name, from the path.
|
||
@return MqAPIPostMqStreamByStreamConsumerByNameNextRequest
|
||
*/
|
||
func (a *MqAPIService) PostMqStreamByStreamConsumerByNameNext(ctx context.Context, stream string, name string) MqAPIPostMqStreamByStreamConsumerByNameNextRequest {
|
||
return MqAPIPostMqStreamByStreamConsumerByNameNextRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
stream: stream,
|
||
name: name,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return MqReadOut
|
||
func (a *MqAPIService) PostMqStreamByStreamConsumerByNameNextExecute(r MqAPIPostMqStreamByStreamConsumerByNameNextRequest) (*MqReadOut, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodPost
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *MqReadOut
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "MqAPIService.PostMqStreamByStreamConsumerByNameNext")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/mq/stream/{stream}/consumer/{name}/next"
|
||
localVarPath = strings.Replace(localVarPath, "{"+"stream"+"}", url.PathEscape(parameterValueToString(r.stream, "stream")), -1)
|
||
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
if r.mqNextIn == nil {
|
||
return localVarReturnValue, nil, reportError("mqNextIn is required and must be specified")
|
||
}
|
||
|
||
// to determine the Content-Type header
|
||
localVarHTTPContentTypes := []string{"application/json"}
|
||
|
||
// set Content-Type header
|
||
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
||
if localVarHTTPContentType != "" {
|
||
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
||
}
|
||
|
||
// to determine the Accept header
|
||
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
||
|
||
// set Accept header
|
||
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
||
if localVarHTTPHeaderAccept != "" {
|
||
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
||
}
|
||
// body params
|
||
localVarPostBody = r.mqNextIn
|
||
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
||
if err != nil {
|
||
return localVarReturnValue, nil, err
|
||
}
|
||
|
||
localVarHTTPResponse, err := a.client.callAPI(req)
|
||
if err != nil || localVarHTTPResponse == nil {
|
||
return localVarReturnValue, localVarHTTPResponse, err
|
||
}
|
||
|
||
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
||
localVarHTTPResponse.Body.Close()
|
||
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
||
if err != nil {
|
||
return localVarReturnValue, localVarHTTPResponse, err
|
||
}
|
||
|
||
if localVarHTTPResponse.StatusCode >= 300 {
|
||
newErr := &GenericOpenAPIError{
|
||
body: localVarBody,
|
||
error: localVarHTTPResponse.Status,
|
||
}
|
||
var v ProblemDetails
|
||
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
||
if err != nil {
|
||
newErr.error = err.Error()
|
||
return localVarReturnValue, localVarHTTPResponse, newErr
|
||
}
|
||
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
||
newErr.model = v
|
||
return localVarReturnValue, localVarHTTPResponse, newErr
|
||
}
|
||
|
||
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
||
if err != nil {
|
||
newErr := &GenericOpenAPIError{
|
||
body: localVarBody,
|
||
error: err.Error(),
|
||
}
|
||
return localVarReturnValue, localVarHTTPResponse, newErr
|
||
}
|
||
|
||
return localVarReturnValue, localVarHTTPResponse, nil
|
||
}
|
||
|
||
type MqAPIPutMqStreamByNameRequest struct {
|
||
ctx context.Context
|
||
ApiService *MqAPIService
|
||
name string
|
||
mqConfig *MqConfig
|
||
}
|
||
|
||
func (r MqAPIPutMqStreamByNameRequest) MqConfig(mqConfig MqConfig) MqAPIPutMqStreamByNameRequest {
|
||
r.mqConfig = &mqConfig
|
||
return r
|
||
}
|
||
|
||
func (r MqAPIPutMqStreamByNameRequest) Execute() (*MqStream, *http.Response, error) {
|
||
return r.ApiService.PutMqStreamByNameExecute(r)
|
||
}
|
||
|
||
/*
|
||
PutMqStreamByName Reconfigures an existing stream; the path names the stream, and the immutable fields (storage, retention) must restate what they are.
|
||
|
||
Reconfigures an existing stream; the path names the stream, and the
|
||
immutable fields (storage, retention) must restate what they are.
|
||
|
||
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
||
@param name Name is the stream name, unique within the org (alphanumeric, hyphens, underscores).
|
||
@return MqAPIPutMqStreamByNameRequest
|
||
*/
|
||
func (a *MqAPIService) PutMqStreamByName(ctx context.Context, name string) MqAPIPutMqStreamByNameRequest {
|
||
return MqAPIPutMqStreamByNameRequest{
|
||
ApiService: a,
|
||
ctx: ctx,
|
||
name: name,
|
||
}
|
||
}
|
||
|
||
// Execute executes the request
|
||
//
|
||
// @return MqStream
|
||
func (a *MqAPIService) PutMqStreamByNameExecute(r MqAPIPutMqStreamByNameRequest) (*MqStream, *http.Response, error) {
|
||
var (
|
||
localVarHTTPMethod = http.MethodPut
|
||
localVarPostBody interface{}
|
||
formFiles []formFile
|
||
localVarReturnValue *MqStream
|
||
)
|
||
|
||
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "MqAPIService.PutMqStreamByName")
|
||
if err != nil {
|
||
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
||
}
|
||
|
||
localVarPath := localBasePath + "/v1/mq/stream/{name}"
|
||
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
|
||
|
||
localVarHeaderParams := make(map[string]string)
|
||
localVarQueryParams := url.Values{}
|
||
localVarFormParams := url.Values{}
|
||
if r.mqConfig == nil {
|
||
return localVarReturnValue, nil, reportError("mqConfig is required and must be specified")
|
||
}
|
||
|
||
// to determine the Content-Type header
|
||
localVarHTTPContentTypes := []string{"application/json"}
|
||
|
||
// set Content-Type header
|
||
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
||
if localVarHTTPContentType != "" {
|
||
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
||
}
|
||
|
||
// to determine the Accept header
|
||
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
||
|
||
// set Accept header
|
||
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
||
if localVarHTTPHeaderAccept != "" {
|
||
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
||
}
|
||
// body params
|
||
localVarPostBody = r.mqConfig
|
||
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
||
if err != nil {
|
||
return localVarReturnValue, nil, err
|
||
}
|
||
|
||
localVarHTTPResponse, err := a.client.callAPI(req)
|
||
if err != nil || localVarHTTPResponse == nil {
|
||
return localVarReturnValue, localVarHTTPResponse, err
|
||
}
|
||
|
||
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
||
localVarHTTPResponse.Body.Close()
|
||
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
||
if err != nil {
|
||
return localVarReturnValue, localVarHTTPResponse, err
|
||
}
|
||
|
||
if localVarHTTPResponse.StatusCode >= 300 {
|
||
newErr := &GenericOpenAPIError{
|
||
body: localVarBody,
|
||
error: localVarHTTPResponse.Status,
|
||
}
|
||
var v ProblemDetails
|
||
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
||
if err != nil {
|
||
newErr.error = err.Error()
|
||
return localVarReturnValue, localVarHTTPResponse, newErr
|
||
}
|
||
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
||
newErr.model = v
|
||
return localVarReturnValue, localVarHTTPResponse, newErr
|
||
}
|
||
|
||
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
||
if err != nil {
|
||
newErr := &GenericOpenAPIError{
|
||
body: localVarBody,
|
||
error: err.Error(),
|
||
}
|
||
return localVarReturnValue, localVarHTTPResponse, newErr
|
||
}
|
||
|
||
return localVarReturnValue, localVarHTTPResponse, nil
|
||
}
|