Update generated swagger client code

Signed-off-by: Mihaela Balutoiu <mbalutoiu@cloudbasesolutions.com>
This commit is contained in:
Mihaela Balutoiu 2023-07-18 20:38:34 +03:00
parent 802c7527fe
commit d2b78793f5
25 changed files with 4339 additions and 0 deletions

View file

@ -0,0 +1,151 @@
// Code generated by go-swagger; DO NOT EDIT.
package enterprises
// This file was generated by the swagger tool.
// Editing this file might prove futile when you re-run the swagger generate command
import (
"context"
"net/http"
"time"
"github.com/go-openapi/errors"
"github.com/go-openapi/runtime"
cr "github.com/go-openapi/runtime/client"
"github.com/go-openapi/strfmt"
garm_params "github.com/cloudbase/garm/params"
)
// NewCreateEnterpriseParams creates a new CreateEnterpriseParams object,
// with the default timeout for this client.
//
// Default values are not hydrated, since defaults are normally applied by the API server side.
//
// To enforce default values in parameter, use SetDefaults or WithDefaults.
func NewCreateEnterpriseParams() *CreateEnterpriseParams {
return &CreateEnterpriseParams{
timeout: cr.DefaultTimeout,
}
}
// NewCreateEnterpriseParamsWithTimeout creates a new CreateEnterpriseParams object
// with the ability to set a timeout on a request.
func NewCreateEnterpriseParamsWithTimeout(timeout time.Duration) *CreateEnterpriseParams {
return &CreateEnterpriseParams{
timeout: timeout,
}
}
// NewCreateEnterpriseParamsWithContext creates a new CreateEnterpriseParams object
// with the ability to set a context for a request.
func NewCreateEnterpriseParamsWithContext(ctx context.Context) *CreateEnterpriseParams {
return &CreateEnterpriseParams{
Context: ctx,
}
}
// NewCreateEnterpriseParamsWithHTTPClient creates a new CreateEnterpriseParams object
// with the ability to set a custom HTTPClient for a request.
func NewCreateEnterpriseParamsWithHTTPClient(client *http.Client) *CreateEnterpriseParams {
return &CreateEnterpriseParams{
HTTPClient: client,
}
}
/*
CreateEnterpriseParams contains all the parameters to send to the API endpoint
for the create enterprise operation.
Typically these are written to a http.Request.
*/
type CreateEnterpriseParams struct {
/* Body.
Parameters used to create the enterprise.
*/
Body garm_params.CreateEnterpriseParams
timeout time.Duration
Context context.Context
HTTPClient *http.Client
}
// WithDefaults hydrates default values in the create enterprise params (not the query body).
//
// All values with no default are reset to their zero value.
func (o *CreateEnterpriseParams) WithDefaults() *CreateEnterpriseParams {
o.SetDefaults()
return o
}
// SetDefaults hydrates default values in the create enterprise params (not the query body).
//
// All values with no default are reset to their zero value.
func (o *CreateEnterpriseParams) SetDefaults() {
// no default values defined for this parameter
}
// WithTimeout adds the timeout to the create enterprise params
func (o *CreateEnterpriseParams) WithTimeout(timeout time.Duration) *CreateEnterpriseParams {
o.SetTimeout(timeout)
return o
}
// SetTimeout adds the timeout to the create enterprise params
func (o *CreateEnterpriseParams) SetTimeout(timeout time.Duration) {
o.timeout = timeout
}
// WithContext adds the context to the create enterprise params
func (o *CreateEnterpriseParams) WithContext(ctx context.Context) *CreateEnterpriseParams {
o.SetContext(ctx)
return o
}
// SetContext adds the context to the create enterprise params
func (o *CreateEnterpriseParams) SetContext(ctx context.Context) {
o.Context = ctx
}
// WithHTTPClient adds the HTTPClient to the create enterprise params
func (o *CreateEnterpriseParams) WithHTTPClient(client *http.Client) *CreateEnterpriseParams {
o.SetHTTPClient(client)
return o
}
// SetHTTPClient adds the HTTPClient to the create enterprise params
func (o *CreateEnterpriseParams) SetHTTPClient(client *http.Client) {
o.HTTPClient = client
}
// WithBody adds the body to the create enterprise params
func (o *CreateEnterpriseParams) WithBody(body garm_params.CreateEnterpriseParams) *CreateEnterpriseParams {
o.SetBody(body)
return o
}
// SetBody adds the body to the create enterprise params
func (o *CreateEnterpriseParams) SetBody(body garm_params.CreateEnterpriseParams) {
o.Body = body
}
// WriteToRequest writes these params to a swagger request
func (o *CreateEnterpriseParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error {
if err := r.SetTimeout(o.timeout); err != nil {
return err
}
var res []error
if err := r.SetBodyParam(o.Body); err != nil {
return err
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
}

View file

@ -0,0 +1,173 @@
// Code generated by go-swagger; DO NOT EDIT.
package enterprises
// This file was generated by the swagger tool.
// Editing this file might prove futile when you re-run the swagger generate command
import (
"context"
"net/http"
"time"
"github.com/go-openapi/errors"
"github.com/go-openapi/runtime"
cr "github.com/go-openapi/runtime/client"
"github.com/go-openapi/strfmt"
garm_params "github.com/cloudbase/garm/params"
)
// NewCreateEnterprisePoolParams creates a new CreateEnterprisePoolParams object,
// with the default timeout for this client.
//
// Default values are not hydrated, since defaults are normally applied by the API server side.
//
// To enforce default values in parameter, use SetDefaults or WithDefaults.
func NewCreateEnterprisePoolParams() *CreateEnterprisePoolParams {
return &CreateEnterprisePoolParams{
timeout: cr.DefaultTimeout,
}
}
// NewCreateEnterprisePoolParamsWithTimeout creates a new CreateEnterprisePoolParams object
// with the ability to set a timeout on a request.
func NewCreateEnterprisePoolParamsWithTimeout(timeout time.Duration) *CreateEnterprisePoolParams {
return &CreateEnterprisePoolParams{
timeout: timeout,
}
}
// NewCreateEnterprisePoolParamsWithContext creates a new CreateEnterprisePoolParams object
// with the ability to set a context for a request.
func NewCreateEnterprisePoolParamsWithContext(ctx context.Context) *CreateEnterprisePoolParams {
return &CreateEnterprisePoolParams{
Context: ctx,
}
}
// NewCreateEnterprisePoolParamsWithHTTPClient creates a new CreateEnterprisePoolParams object
// with the ability to set a custom HTTPClient for a request.
func NewCreateEnterprisePoolParamsWithHTTPClient(client *http.Client) *CreateEnterprisePoolParams {
return &CreateEnterprisePoolParams{
HTTPClient: client,
}
}
/*
CreateEnterprisePoolParams contains all the parameters to send to the API endpoint
for the create enterprise pool operation.
Typically these are written to a http.Request.
*/
type CreateEnterprisePoolParams struct {
/* Body.
Parameters used when creating the enterprise pool.
*/
Body garm_params.CreatePoolParams
/* EnterpriseID.
Enterprise ID.
*/
EnterpriseID string
timeout time.Duration
Context context.Context
HTTPClient *http.Client
}
// WithDefaults hydrates default values in the create enterprise pool params (not the query body).
//
// All values with no default are reset to their zero value.
func (o *CreateEnterprisePoolParams) WithDefaults() *CreateEnterprisePoolParams {
o.SetDefaults()
return o
}
// SetDefaults hydrates default values in the create enterprise pool params (not the query body).
//
// All values with no default are reset to their zero value.
func (o *CreateEnterprisePoolParams) SetDefaults() {
// no default values defined for this parameter
}
// WithTimeout adds the timeout to the create enterprise pool params
func (o *CreateEnterprisePoolParams) WithTimeout(timeout time.Duration) *CreateEnterprisePoolParams {
o.SetTimeout(timeout)
return o
}
// SetTimeout adds the timeout to the create enterprise pool params
func (o *CreateEnterprisePoolParams) SetTimeout(timeout time.Duration) {
o.timeout = timeout
}
// WithContext adds the context to the create enterprise pool params
func (o *CreateEnterprisePoolParams) WithContext(ctx context.Context) *CreateEnterprisePoolParams {
o.SetContext(ctx)
return o
}
// SetContext adds the context to the create enterprise pool params
func (o *CreateEnterprisePoolParams) SetContext(ctx context.Context) {
o.Context = ctx
}
// WithHTTPClient adds the HTTPClient to the create enterprise pool params
func (o *CreateEnterprisePoolParams) WithHTTPClient(client *http.Client) *CreateEnterprisePoolParams {
o.SetHTTPClient(client)
return o
}
// SetHTTPClient adds the HTTPClient to the create enterprise pool params
func (o *CreateEnterprisePoolParams) SetHTTPClient(client *http.Client) {
o.HTTPClient = client
}
// WithBody adds the body to the create enterprise pool params
func (o *CreateEnterprisePoolParams) WithBody(body garm_params.CreatePoolParams) *CreateEnterprisePoolParams {
o.SetBody(body)
return o
}
// SetBody adds the body to the create enterprise pool params
func (o *CreateEnterprisePoolParams) SetBody(body garm_params.CreatePoolParams) {
o.Body = body
}
// WithEnterpriseID adds the enterpriseID to the create enterprise pool params
func (o *CreateEnterprisePoolParams) WithEnterpriseID(enterpriseID string) *CreateEnterprisePoolParams {
o.SetEnterpriseID(enterpriseID)
return o
}
// SetEnterpriseID adds the enterpriseId to the create enterprise pool params
func (o *CreateEnterprisePoolParams) SetEnterpriseID(enterpriseID string) {
o.EnterpriseID = enterpriseID
}
// WriteToRequest writes these params to a swagger request
func (o *CreateEnterprisePoolParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error {
if err := r.SetTimeout(o.timeout); err != nil {
return err
}
var res []error
if err := r.SetBodyParam(o.Body); err != nil {
return err
}
// path param enterpriseID
if err := r.SetPathParam("enterpriseID", o.EnterpriseID); err != nil {
return err
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
}

View file

@ -0,0 +1,179 @@
// Code generated by go-swagger; DO NOT EDIT.
package enterprises
// This file was generated by the swagger tool.
// Editing this file might prove futile when you re-run the swagger generate command
import (
"fmt"
"io"
"github.com/go-openapi/runtime"
"github.com/go-openapi/strfmt"
apiserver_params "github.com/cloudbase/garm/apiserver/params"
garm_params "github.com/cloudbase/garm/params"
)
// CreateEnterprisePoolReader is a Reader for the CreateEnterprisePool structure.
type CreateEnterprisePoolReader struct {
formats strfmt.Registry
}
// ReadResponse reads a server response into the received o.
func (o *CreateEnterprisePoolReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) {
switch response.Code() {
case 200:
result := NewCreateEnterprisePoolOK()
if err := result.readResponse(response, consumer, o.formats); err != nil {
return nil, err
}
return result, nil
default:
result := NewCreateEnterprisePoolDefault(response.Code())
if err := result.readResponse(response, consumer, o.formats); err != nil {
return nil, err
}
if response.Code()/100 == 2 {
return result, nil
}
return nil, result
}
}
// NewCreateEnterprisePoolOK creates a CreateEnterprisePoolOK with default headers values
func NewCreateEnterprisePoolOK() *CreateEnterprisePoolOK {
return &CreateEnterprisePoolOK{}
}
/*
CreateEnterprisePoolOK describes a response with status code 200, with default header values.
Pool
*/
type CreateEnterprisePoolOK struct {
Payload garm_params.Pool
}
// IsSuccess returns true when this create enterprise pool o k response has a 2xx status code
func (o *CreateEnterprisePoolOK) IsSuccess() bool {
return true
}
// IsRedirect returns true when this create enterprise pool o k response has a 3xx status code
func (o *CreateEnterprisePoolOK) IsRedirect() bool {
return false
}
// IsClientError returns true when this create enterprise pool o k response has a 4xx status code
func (o *CreateEnterprisePoolOK) IsClientError() bool {
return false
}
// IsServerError returns true when this create enterprise pool o k response has a 5xx status code
func (o *CreateEnterprisePoolOK) IsServerError() bool {
return false
}
// IsCode returns true when this create enterprise pool o k response a status code equal to that given
func (o *CreateEnterprisePoolOK) IsCode(code int) bool {
return code == 200
}
// Code gets the status code for the create enterprise pool o k response
func (o *CreateEnterprisePoolOK) Code() int {
return 200
}
func (o *CreateEnterprisePoolOK) Error() string {
return fmt.Sprintf("[POST /enterprises/{enterpriseID}/pools][%d] createEnterprisePoolOK %+v", 200, o.Payload)
}
func (o *CreateEnterprisePoolOK) String() string {
return fmt.Sprintf("[POST /enterprises/{enterpriseID}/pools][%d] createEnterprisePoolOK %+v", 200, o.Payload)
}
func (o *CreateEnterprisePoolOK) GetPayload() garm_params.Pool {
return o.Payload
}
func (o *CreateEnterprisePoolOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error {
// response payload
if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF {
return err
}
return nil
}
// NewCreateEnterprisePoolDefault creates a CreateEnterprisePoolDefault with default headers values
func NewCreateEnterprisePoolDefault(code int) *CreateEnterprisePoolDefault {
return &CreateEnterprisePoolDefault{
_statusCode: code,
}
}
/*
CreateEnterprisePoolDefault describes a response with status code -1, with default header values.
APIErrorResponse
*/
type CreateEnterprisePoolDefault struct {
_statusCode int
Payload apiserver_params.APIErrorResponse
}
// IsSuccess returns true when this create enterprise pool default response has a 2xx status code
func (o *CreateEnterprisePoolDefault) IsSuccess() bool {
return o._statusCode/100 == 2
}
// IsRedirect returns true when this create enterprise pool default response has a 3xx status code
func (o *CreateEnterprisePoolDefault) IsRedirect() bool {
return o._statusCode/100 == 3
}
// IsClientError returns true when this create enterprise pool default response has a 4xx status code
func (o *CreateEnterprisePoolDefault) IsClientError() bool {
return o._statusCode/100 == 4
}
// IsServerError returns true when this create enterprise pool default response has a 5xx status code
func (o *CreateEnterprisePoolDefault) IsServerError() bool {
return o._statusCode/100 == 5
}
// IsCode returns true when this create enterprise pool default response a status code equal to that given
func (o *CreateEnterprisePoolDefault) IsCode(code int) bool {
return o._statusCode == code
}
// Code gets the status code for the create enterprise pool default response
func (o *CreateEnterprisePoolDefault) Code() int {
return o._statusCode
}
func (o *CreateEnterprisePoolDefault) Error() string {
return fmt.Sprintf("[POST /enterprises/{enterpriseID}/pools][%d] CreateEnterprisePool default %+v", o._statusCode, o.Payload)
}
func (o *CreateEnterprisePoolDefault) String() string {
return fmt.Sprintf("[POST /enterprises/{enterpriseID}/pools][%d] CreateEnterprisePool default %+v", o._statusCode, o.Payload)
}
func (o *CreateEnterprisePoolDefault) GetPayload() apiserver_params.APIErrorResponse {
return o.Payload
}
func (o *CreateEnterprisePoolDefault) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error {
// response payload
if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF {
return err
}
return nil
}

View file

@ -0,0 +1,179 @@
// Code generated by go-swagger; DO NOT EDIT.
package enterprises
// This file was generated by the swagger tool.
// Editing this file might prove futile when you re-run the swagger generate command
import (
"fmt"
"io"
"github.com/go-openapi/runtime"
"github.com/go-openapi/strfmt"
apiserver_params "github.com/cloudbase/garm/apiserver/params"
garm_params "github.com/cloudbase/garm/params"
)
// CreateEnterpriseReader is a Reader for the CreateEnterprise structure.
type CreateEnterpriseReader struct {
formats strfmt.Registry
}
// ReadResponse reads a server response into the received o.
func (o *CreateEnterpriseReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) {
switch response.Code() {
case 200:
result := NewCreateEnterpriseOK()
if err := result.readResponse(response, consumer, o.formats); err != nil {
return nil, err
}
return result, nil
default:
result := NewCreateEnterpriseDefault(response.Code())
if err := result.readResponse(response, consumer, o.formats); err != nil {
return nil, err
}
if response.Code()/100 == 2 {
return result, nil
}
return nil, result
}
}
// NewCreateEnterpriseOK creates a CreateEnterpriseOK with default headers values
func NewCreateEnterpriseOK() *CreateEnterpriseOK {
return &CreateEnterpriseOK{}
}
/*
CreateEnterpriseOK describes a response with status code 200, with default header values.
Enterprise
*/
type CreateEnterpriseOK struct {
Payload garm_params.Enterprise
}
// IsSuccess returns true when this create enterprise o k response has a 2xx status code
func (o *CreateEnterpriseOK) IsSuccess() bool {
return true
}
// IsRedirect returns true when this create enterprise o k response has a 3xx status code
func (o *CreateEnterpriseOK) IsRedirect() bool {
return false
}
// IsClientError returns true when this create enterprise o k response has a 4xx status code
func (o *CreateEnterpriseOK) IsClientError() bool {
return false
}
// IsServerError returns true when this create enterprise o k response has a 5xx status code
func (o *CreateEnterpriseOK) IsServerError() bool {
return false
}
// IsCode returns true when this create enterprise o k response a status code equal to that given
func (o *CreateEnterpriseOK) IsCode(code int) bool {
return code == 200
}
// Code gets the status code for the create enterprise o k response
func (o *CreateEnterpriseOK) Code() int {
return 200
}
func (o *CreateEnterpriseOK) Error() string {
return fmt.Sprintf("[POST /enterprises][%d] createEnterpriseOK %+v", 200, o.Payload)
}
func (o *CreateEnterpriseOK) String() string {
return fmt.Sprintf("[POST /enterprises][%d] createEnterpriseOK %+v", 200, o.Payload)
}
func (o *CreateEnterpriseOK) GetPayload() garm_params.Enterprise {
return o.Payload
}
func (o *CreateEnterpriseOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error {
// response payload
if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF {
return err
}
return nil
}
// NewCreateEnterpriseDefault creates a CreateEnterpriseDefault with default headers values
func NewCreateEnterpriseDefault(code int) *CreateEnterpriseDefault {
return &CreateEnterpriseDefault{
_statusCode: code,
}
}
/*
CreateEnterpriseDefault describes a response with status code -1, with default header values.
APIErrorResponse
*/
type CreateEnterpriseDefault struct {
_statusCode int
Payload apiserver_params.APIErrorResponse
}
// IsSuccess returns true when this create enterprise default response has a 2xx status code
func (o *CreateEnterpriseDefault) IsSuccess() bool {
return o._statusCode/100 == 2
}
// IsRedirect returns true when this create enterprise default response has a 3xx status code
func (o *CreateEnterpriseDefault) IsRedirect() bool {
return o._statusCode/100 == 3
}
// IsClientError returns true when this create enterprise default response has a 4xx status code
func (o *CreateEnterpriseDefault) IsClientError() bool {
return o._statusCode/100 == 4
}
// IsServerError returns true when this create enterprise default response has a 5xx status code
func (o *CreateEnterpriseDefault) IsServerError() bool {
return o._statusCode/100 == 5
}
// IsCode returns true when this create enterprise default response a status code equal to that given
func (o *CreateEnterpriseDefault) IsCode(code int) bool {
return o._statusCode == code
}
// Code gets the status code for the create enterprise default response
func (o *CreateEnterpriseDefault) Code() int {
return o._statusCode
}
func (o *CreateEnterpriseDefault) Error() string {
return fmt.Sprintf("[POST /enterprises][%d] CreateEnterprise default %+v", o._statusCode, o.Payload)
}
func (o *CreateEnterpriseDefault) String() string {
return fmt.Sprintf("[POST /enterprises][%d] CreateEnterprise default %+v", o._statusCode, o.Payload)
}
func (o *CreateEnterpriseDefault) GetPayload() apiserver_params.APIErrorResponse {
return o.Payload
}
func (o *CreateEnterpriseDefault) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error {
// response payload
if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF {
return err
}
return nil
}

View file

@ -0,0 +1,151 @@
// Code generated by go-swagger; DO NOT EDIT.
package enterprises
// This file was generated by the swagger tool.
// Editing this file might prove futile when you re-run the swagger generate command
import (
"context"
"net/http"
"time"
"github.com/go-openapi/errors"
"github.com/go-openapi/runtime"
cr "github.com/go-openapi/runtime/client"
"github.com/go-openapi/strfmt"
)
// NewDeleteEnterpriseParams creates a new DeleteEnterpriseParams object,
// with the default timeout for this client.
//
// Default values are not hydrated, since defaults are normally applied by the API server side.
//
// To enforce default values in parameter, use SetDefaults or WithDefaults.
func NewDeleteEnterpriseParams() *DeleteEnterpriseParams {
return &DeleteEnterpriseParams{
timeout: cr.DefaultTimeout,
}
}
// NewDeleteEnterpriseParamsWithTimeout creates a new DeleteEnterpriseParams object
// with the ability to set a timeout on a request.
func NewDeleteEnterpriseParamsWithTimeout(timeout time.Duration) *DeleteEnterpriseParams {
return &DeleteEnterpriseParams{
timeout: timeout,
}
}
// NewDeleteEnterpriseParamsWithContext creates a new DeleteEnterpriseParams object
// with the ability to set a context for a request.
func NewDeleteEnterpriseParamsWithContext(ctx context.Context) *DeleteEnterpriseParams {
return &DeleteEnterpriseParams{
Context: ctx,
}
}
// NewDeleteEnterpriseParamsWithHTTPClient creates a new DeleteEnterpriseParams object
// with the ability to set a custom HTTPClient for a request.
func NewDeleteEnterpriseParamsWithHTTPClient(client *http.Client) *DeleteEnterpriseParams {
return &DeleteEnterpriseParams{
HTTPClient: client,
}
}
/*
DeleteEnterpriseParams contains all the parameters to send to the API endpoint
for the delete enterprise operation.
Typically these are written to a http.Request.
*/
type DeleteEnterpriseParams struct {
/* EnterpriseID.
ID of the enterprise to delete.
*/
EnterpriseID string
timeout time.Duration
Context context.Context
HTTPClient *http.Client
}
// WithDefaults hydrates default values in the delete enterprise params (not the query body).
//
// All values with no default are reset to their zero value.
func (o *DeleteEnterpriseParams) WithDefaults() *DeleteEnterpriseParams {
o.SetDefaults()
return o
}
// SetDefaults hydrates default values in the delete enterprise params (not the query body).
//
// All values with no default are reset to their zero value.
func (o *DeleteEnterpriseParams) SetDefaults() {
// no default values defined for this parameter
}
// WithTimeout adds the timeout to the delete enterprise params
func (o *DeleteEnterpriseParams) WithTimeout(timeout time.Duration) *DeleteEnterpriseParams {
o.SetTimeout(timeout)
return o
}
// SetTimeout adds the timeout to the delete enterprise params
func (o *DeleteEnterpriseParams) SetTimeout(timeout time.Duration) {
o.timeout = timeout
}
// WithContext adds the context to the delete enterprise params
func (o *DeleteEnterpriseParams) WithContext(ctx context.Context) *DeleteEnterpriseParams {
o.SetContext(ctx)
return o
}
// SetContext adds the context to the delete enterprise params
func (o *DeleteEnterpriseParams) SetContext(ctx context.Context) {
o.Context = ctx
}
// WithHTTPClient adds the HTTPClient to the delete enterprise params
func (o *DeleteEnterpriseParams) WithHTTPClient(client *http.Client) *DeleteEnterpriseParams {
o.SetHTTPClient(client)
return o
}
// SetHTTPClient adds the HTTPClient to the delete enterprise params
func (o *DeleteEnterpriseParams) SetHTTPClient(client *http.Client) {
o.HTTPClient = client
}
// WithEnterpriseID adds the enterpriseID to the delete enterprise params
func (o *DeleteEnterpriseParams) WithEnterpriseID(enterpriseID string) *DeleteEnterpriseParams {
o.SetEnterpriseID(enterpriseID)
return o
}
// SetEnterpriseID adds the enterpriseId to the delete enterprise params
func (o *DeleteEnterpriseParams) SetEnterpriseID(enterpriseID string) {
o.EnterpriseID = enterpriseID
}
// WriteToRequest writes these params to a swagger request
func (o *DeleteEnterpriseParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error {
if err := r.SetTimeout(o.timeout); err != nil {
return err
}
var res []error
// path param enterpriseID
if err := r.SetPathParam("enterpriseID", o.EnterpriseID); err != nil {
return err
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
}

View file

@ -0,0 +1,173 @@
// Code generated by go-swagger; DO NOT EDIT.
package enterprises
// This file was generated by the swagger tool.
// Editing this file might prove futile when you re-run the swagger generate command
import (
"context"
"net/http"
"time"
"github.com/go-openapi/errors"
"github.com/go-openapi/runtime"
cr "github.com/go-openapi/runtime/client"
"github.com/go-openapi/strfmt"
)
// NewDeleteEnterprisePoolParams creates a new DeleteEnterprisePoolParams object,
// with the default timeout for this client.
//
// Default values are not hydrated, since defaults are normally applied by the API server side.
//
// To enforce default values in parameter, use SetDefaults or WithDefaults.
func NewDeleteEnterprisePoolParams() *DeleteEnterprisePoolParams {
return &DeleteEnterprisePoolParams{
timeout: cr.DefaultTimeout,
}
}
// NewDeleteEnterprisePoolParamsWithTimeout creates a new DeleteEnterprisePoolParams object
// with the ability to set a timeout on a request.
func NewDeleteEnterprisePoolParamsWithTimeout(timeout time.Duration) *DeleteEnterprisePoolParams {
return &DeleteEnterprisePoolParams{
timeout: timeout,
}
}
// NewDeleteEnterprisePoolParamsWithContext creates a new DeleteEnterprisePoolParams object
// with the ability to set a context for a request.
func NewDeleteEnterprisePoolParamsWithContext(ctx context.Context) *DeleteEnterprisePoolParams {
return &DeleteEnterprisePoolParams{
Context: ctx,
}
}
// NewDeleteEnterprisePoolParamsWithHTTPClient creates a new DeleteEnterprisePoolParams object
// with the ability to set a custom HTTPClient for a request.
func NewDeleteEnterprisePoolParamsWithHTTPClient(client *http.Client) *DeleteEnterprisePoolParams {
return &DeleteEnterprisePoolParams{
HTTPClient: client,
}
}
/*
DeleteEnterprisePoolParams contains all the parameters to send to the API endpoint
for the delete enterprise pool operation.
Typically these are written to a http.Request.
*/
type DeleteEnterprisePoolParams struct {
/* EnterpriseID.
Enterprise ID.
*/
EnterpriseID string
/* PoolID.
ID of the enterprise pool to delete.
*/
PoolID string
timeout time.Duration
Context context.Context
HTTPClient *http.Client
}
// WithDefaults hydrates default values in the delete enterprise pool params (not the query body).
//
// All values with no default are reset to their zero value.
func (o *DeleteEnterprisePoolParams) WithDefaults() *DeleteEnterprisePoolParams {
o.SetDefaults()
return o
}
// SetDefaults hydrates default values in the delete enterprise pool params (not the query body).
//
// All values with no default are reset to their zero value.
func (o *DeleteEnterprisePoolParams) SetDefaults() {
// no default values defined for this parameter
}
// WithTimeout adds the timeout to the delete enterprise pool params
func (o *DeleteEnterprisePoolParams) WithTimeout(timeout time.Duration) *DeleteEnterprisePoolParams {
o.SetTimeout(timeout)
return o
}
// SetTimeout adds the timeout to the delete enterprise pool params
func (o *DeleteEnterprisePoolParams) SetTimeout(timeout time.Duration) {
o.timeout = timeout
}
// WithContext adds the context to the delete enterprise pool params
func (o *DeleteEnterprisePoolParams) WithContext(ctx context.Context) *DeleteEnterprisePoolParams {
o.SetContext(ctx)
return o
}
// SetContext adds the context to the delete enterprise pool params
func (o *DeleteEnterprisePoolParams) SetContext(ctx context.Context) {
o.Context = ctx
}
// WithHTTPClient adds the HTTPClient to the delete enterprise pool params
func (o *DeleteEnterprisePoolParams) WithHTTPClient(client *http.Client) *DeleteEnterprisePoolParams {
o.SetHTTPClient(client)
return o
}
// SetHTTPClient adds the HTTPClient to the delete enterprise pool params
func (o *DeleteEnterprisePoolParams) SetHTTPClient(client *http.Client) {
o.HTTPClient = client
}
// WithEnterpriseID adds the enterpriseID to the delete enterprise pool params
func (o *DeleteEnterprisePoolParams) WithEnterpriseID(enterpriseID string) *DeleteEnterprisePoolParams {
o.SetEnterpriseID(enterpriseID)
return o
}
// SetEnterpriseID adds the enterpriseId to the delete enterprise pool params
func (o *DeleteEnterprisePoolParams) SetEnterpriseID(enterpriseID string) {
o.EnterpriseID = enterpriseID
}
// WithPoolID adds the poolID to the delete enterprise pool params
func (o *DeleteEnterprisePoolParams) WithPoolID(poolID string) *DeleteEnterprisePoolParams {
o.SetPoolID(poolID)
return o
}
// SetPoolID adds the poolId to the delete enterprise pool params
func (o *DeleteEnterprisePoolParams) SetPoolID(poolID string) {
o.PoolID = poolID
}
// WriteToRequest writes these params to a swagger request
func (o *DeleteEnterprisePoolParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error {
if err := r.SetTimeout(o.timeout); err != nil {
return err
}
var res []error
// path param enterpriseID
if err := r.SetPathParam("enterpriseID", o.EnterpriseID); err != nil {
return err
}
// path param poolID
if err := r.SetPathParam("poolID", o.PoolID); err != nil {
return err
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
}

View file

@ -0,0 +1,103 @@
// Code generated by go-swagger; DO NOT EDIT.
package enterprises
// This file was generated by the swagger tool.
// Editing this file might prove futile when you re-run the swagger generate command
import (
"fmt"
"io"
"github.com/go-openapi/runtime"
"github.com/go-openapi/strfmt"
apiserver_params "github.com/cloudbase/garm/apiserver/params"
)
// DeleteEnterprisePoolReader is a Reader for the DeleteEnterprisePool structure.
type DeleteEnterprisePoolReader struct {
formats strfmt.Registry
}
// ReadResponse reads a server response into the received o.
func (o *DeleteEnterprisePoolReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) {
result := NewDeleteEnterprisePoolDefault(response.Code())
if err := result.readResponse(response, consumer, o.formats); err != nil {
return nil, err
}
if response.Code()/100 == 2 {
return result, nil
}
return nil, result
}
// NewDeleteEnterprisePoolDefault creates a DeleteEnterprisePoolDefault with default headers values
func NewDeleteEnterprisePoolDefault(code int) *DeleteEnterprisePoolDefault {
return &DeleteEnterprisePoolDefault{
_statusCode: code,
}
}
/*
DeleteEnterprisePoolDefault describes a response with status code -1, with default header values.
APIErrorResponse
*/
type DeleteEnterprisePoolDefault struct {
_statusCode int
Payload apiserver_params.APIErrorResponse
}
// IsSuccess returns true when this delete enterprise pool default response has a 2xx status code
func (o *DeleteEnterprisePoolDefault) IsSuccess() bool {
return o._statusCode/100 == 2
}
// IsRedirect returns true when this delete enterprise pool default response has a 3xx status code
func (o *DeleteEnterprisePoolDefault) IsRedirect() bool {
return o._statusCode/100 == 3
}
// IsClientError returns true when this delete enterprise pool default response has a 4xx status code
func (o *DeleteEnterprisePoolDefault) IsClientError() bool {
return o._statusCode/100 == 4
}
// IsServerError returns true when this delete enterprise pool default response has a 5xx status code
func (o *DeleteEnterprisePoolDefault) IsServerError() bool {
return o._statusCode/100 == 5
}
// IsCode returns true when this delete enterprise pool default response a status code equal to that given
func (o *DeleteEnterprisePoolDefault) IsCode(code int) bool {
return o._statusCode == code
}
// Code gets the status code for the delete enterprise pool default response
func (o *DeleteEnterprisePoolDefault) Code() int {
return o._statusCode
}
func (o *DeleteEnterprisePoolDefault) Error() string {
return fmt.Sprintf("[DELETE /enterprises/{enterpriseID}/pools/{poolID}][%d] DeleteEnterprisePool default %+v", o._statusCode, o.Payload)
}
func (o *DeleteEnterprisePoolDefault) String() string {
return fmt.Sprintf("[DELETE /enterprises/{enterpriseID}/pools/{poolID}][%d] DeleteEnterprisePool default %+v", o._statusCode, o.Payload)
}
func (o *DeleteEnterprisePoolDefault) GetPayload() apiserver_params.APIErrorResponse {
return o.Payload
}
func (o *DeleteEnterprisePoolDefault) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error {
// response payload
if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF {
return err
}
return nil
}

View file

@ -0,0 +1,103 @@
// Code generated by go-swagger; DO NOT EDIT.
package enterprises
// This file was generated by the swagger tool.
// Editing this file might prove futile when you re-run the swagger generate command
import (
"fmt"
"io"
"github.com/go-openapi/runtime"
"github.com/go-openapi/strfmt"
apiserver_params "github.com/cloudbase/garm/apiserver/params"
)
// DeleteEnterpriseReader is a Reader for the DeleteEnterprise structure.
type DeleteEnterpriseReader struct {
formats strfmt.Registry
}
// ReadResponse reads a server response into the received o.
func (o *DeleteEnterpriseReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) {
result := NewDeleteEnterpriseDefault(response.Code())
if err := result.readResponse(response, consumer, o.formats); err != nil {
return nil, err
}
if response.Code()/100 == 2 {
return result, nil
}
return nil, result
}
// NewDeleteEnterpriseDefault creates a DeleteEnterpriseDefault with default headers values
func NewDeleteEnterpriseDefault(code int) *DeleteEnterpriseDefault {
return &DeleteEnterpriseDefault{
_statusCode: code,
}
}
/*
DeleteEnterpriseDefault describes a response with status code -1, with default header values.
APIErrorResponse
*/
type DeleteEnterpriseDefault struct {
_statusCode int
Payload apiserver_params.APIErrorResponse
}
// IsSuccess returns true when this delete enterprise default response has a 2xx status code
func (o *DeleteEnterpriseDefault) IsSuccess() bool {
return o._statusCode/100 == 2
}
// IsRedirect returns true when this delete enterprise default response has a 3xx status code
func (o *DeleteEnterpriseDefault) IsRedirect() bool {
return o._statusCode/100 == 3
}
// IsClientError returns true when this delete enterprise default response has a 4xx status code
func (o *DeleteEnterpriseDefault) IsClientError() bool {
return o._statusCode/100 == 4
}
// IsServerError returns true when this delete enterprise default response has a 5xx status code
func (o *DeleteEnterpriseDefault) IsServerError() bool {
return o._statusCode/100 == 5
}
// IsCode returns true when this delete enterprise default response a status code equal to that given
func (o *DeleteEnterpriseDefault) IsCode(code int) bool {
return o._statusCode == code
}
// Code gets the status code for the delete enterprise default response
func (o *DeleteEnterpriseDefault) Code() int {
return o._statusCode
}
func (o *DeleteEnterpriseDefault) Error() string {
return fmt.Sprintf("[DELETE /enterprises/{enterpriseID}][%d] DeleteEnterprise default %+v", o._statusCode, o.Payload)
}
func (o *DeleteEnterpriseDefault) String() string {
return fmt.Sprintf("[DELETE /enterprises/{enterpriseID}][%d] DeleteEnterprise default %+v", o._statusCode, o.Payload)
}
func (o *DeleteEnterpriseDefault) GetPayload() apiserver_params.APIErrorResponse {
return o.Payload
}
func (o *DeleteEnterpriseDefault) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error {
// response payload
if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF {
return err
}
return nil
}

View file

@ -0,0 +1,465 @@
// Code generated by go-swagger; DO NOT EDIT.
package enterprises
// This file was generated by the swagger tool.
// Editing this file might prove futile when you re-run the swagger generate command
import (
"github.com/go-openapi/runtime"
"github.com/go-openapi/strfmt"
)
// New creates a new enterprises API client.
func New(transport runtime.ClientTransport, formats strfmt.Registry) ClientService {
return &Client{transport: transport, formats: formats}
}
/*
Client for enterprises API
*/
type Client struct {
transport runtime.ClientTransport
formats strfmt.Registry
}
// ClientOption is the option for Client methods
type ClientOption func(*runtime.ClientOperation)
// ClientService is the interface for Client methods
type ClientService interface {
CreateEnterprise(params *CreateEnterpriseParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateEnterpriseOK, error)
CreateEnterprisePool(params *CreateEnterprisePoolParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateEnterprisePoolOK, error)
DeleteEnterprise(params *DeleteEnterpriseParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) error
DeleteEnterprisePool(params *DeleteEnterprisePoolParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) error
GetEnterprise(params *GetEnterpriseParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetEnterpriseOK, error)
GetEnterprisePool(params *GetEnterprisePoolParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetEnterprisePoolOK, error)
ListEnterpriseInstances(params *ListEnterpriseInstancesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListEnterpriseInstancesOK, error)
ListEnterprisePools(params *ListEnterprisePoolsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListEnterprisePoolsOK, error)
ListEnterprises(params *ListEnterprisesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListEnterprisesOK, error)
UpdateEnterprise(params *UpdateEnterpriseParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateEnterpriseOK, error)
UpdateEnterprisePool(params *UpdateEnterprisePoolParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateEnterprisePoolOK, error)
SetTransport(transport runtime.ClientTransport)
}
/*
CreateEnterprise creates enterprise with the given parameters
*/
func (a *Client) CreateEnterprise(params *CreateEnterpriseParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateEnterpriseOK, error) {
// TODO: Validate the params before sending
if params == nil {
params = NewCreateEnterpriseParams()
}
op := &runtime.ClientOperation{
ID: "CreateEnterprise",
Method: "POST",
PathPattern: "/enterprises",
ProducesMediaTypes: []string{"application/json"},
ConsumesMediaTypes: []string{"application/json"},
Schemes: []string{"http"},
Params: params,
Reader: &CreateEnterpriseReader{formats: a.formats},
AuthInfo: authInfo,
Context: params.Context,
Client: params.HTTPClient,
}
for _, opt := range opts {
opt(op)
}
result, err := a.transport.Submit(op)
if err != nil {
return nil, err
}
success, ok := result.(*CreateEnterpriseOK)
if ok {
return success, nil
}
// unexpected success response
unexpectedSuccess := result.(*CreateEnterpriseDefault)
return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}
/*
CreateEnterprisePool creates enterprise pool with the parameters given
*/
func (a *Client) CreateEnterprisePool(params *CreateEnterprisePoolParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateEnterprisePoolOK, error) {
// TODO: Validate the params before sending
if params == nil {
params = NewCreateEnterprisePoolParams()
}
op := &runtime.ClientOperation{
ID: "CreateEnterprisePool",
Method: "POST",
PathPattern: "/enterprises/{enterpriseID}/pools",
ProducesMediaTypes: []string{"application/json"},
ConsumesMediaTypes: []string{"application/json"},
Schemes: []string{"http"},
Params: params,
Reader: &CreateEnterprisePoolReader{formats: a.formats},
AuthInfo: authInfo,
Context: params.Context,
Client: params.HTTPClient,
}
for _, opt := range opts {
opt(op)
}
result, err := a.transport.Submit(op)
if err != nil {
return nil, err
}
success, ok := result.(*CreateEnterprisePoolOK)
if ok {
return success, nil
}
// unexpected success response
unexpectedSuccess := result.(*CreateEnterprisePoolDefault)
return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}
/*
DeleteEnterprise deletes enterprise by ID
*/
func (a *Client) DeleteEnterprise(params *DeleteEnterpriseParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) error {
// TODO: Validate the params before sending
if params == nil {
params = NewDeleteEnterpriseParams()
}
op := &runtime.ClientOperation{
ID: "DeleteEnterprise",
Method: "DELETE",
PathPattern: "/enterprises/{enterpriseID}",
ProducesMediaTypes: []string{"application/json"},
ConsumesMediaTypes: []string{"application/json"},
Schemes: []string{"http"},
Params: params,
Reader: &DeleteEnterpriseReader{formats: a.formats},
AuthInfo: authInfo,
Context: params.Context,
Client: params.HTTPClient,
}
for _, opt := range opts {
opt(op)
}
_, err := a.transport.Submit(op)
if err != nil {
return err
}
return nil
}
/*
DeleteEnterprisePool deletes enterprise pool by ID
*/
func (a *Client) DeleteEnterprisePool(params *DeleteEnterprisePoolParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) error {
// TODO: Validate the params before sending
if params == nil {
params = NewDeleteEnterprisePoolParams()
}
op := &runtime.ClientOperation{
ID: "DeleteEnterprisePool",
Method: "DELETE",
PathPattern: "/enterprises/{enterpriseID}/pools/{poolID}",
ProducesMediaTypes: []string{"application/json"},
ConsumesMediaTypes: []string{"application/json"},
Schemes: []string{"http"},
Params: params,
Reader: &DeleteEnterprisePoolReader{formats: a.formats},
AuthInfo: authInfo,
Context: params.Context,
Client: params.HTTPClient,
}
for _, opt := range opts {
opt(op)
}
_, err := a.transport.Submit(op)
if err != nil {
return err
}
return nil
}
/*
GetEnterprise gets enterprise by ID
*/
func (a *Client) GetEnterprise(params *GetEnterpriseParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetEnterpriseOK, error) {
// TODO: Validate the params before sending
if params == nil {
params = NewGetEnterpriseParams()
}
op := &runtime.ClientOperation{
ID: "GetEnterprise",
Method: "GET",
PathPattern: "/enterprises/{enterpriseID}",
ProducesMediaTypes: []string{"application/json"},
ConsumesMediaTypes: []string{"application/json"},
Schemes: []string{"http"},
Params: params,
Reader: &GetEnterpriseReader{formats: a.formats},
AuthInfo: authInfo,
Context: params.Context,
Client: params.HTTPClient,
}
for _, opt := range opts {
opt(op)
}
result, err := a.transport.Submit(op)
if err != nil {
return nil, err
}
success, ok := result.(*GetEnterpriseOK)
if ok {
return success, nil
}
// unexpected success response
unexpectedSuccess := result.(*GetEnterpriseDefault)
return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}
/*
GetEnterprisePool gets enterprise pool by ID
*/
func (a *Client) GetEnterprisePool(params *GetEnterprisePoolParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetEnterprisePoolOK, error) {
// TODO: Validate the params before sending
if params == nil {
params = NewGetEnterprisePoolParams()
}
op := &runtime.ClientOperation{
ID: "GetEnterprisePool",
Method: "GET",
PathPattern: "/enterprises/{enterpriseID}/pools/{poolID}",
ProducesMediaTypes: []string{"application/json"},
ConsumesMediaTypes: []string{"application/json"},
Schemes: []string{"http"},
Params: params,
Reader: &GetEnterprisePoolReader{formats: a.formats},
AuthInfo: authInfo,
Context: params.Context,
Client: params.HTTPClient,
}
for _, opt := range opts {
opt(op)
}
result, err := a.transport.Submit(op)
if err != nil {
return nil, err
}
success, ok := result.(*GetEnterprisePoolOK)
if ok {
return success, nil
}
// unexpected success response
unexpectedSuccess := result.(*GetEnterprisePoolDefault)
return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}
/*
ListEnterpriseInstances lists enterprise instances
*/
func (a *Client) ListEnterpriseInstances(params *ListEnterpriseInstancesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListEnterpriseInstancesOK, error) {
// TODO: Validate the params before sending
if params == nil {
params = NewListEnterpriseInstancesParams()
}
op := &runtime.ClientOperation{
ID: "ListEnterpriseInstances",
Method: "GET",
PathPattern: "/enterprises/{enterpriseID}/instances",
ProducesMediaTypes: []string{"application/json"},
ConsumesMediaTypes: []string{"application/json"},
Schemes: []string{"http"},
Params: params,
Reader: &ListEnterpriseInstancesReader{formats: a.formats},
AuthInfo: authInfo,
Context: params.Context,
Client: params.HTTPClient,
}
for _, opt := range opts {
opt(op)
}
result, err := a.transport.Submit(op)
if err != nil {
return nil, err
}
success, ok := result.(*ListEnterpriseInstancesOK)
if ok {
return success, nil
}
// unexpected success response
unexpectedSuccess := result.(*ListEnterpriseInstancesDefault)
return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}
/*
ListEnterprisePools lists enterprise pools
*/
func (a *Client) ListEnterprisePools(params *ListEnterprisePoolsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListEnterprisePoolsOK, error) {
// TODO: Validate the params before sending
if params == nil {
params = NewListEnterprisePoolsParams()
}
op := &runtime.ClientOperation{
ID: "ListEnterprisePools",
Method: "GET",
PathPattern: "/enterprises/{enterpriseID}/pools",
ProducesMediaTypes: []string{"application/json"},
ConsumesMediaTypes: []string{"application/json"},
Schemes: []string{"http"},
Params: params,
Reader: &ListEnterprisePoolsReader{formats: a.formats},
AuthInfo: authInfo,
Context: params.Context,
Client: params.HTTPClient,
}
for _, opt := range opts {
opt(op)
}
result, err := a.transport.Submit(op)
if err != nil {
return nil, err
}
success, ok := result.(*ListEnterprisePoolsOK)
if ok {
return success, nil
}
// unexpected success response
unexpectedSuccess := result.(*ListEnterprisePoolsDefault)
return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}
/*
ListEnterprises lists all enterprises
*/
func (a *Client) ListEnterprises(params *ListEnterprisesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ListEnterprisesOK, error) {
// TODO: Validate the params before sending
if params == nil {
params = NewListEnterprisesParams()
}
op := &runtime.ClientOperation{
ID: "ListEnterprises",
Method: "GET",
PathPattern: "/enterprises",
ProducesMediaTypes: []string{"application/json"},
ConsumesMediaTypes: []string{"application/json"},
Schemes: []string{"http"},
Params: params,
Reader: &ListEnterprisesReader{formats: a.formats},
AuthInfo: authInfo,
Context: params.Context,
Client: params.HTTPClient,
}
for _, opt := range opts {
opt(op)
}
result, err := a.transport.Submit(op)
if err != nil {
return nil, err
}
success, ok := result.(*ListEnterprisesOK)
if ok {
return success, nil
}
// unexpected success response
unexpectedSuccess := result.(*ListEnterprisesDefault)
return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}
/*
UpdateEnterprise updates an enterprise with the given parameters
*/
func (a *Client) UpdateEnterprise(params *UpdateEnterpriseParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateEnterpriseOK, error) {
// TODO: Validate the params before sending
if params == nil {
params = NewUpdateEnterpriseParams()
}
op := &runtime.ClientOperation{
ID: "UpdateEnterprise",
Method: "PUT",
PathPattern: "/enterprises/{enterpriseID}",
ProducesMediaTypes: []string{"application/json"},
ConsumesMediaTypes: []string{"application/json"},
Schemes: []string{"http"},
Params: params,
Reader: &UpdateEnterpriseReader{formats: a.formats},
AuthInfo: authInfo,
Context: params.Context,
Client: params.HTTPClient,
}
for _, opt := range opts {
opt(op)
}
result, err := a.transport.Submit(op)
if err != nil {
return nil, err
}
success, ok := result.(*UpdateEnterpriseOK)
if ok {
return success, nil
}
// unexpected success response
unexpectedSuccess := result.(*UpdateEnterpriseDefault)
return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}
/*
UpdateEnterprisePool updates enterprise pool with the parameters given
*/
func (a *Client) UpdateEnterprisePool(params *UpdateEnterprisePoolParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateEnterprisePoolOK, error) {
// TODO: Validate the params before sending
if params == nil {
params = NewUpdateEnterprisePoolParams()
}
op := &runtime.ClientOperation{
ID: "UpdateEnterprisePool",
Method: "PUT",
PathPattern: "/enterprises/{enterpriseID}/pools/{poolID}",
ProducesMediaTypes: []string{"application/json"},
ConsumesMediaTypes: []string{"application/json"},
Schemes: []string{"http"},
Params: params,
Reader: &UpdateEnterprisePoolReader{formats: a.formats},
AuthInfo: authInfo,
Context: params.Context,
Client: params.HTTPClient,
}
for _, opt := range opts {
opt(op)
}
result, err := a.transport.Submit(op)
if err != nil {
return nil, err
}
success, ok := result.(*UpdateEnterprisePoolOK)
if ok {
return success, nil
}
// unexpected success response
unexpectedSuccess := result.(*UpdateEnterprisePoolDefault)
return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}
// SetTransport changes the transport on the client
func (a *Client) SetTransport(transport runtime.ClientTransport) {
a.transport = transport
}

View file

@ -0,0 +1,151 @@
// Code generated by go-swagger; DO NOT EDIT.
package enterprises
// This file was generated by the swagger tool.
// Editing this file might prove futile when you re-run the swagger generate command
import (
"context"
"net/http"
"time"
"github.com/go-openapi/errors"
"github.com/go-openapi/runtime"
cr "github.com/go-openapi/runtime/client"
"github.com/go-openapi/strfmt"
)
// NewGetEnterpriseParams creates a new GetEnterpriseParams object,
// with the default timeout for this client.
//
// Default values are not hydrated, since defaults are normally applied by the API server side.
//
// To enforce default values in parameter, use SetDefaults or WithDefaults.
func NewGetEnterpriseParams() *GetEnterpriseParams {
return &GetEnterpriseParams{
timeout: cr.DefaultTimeout,
}
}
// NewGetEnterpriseParamsWithTimeout creates a new GetEnterpriseParams object
// with the ability to set a timeout on a request.
func NewGetEnterpriseParamsWithTimeout(timeout time.Duration) *GetEnterpriseParams {
return &GetEnterpriseParams{
timeout: timeout,
}
}
// NewGetEnterpriseParamsWithContext creates a new GetEnterpriseParams object
// with the ability to set a context for a request.
func NewGetEnterpriseParamsWithContext(ctx context.Context) *GetEnterpriseParams {
return &GetEnterpriseParams{
Context: ctx,
}
}
// NewGetEnterpriseParamsWithHTTPClient creates a new GetEnterpriseParams object
// with the ability to set a custom HTTPClient for a request.
func NewGetEnterpriseParamsWithHTTPClient(client *http.Client) *GetEnterpriseParams {
return &GetEnterpriseParams{
HTTPClient: client,
}
}
/*
GetEnterpriseParams contains all the parameters to send to the API endpoint
for the get enterprise operation.
Typically these are written to a http.Request.
*/
type GetEnterpriseParams struct {
/* EnterpriseID.
The ID of the enterprise to fetch.
*/
EnterpriseID string
timeout time.Duration
Context context.Context
HTTPClient *http.Client
}
// WithDefaults hydrates default values in the get enterprise params (not the query body).
//
// All values with no default are reset to their zero value.
func (o *GetEnterpriseParams) WithDefaults() *GetEnterpriseParams {
o.SetDefaults()
return o
}
// SetDefaults hydrates default values in the get enterprise params (not the query body).
//
// All values with no default are reset to their zero value.
func (o *GetEnterpriseParams) SetDefaults() {
// no default values defined for this parameter
}
// WithTimeout adds the timeout to the get enterprise params
func (o *GetEnterpriseParams) WithTimeout(timeout time.Duration) *GetEnterpriseParams {
o.SetTimeout(timeout)
return o
}
// SetTimeout adds the timeout to the get enterprise params
func (o *GetEnterpriseParams) SetTimeout(timeout time.Duration) {
o.timeout = timeout
}
// WithContext adds the context to the get enterprise params
func (o *GetEnterpriseParams) WithContext(ctx context.Context) *GetEnterpriseParams {
o.SetContext(ctx)
return o
}
// SetContext adds the context to the get enterprise params
func (o *GetEnterpriseParams) SetContext(ctx context.Context) {
o.Context = ctx
}
// WithHTTPClient adds the HTTPClient to the get enterprise params
func (o *GetEnterpriseParams) WithHTTPClient(client *http.Client) *GetEnterpriseParams {
o.SetHTTPClient(client)
return o
}
// SetHTTPClient adds the HTTPClient to the get enterprise params
func (o *GetEnterpriseParams) SetHTTPClient(client *http.Client) {
o.HTTPClient = client
}
// WithEnterpriseID adds the enterpriseID to the get enterprise params
func (o *GetEnterpriseParams) WithEnterpriseID(enterpriseID string) *GetEnterpriseParams {
o.SetEnterpriseID(enterpriseID)
return o
}
// SetEnterpriseID adds the enterpriseId to the get enterprise params
func (o *GetEnterpriseParams) SetEnterpriseID(enterpriseID string) {
o.EnterpriseID = enterpriseID
}
// WriteToRequest writes these params to a swagger request
func (o *GetEnterpriseParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error {
if err := r.SetTimeout(o.timeout); err != nil {
return err
}
var res []error
// path param enterpriseID
if err := r.SetPathParam("enterpriseID", o.EnterpriseID); err != nil {
return err
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
}

View file

@ -0,0 +1,173 @@
// Code generated by go-swagger; DO NOT EDIT.
package enterprises
// This file was generated by the swagger tool.
// Editing this file might prove futile when you re-run the swagger generate command
import (
"context"
"net/http"
"time"
"github.com/go-openapi/errors"
"github.com/go-openapi/runtime"
cr "github.com/go-openapi/runtime/client"
"github.com/go-openapi/strfmt"
)
// NewGetEnterprisePoolParams creates a new GetEnterprisePoolParams object,
// with the default timeout for this client.
//
// Default values are not hydrated, since defaults are normally applied by the API server side.
//
// To enforce default values in parameter, use SetDefaults or WithDefaults.
func NewGetEnterprisePoolParams() *GetEnterprisePoolParams {
return &GetEnterprisePoolParams{
timeout: cr.DefaultTimeout,
}
}
// NewGetEnterprisePoolParamsWithTimeout creates a new GetEnterprisePoolParams object
// with the ability to set a timeout on a request.
func NewGetEnterprisePoolParamsWithTimeout(timeout time.Duration) *GetEnterprisePoolParams {
return &GetEnterprisePoolParams{
timeout: timeout,
}
}
// NewGetEnterprisePoolParamsWithContext creates a new GetEnterprisePoolParams object
// with the ability to set a context for a request.
func NewGetEnterprisePoolParamsWithContext(ctx context.Context) *GetEnterprisePoolParams {
return &GetEnterprisePoolParams{
Context: ctx,
}
}
// NewGetEnterprisePoolParamsWithHTTPClient creates a new GetEnterprisePoolParams object
// with the ability to set a custom HTTPClient for a request.
func NewGetEnterprisePoolParamsWithHTTPClient(client *http.Client) *GetEnterprisePoolParams {
return &GetEnterprisePoolParams{
HTTPClient: client,
}
}
/*
GetEnterprisePoolParams contains all the parameters to send to the API endpoint
for the get enterprise pool operation.
Typically these are written to a http.Request.
*/
type GetEnterprisePoolParams struct {
/* EnterpriseID.
Enterprise ID.
*/
EnterpriseID string
/* PoolID.
Pool ID.
*/
PoolID string
timeout time.Duration
Context context.Context
HTTPClient *http.Client
}
// WithDefaults hydrates default values in the get enterprise pool params (not the query body).
//
// All values with no default are reset to their zero value.
func (o *GetEnterprisePoolParams) WithDefaults() *GetEnterprisePoolParams {
o.SetDefaults()
return o
}
// SetDefaults hydrates default values in the get enterprise pool params (not the query body).
//
// All values with no default are reset to their zero value.
func (o *GetEnterprisePoolParams) SetDefaults() {
// no default values defined for this parameter
}
// WithTimeout adds the timeout to the get enterprise pool params
func (o *GetEnterprisePoolParams) WithTimeout(timeout time.Duration) *GetEnterprisePoolParams {
o.SetTimeout(timeout)
return o
}
// SetTimeout adds the timeout to the get enterprise pool params
func (o *GetEnterprisePoolParams) SetTimeout(timeout time.Duration) {
o.timeout = timeout
}
// WithContext adds the context to the get enterprise pool params
func (o *GetEnterprisePoolParams) WithContext(ctx context.Context) *GetEnterprisePoolParams {
o.SetContext(ctx)
return o
}
// SetContext adds the context to the get enterprise pool params
func (o *GetEnterprisePoolParams) SetContext(ctx context.Context) {
o.Context = ctx
}
// WithHTTPClient adds the HTTPClient to the get enterprise pool params
func (o *GetEnterprisePoolParams) WithHTTPClient(client *http.Client) *GetEnterprisePoolParams {
o.SetHTTPClient(client)
return o
}
// SetHTTPClient adds the HTTPClient to the get enterprise pool params
func (o *GetEnterprisePoolParams) SetHTTPClient(client *http.Client) {
o.HTTPClient = client
}
// WithEnterpriseID adds the enterpriseID to the get enterprise pool params
func (o *GetEnterprisePoolParams) WithEnterpriseID(enterpriseID string) *GetEnterprisePoolParams {
o.SetEnterpriseID(enterpriseID)
return o
}
// SetEnterpriseID adds the enterpriseId to the get enterprise pool params
func (o *GetEnterprisePoolParams) SetEnterpriseID(enterpriseID string) {
o.EnterpriseID = enterpriseID
}
// WithPoolID adds the poolID to the get enterprise pool params
func (o *GetEnterprisePoolParams) WithPoolID(poolID string) *GetEnterprisePoolParams {
o.SetPoolID(poolID)
return o
}
// SetPoolID adds the poolId to the get enterprise pool params
func (o *GetEnterprisePoolParams) SetPoolID(poolID string) {
o.PoolID = poolID
}
// WriteToRequest writes these params to a swagger request
func (o *GetEnterprisePoolParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error {
if err := r.SetTimeout(o.timeout); err != nil {
return err
}
var res []error
// path param enterpriseID
if err := r.SetPathParam("enterpriseID", o.EnterpriseID); err != nil {
return err
}
// path param poolID
if err := r.SetPathParam("poolID", o.PoolID); err != nil {
return err
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
}

View file

@ -0,0 +1,179 @@
// Code generated by go-swagger; DO NOT EDIT.
package enterprises
// This file was generated by the swagger tool.
// Editing this file might prove futile when you re-run the swagger generate command
import (
"fmt"
"io"
"github.com/go-openapi/runtime"
"github.com/go-openapi/strfmt"
apiserver_params "github.com/cloudbase/garm/apiserver/params"
garm_params "github.com/cloudbase/garm/params"
)
// GetEnterprisePoolReader is a Reader for the GetEnterprisePool structure.
type GetEnterprisePoolReader struct {
formats strfmt.Registry
}
// ReadResponse reads a server response into the received o.
func (o *GetEnterprisePoolReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) {
switch response.Code() {
case 200:
result := NewGetEnterprisePoolOK()
if err := result.readResponse(response, consumer, o.formats); err != nil {
return nil, err
}
return result, nil
default:
result := NewGetEnterprisePoolDefault(response.Code())
if err := result.readResponse(response, consumer, o.formats); err != nil {
return nil, err
}
if response.Code()/100 == 2 {
return result, nil
}
return nil, result
}
}
// NewGetEnterprisePoolOK creates a GetEnterprisePoolOK with default headers values
func NewGetEnterprisePoolOK() *GetEnterprisePoolOK {
return &GetEnterprisePoolOK{}
}
/*
GetEnterprisePoolOK describes a response with status code 200, with default header values.
Pool
*/
type GetEnterprisePoolOK struct {
Payload garm_params.Pool
}
// IsSuccess returns true when this get enterprise pool o k response has a 2xx status code
func (o *GetEnterprisePoolOK) IsSuccess() bool {
return true
}
// IsRedirect returns true when this get enterprise pool o k response has a 3xx status code
func (o *GetEnterprisePoolOK) IsRedirect() bool {
return false
}
// IsClientError returns true when this get enterprise pool o k response has a 4xx status code
func (o *GetEnterprisePoolOK) IsClientError() bool {
return false
}
// IsServerError returns true when this get enterprise pool o k response has a 5xx status code
func (o *GetEnterprisePoolOK) IsServerError() bool {
return false
}
// IsCode returns true when this get enterprise pool o k response a status code equal to that given
func (o *GetEnterprisePoolOK) IsCode(code int) bool {
return code == 200
}
// Code gets the status code for the get enterprise pool o k response
func (o *GetEnterprisePoolOK) Code() int {
return 200
}
func (o *GetEnterprisePoolOK) Error() string {
return fmt.Sprintf("[GET /enterprises/{enterpriseID}/pools/{poolID}][%d] getEnterprisePoolOK %+v", 200, o.Payload)
}
func (o *GetEnterprisePoolOK) String() string {
return fmt.Sprintf("[GET /enterprises/{enterpriseID}/pools/{poolID}][%d] getEnterprisePoolOK %+v", 200, o.Payload)
}
func (o *GetEnterprisePoolOK) GetPayload() garm_params.Pool {
return o.Payload
}
func (o *GetEnterprisePoolOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error {
// response payload
if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF {
return err
}
return nil
}
// NewGetEnterprisePoolDefault creates a GetEnterprisePoolDefault with default headers values
func NewGetEnterprisePoolDefault(code int) *GetEnterprisePoolDefault {
return &GetEnterprisePoolDefault{
_statusCode: code,
}
}
/*
GetEnterprisePoolDefault describes a response with status code -1, with default header values.
APIErrorResponse
*/
type GetEnterprisePoolDefault struct {
_statusCode int
Payload apiserver_params.APIErrorResponse
}
// IsSuccess returns true when this get enterprise pool default response has a 2xx status code
func (o *GetEnterprisePoolDefault) IsSuccess() bool {
return o._statusCode/100 == 2
}
// IsRedirect returns true when this get enterprise pool default response has a 3xx status code
func (o *GetEnterprisePoolDefault) IsRedirect() bool {
return o._statusCode/100 == 3
}
// IsClientError returns true when this get enterprise pool default response has a 4xx status code
func (o *GetEnterprisePoolDefault) IsClientError() bool {
return o._statusCode/100 == 4
}
// IsServerError returns true when this get enterprise pool default response has a 5xx status code
func (o *GetEnterprisePoolDefault) IsServerError() bool {
return o._statusCode/100 == 5
}
// IsCode returns true when this get enterprise pool default response a status code equal to that given
func (o *GetEnterprisePoolDefault) IsCode(code int) bool {
return o._statusCode == code
}
// Code gets the status code for the get enterprise pool default response
func (o *GetEnterprisePoolDefault) Code() int {
return o._statusCode
}
func (o *GetEnterprisePoolDefault) Error() string {
return fmt.Sprintf("[GET /enterprises/{enterpriseID}/pools/{poolID}][%d] GetEnterprisePool default %+v", o._statusCode, o.Payload)
}
func (o *GetEnterprisePoolDefault) String() string {
return fmt.Sprintf("[GET /enterprises/{enterpriseID}/pools/{poolID}][%d] GetEnterprisePool default %+v", o._statusCode, o.Payload)
}
func (o *GetEnterprisePoolDefault) GetPayload() apiserver_params.APIErrorResponse {
return o.Payload
}
func (o *GetEnterprisePoolDefault) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error {
// response payload
if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF {
return err
}
return nil
}

View file

@ -0,0 +1,179 @@
// Code generated by go-swagger; DO NOT EDIT.
package enterprises
// This file was generated by the swagger tool.
// Editing this file might prove futile when you re-run the swagger generate command
import (
"fmt"
"io"
"github.com/go-openapi/runtime"
"github.com/go-openapi/strfmt"
apiserver_params "github.com/cloudbase/garm/apiserver/params"
garm_params "github.com/cloudbase/garm/params"
)
// GetEnterpriseReader is a Reader for the GetEnterprise structure.
type GetEnterpriseReader struct {
formats strfmt.Registry
}
// ReadResponse reads a server response into the received o.
func (o *GetEnterpriseReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) {
switch response.Code() {
case 200:
result := NewGetEnterpriseOK()
if err := result.readResponse(response, consumer, o.formats); err != nil {
return nil, err
}
return result, nil
default:
result := NewGetEnterpriseDefault(response.Code())
if err := result.readResponse(response, consumer, o.formats); err != nil {
return nil, err
}
if response.Code()/100 == 2 {
return result, nil
}
return nil, result
}
}
// NewGetEnterpriseOK creates a GetEnterpriseOK with default headers values
func NewGetEnterpriseOK() *GetEnterpriseOK {
return &GetEnterpriseOK{}
}
/*
GetEnterpriseOK describes a response with status code 200, with default header values.
Enterprise
*/
type GetEnterpriseOK struct {
Payload garm_params.Enterprise
}
// IsSuccess returns true when this get enterprise o k response has a 2xx status code
func (o *GetEnterpriseOK) IsSuccess() bool {
return true
}
// IsRedirect returns true when this get enterprise o k response has a 3xx status code
func (o *GetEnterpriseOK) IsRedirect() bool {
return false
}
// IsClientError returns true when this get enterprise o k response has a 4xx status code
func (o *GetEnterpriseOK) IsClientError() bool {
return false
}
// IsServerError returns true when this get enterprise o k response has a 5xx status code
func (o *GetEnterpriseOK) IsServerError() bool {
return false
}
// IsCode returns true when this get enterprise o k response a status code equal to that given
func (o *GetEnterpriseOK) IsCode(code int) bool {
return code == 200
}
// Code gets the status code for the get enterprise o k response
func (o *GetEnterpriseOK) Code() int {
return 200
}
func (o *GetEnterpriseOK) Error() string {
return fmt.Sprintf("[GET /enterprises/{enterpriseID}][%d] getEnterpriseOK %+v", 200, o.Payload)
}
func (o *GetEnterpriseOK) String() string {
return fmt.Sprintf("[GET /enterprises/{enterpriseID}][%d] getEnterpriseOK %+v", 200, o.Payload)
}
func (o *GetEnterpriseOK) GetPayload() garm_params.Enterprise {
return o.Payload
}
func (o *GetEnterpriseOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error {
// response payload
if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF {
return err
}
return nil
}
// NewGetEnterpriseDefault creates a GetEnterpriseDefault with default headers values
func NewGetEnterpriseDefault(code int) *GetEnterpriseDefault {
return &GetEnterpriseDefault{
_statusCode: code,
}
}
/*
GetEnterpriseDefault describes a response with status code -1, with default header values.
APIErrorResponse
*/
type GetEnterpriseDefault struct {
_statusCode int
Payload apiserver_params.APIErrorResponse
}
// IsSuccess returns true when this get enterprise default response has a 2xx status code
func (o *GetEnterpriseDefault) IsSuccess() bool {
return o._statusCode/100 == 2
}
// IsRedirect returns true when this get enterprise default response has a 3xx status code
func (o *GetEnterpriseDefault) IsRedirect() bool {
return o._statusCode/100 == 3
}
// IsClientError returns true when this get enterprise default response has a 4xx status code
func (o *GetEnterpriseDefault) IsClientError() bool {
return o._statusCode/100 == 4
}
// IsServerError returns true when this get enterprise default response has a 5xx status code
func (o *GetEnterpriseDefault) IsServerError() bool {
return o._statusCode/100 == 5
}
// IsCode returns true when this get enterprise default response a status code equal to that given
func (o *GetEnterpriseDefault) IsCode(code int) bool {
return o._statusCode == code
}
// Code gets the status code for the get enterprise default response
func (o *GetEnterpriseDefault) Code() int {
return o._statusCode
}
func (o *GetEnterpriseDefault) Error() string {
return fmt.Sprintf("[GET /enterprises/{enterpriseID}][%d] GetEnterprise default %+v", o._statusCode, o.Payload)
}
func (o *GetEnterpriseDefault) String() string {
return fmt.Sprintf("[GET /enterprises/{enterpriseID}][%d] GetEnterprise default %+v", o._statusCode, o.Payload)
}
func (o *GetEnterpriseDefault) GetPayload() apiserver_params.APIErrorResponse {
return o.Payload
}
func (o *GetEnterpriseDefault) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error {
// response payload
if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF {
return err
}
return nil
}

View file

@ -0,0 +1,151 @@
// Code generated by go-swagger; DO NOT EDIT.
package enterprises
// This file was generated by the swagger tool.
// Editing this file might prove futile when you re-run the swagger generate command
import (
"context"
"net/http"
"time"
"github.com/go-openapi/errors"
"github.com/go-openapi/runtime"
cr "github.com/go-openapi/runtime/client"
"github.com/go-openapi/strfmt"
)
// NewListEnterpriseInstancesParams creates a new ListEnterpriseInstancesParams object,
// with the default timeout for this client.
//
// Default values are not hydrated, since defaults are normally applied by the API server side.
//
// To enforce default values in parameter, use SetDefaults or WithDefaults.
func NewListEnterpriseInstancesParams() *ListEnterpriseInstancesParams {
return &ListEnterpriseInstancesParams{
timeout: cr.DefaultTimeout,
}
}
// NewListEnterpriseInstancesParamsWithTimeout creates a new ListEnterpriseInstancesParams object
// with the ability to set a timeout on a request.
func NewListEnterpriseInstancesParamsWithTimeout(timeout time.Duration) *ListEnterpriseInstancesParams {
return &ListEnterpriseInstancesParams{
timeout: timeout,
}
}
// NewListEnterpriseInstancesParamsWithContext creates a new ListEnterpriseInstancesParams object
// with the ability to set a context for a request.
func NewListEnterpriseInstancesParamsWithContext(ctx context.Context) *ListEnterpriseInstancesParams {
return &ListEnterpriseInstancesParams{
Context: ctx,
}
}
// NewListEnterpriseInstancesParamsWithHTTPClient creates a new ListEnterpriseInstancesParams object
// with the ability to set a custom HTTPClient for a request.
func NewListEnterpriseInstancesParamsWithHTTPClient(client *http.Client) *ListEnterpriseInstancesParams {
return &ListEnterpriseInstancesParams{
HTTPClient: client,
}
}
/*
ListEnterpriseInstancesParams contains all the parameters to send to the API endpoint
for the list enterprise instances operation.
Typically these are written to a http.Request.
*/
type ListEnterpriseInstancesParams struct {
/* EnterpriseID.
Enterprise ID.
*/
EnterpriseID string
timeout time.Duration
Context context.Context
HTTPClient *http.Client
}
// WithDefaults hydrates default values in the list enterprise instances params (not the query body).
//
// All values with no default are reset to their zero value.
func (o *ListEnterpriseInstancesParams) WithDefaults() *ListEnterpriseInstancesParams {
o.SetDefaults()
return o
}
// SetDefaults hydrates default values in the list enterprise instances params (not the query body).
//
// All values with no default are reset to their zero value.
func (o *ListEnterpriseInstancesParams) SetDefaults() {
// no default values defined for this parameter
}
// WithTimeout adds the timeout to the list enterprise instances params
func (o *ListEnterpriseInstancesParams) WithTimeout(timeout time.Duration) *ListEnterpriseInstancesParams {
o.SetTimeout(timeout)
return o
}
// SetTimeout adds the timeout to the list enterprise instances params
func (o *ListEnterpriseInstancesParams) SetTimeout(timeout time.Duration) {
o.timeout = timeout
}
// WithContext adds the context to the list enterprise instances params
func (o *ListEnterpriseInstancesParams) WithContext(ctx context.Context) *ListEnterpriseInstancesParams {
o.SetContext(ctx)
return o
}
// SetContext adds the context to the list enterprise instances params
func (o *ListEnterpriseInstancesParams) SetContext(ctx context.Context) {
o.Context = ctx
}
// WithHTTPClient adds the HTTPClient to the list enterprise instances params
func (o *ListEnterpriseInstancesParams) WithHTTPClient(client *http.Client) *ListEnterpriseInstancesParams {
o.SetHTTPClient(client)
return o
}
// SetHTTPClient adds the HTTPClient to the list enterprise instances params
func (o *ListEnterpriseInstancesParams) SetHTTPClient(client *http.Client) {
o.HTTPClient = client
}
// WithEnterpriseID adds the enterpriseID to the list enterprise instances params
func (o *ListEnterpriseInstancesParams) WithEnterpriseID(enterpriseID string) *ListEnterpriseInstancesParams {
o.SetEnterpriseID(enterpriseID)
return o
}
// SetEnterpriseID adds the enterpriseId to the list enterprise instances params
func (o *ListEnterpriseInstancesParams) SetEnterpriseID(enterpriseID string) {
o.EnterpriseID = enterpriseID
}
// WriteToRequest writes these params to a swagger request
func (o *ListEnterpriseInstancesParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error {
if err := r.SetTimeout(o.timeout); err != nil {
return err
}
var res []error
// path param enterpriseID
if err := r.SetPathParam("enterpriseID", o.EnterpriseID); err != nil {
return err
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
}

View file

@ -0,0 +1,179 @@
// Code generated by go-swagger; DO NOT EDIT.
package enterprises
// This file was generated by the swagger tool.
// Editing this file might prove futile when you re-run the swagger generate command
import (
"fmt"
"io"
"github.com/go-openapi/runtime"
"github.com/go-openapi/strfmt"
apiserver_params "github.com/cloudbase/garm/apiserver/params"
garm_params "github.com/cloudbase/garm/params"
)
// ListEnterpriseInstancesReader is a Reader for the ListEnterpriseInstances structure.
type ListEnterpriseInstancesReader struct {
formats strfmt.Registry
}
// ReadResponse reads a server response into the received o.
func (o *ListEnterpriseInstancesReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) {
switch response.Code() {
case 200:
result := NewListEnterpriseInstancesOK()
if err := result.readResponse(response, consumer, o.formats); err != nil {
return nil, err
}
return result, nil
default:
result := NewListEnterpriseInstancesDefault(response.Code())
if err := result.readResponse(response, consumer, o.formats); err != nil {
return nil, err
}
if response.Code()/100 == 2 {
return result, nil
}
return nil, result
}
}
// NewListEnterpriseInstancesOK creates a ListEnterpriseInstancesOK with default headers values
func NewListEnterpriseInstancesOK() *ListEnterpriseInstancesOK {
return &ListEnterpriseInstancesOK{}
}
/*
ListEnterpriseInstancesOK describes a response with status code 200, with default header values.
Instances
*/
type ListEnterpriseInstancesOK struct {
Payload garm_params.Instances
}
// IsSuccess returns true when this list enterprise instances o k response has a 2xx status code
func (o *ListEnterpriseInstancesOK) IsSuccess() bool {
return true
}
// IsRedirect returns true when this list enterprise instances o k response has a 3xx status code
func (o *ListEnterpriseInstancesOK) IsRedirect() bool {
return false
}
// IsClientError returns true when this list enterprise instances o k response has a 4xx status code
func (o *ListEnterpriseInstancesOK) IsClientError() bool {
return false
}
// IsServerError returns true when this list enterprise instances o k response has a 5xx status code
func (o *ListEnterpriseInstancesOK) IsServerError() bool {
return false
}
// IsCode returns true when this list enterprise instances o k response a status code equal to that given
func (o *ListEnterpriseInstancesOK) IsCode(code int) bool {
return code == 200
}
// Code gets the status code for the list enterprise instances o k response
func (o *ListEnterpriseInstancesOK) Code() int {
return 200
}
func (o *ListEnterpriseInstancesOK) Error() string {
return fmt.Sprintf("[GET /enterprises/{enterpriseID}/instances][%d] listEnterpriseInstancesOK %+v", 200, o.Payload)
}
func (o *ListEnterpriseInstancesOK) String() string {
return fmt.Sprintf("[GET /enterprises/{enterpriseID}/instances][%d] listEnterpriseInstancesOK %+v", 200, o.Payload)
}
func (o *ListEnterpriseInstancesOK) GetPayload() garm_params.Instances {
return o.Payload
}
func (o *ListEnterpriseInstancesOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error {
// response payload
if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF {
return err
}
return nil
}
// NewListEnterpriseInstancesDefault creates a ListEnterpriseInstancesDefault with default headers values
func NewListEnterpriseInstancesDefault(code int) *ListEnterpriseInstancesDefault {
return &ListEnterpriseInstancesDefault{
_statusCode: code,
}
}
/*
ListEnterpriseInstancesDefault describes a response with status code -1, with default header values.
APIErrorResponse
*/
type ListEnterpriseInstancesDefault struct {
_statusCode int
Payload apiserver_params.APIErrorResponse
}
// IsSuccess returns true when this list enterprise instances default response has a 2xx status code
func (o *ListEnterpriseInstancesDefault) IsSuccess() bool {
return o._statusCode/100 == 2
}
// IsRedirect returns true when this list enterprise instances default response has a 3xx status code
func (o *ListEnterpriseInstancesDefault) IsRedirect() bool {
return o._statusCode/100 == 3
}
// IsClientError returns true when this list enterprise instances default response has a 4xx status code
func (o *ListEnterpriseInstancesDefault) IsClientError() bool {
return o._statusCode/100 == 4
}
// IsServerError returns true when this list enterprise instances default response has a 5xx status code
func (o *ListEnterpriseInstancesDefault) IsServerError() bool {
return o._statusCode/100 == 5
}
// IsCode returns true when this list enterprise instances default response a status code equal to that given
func (o *ListEnterpriseInstancesDefault) IsCode(code int) bool {
return o._statusCode == code
}
// Code gets the status code for the list enterprise instances default response
func (o *ListEnterpriseInstancesDefault) Code() int {
return o._statusCode
}
func (o *ListEnterpriseInstancesDefault) Error() string {
return fmt.Sprintf("[GET /enterprises/{enterpriseID}/instances][%d] ListEnterpriseInstances default %+v", o._statusCode, o.Payload)
}
func (o *ListEnterpriseInstancesDefault) String() string {
return fmt.Sprintf("[GET /enterprises/{enterpriseID}/instances][%d] ListEnterpriseInstances default %+v", o._statusCode, o.Payload)
}
func (o *ListEnterpriseInstancesDefault) GetPayload() apiserver_params.APIErrorResponse {
return o.Payload
}
func (o *ListEnterpriseInstancesDefault) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error {
// response payload
if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF {
return err
}
return nil
}

View file

@ -0,0 +1,151 @@
// Code generated by go-swagger; DO NOT EDIT.
package enterprises
// This file was generated by the swagger tool.
// Editing this file might prove futile when you re-run the swagger generate command
import (
"context"
"net/http"
"time"
"github.com/go-openapi/errors"
"github.com/go-openapi/runtime"
cr "github.com/go-openapi/runtime/client"
"github.com/go-openapi/strfmt"
)
// NewListEnterprisePoolsParams creates a new ListEnterprisePoolsParams object,
// with the default timeout for this client.
//
// Default values are not hydrated, since defaults are normally applied by the API server side.
//
// To enforce default values in parameter, use SetDefaults or WithDefaults.
func NewListEnterprisePoolsParams() *ListEnterprisePoolsParams {
return &ListEnterprisePoolsParams{
timeout: cr.DefaultTimeout,
}
}
// NewListEnterprisePoolsParamsWithTimeout creates a new ListEnterprisePoolsParams object
// with the ability to set a timeout on a request.
func NewListEnterprisePoolsParamsWithTimeout(timeout time.Duration) *ListEnterprisePoolsParams {
return &ListEnterprisePoolsParams{
timeout: timeout,
}
}
// NewListEnterprisePoolsParamsWithContext creates a new ListEnterprisePoolsParams object
// with the ability to set a context for a request.
func NewListEnterprisePoolsParamsWithContext(ctx context.Context) *ListEnterprisePoolsParams {
return &ListEnterprisePoolsParams{
Context: ctx,
}
}
// NewListEnterprisePoolsParamsWithHTTPClient creates a new ListEnterprisePoolsParams object
// with the ability to set a custom HTTPClient for a request.
func NewListEnterprisePoolsParamsWithHTTPClient(client *http.Client) *ListEnterprisePoolsParams {
return &ListEnterprisePoolsParams{
HTTPClient: client,
}
}
/*
ListEnterprisePoolsParams contains all the parameters to send to the API endpoint
for the list enterprise pools operation.
Typically these are written to a http.Request.
*/
type ListEnterprisePoolsParams struct {
/* EnterpriseID.
Enterprise ID.
*/
EnterpriseID string
timeout time.Duration
Context context.Context
HTTPClient *http.Client
}
// WithDefaults hydrates default values in the list enterprise pools params (not the query body).
//
// All values with no default are reset to their zero value.
func (o *ListEnterprisePoolsParams) WithDefaults() *ListEnterprisePoolsParams {
o.SetDefaults()
return o
}
// SetDefaults hydrates default values in the list enterprise pools params (not the query body).
//
// All values with no default are reset to their zero value.
func (o *ListEnterprisePoolsParams) SetDefaults() {
// no default values defined for this parameter
}
// WithTimeout adds the timeout to the list enterprise pools params
func (o *ListEnterprisePoolsParams) WithTimeout(timeout time.Duration) *ListEnterprisePoolsParams {
o.SetTimeout(timeout)
return o
}
// SetTimeout adds the timeout to the list enterprise pools params
func (o *ListEnterprisePoolsParams) SetTimeout(timeout time.Duration) {
o.timeout = timeout
}
// WithContext adds the context to the list enterprise pools params
func (o *ListEnterprisePoolsParams) WithContext(ctx context.Context) *ListEnterprisePoolsParams {
o.SetContext(ctx)
return o
}
// SetContext adds the context to the list enterprise pools params
func (o *ListEnterprisePoolsParams) SetContext(ctx context.Context) {
o.Context = ctx
}
// WithHTTPClient adds the HTTPClient to the list enterprise pools params
func (o *ListEnterprisePoolsParams) WithHTTPClient(client *http.Client) *ListEnterprisePoolsParams {
o.SetHTTPClient(client)
return o
}
// SetHTTPClient adds the HTTPClient to the list enterprise pools params
func (o *ListEnterprisePoolsParams) SetHTTPClient(client *http.Client) {
o.HTTPClient = client
}
// WithEnterpriseID adds the enterpriseID to the list enterprise pools params
func (o *ListEnterprisePoolsParams) WithEnterpriseID(enterpriseID string) *ListEnterprisePoolsParams {
o.SetEnterpriseID(enterpriseID)
return o
}
// SetEnterpriseID adds the enterpriseId to the list enterprise pools params
func (o *ListEnterprisePoolsParams) SetEnterpriseID(enterpriseID string) {
o.EnterpriseID = enterpriseID
}
// WriteToRequest writes these params to a swagger request
func (o *ListEnterprisePoolsParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error {
if err := r.SetTimeout(o.timeout); err != nil {
return err
}
var res []error
// path param enterpriseID
if err := r.SetPathParam("enterpriseID", o.EnterpriseID); err != nil {
return err
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
}

View file

@ -0,0 +1,179 @@
// Code generated by go-swagger; DO NOT EDIT.
package enterprises
// This file was generated by the swagger tool.
// Editing this file might prove futile when you re-run the swagger generate command
import (
"fmt"
"io"
"github.com/go-openapi/runtime"
"github.com/go-openapi/strfmt"
apiserver_params "github.com/cloudbase/garm/apiserver/params"
garm_params "github.com/cloudbase/garm/params"
)
// ListEnterprisePoolsReader is a Reader for the ListEnterprisePools structure.
type ListEnterprisePoolsReader struct {
formats strfmt.Registry
}
// ReadResponse reads a server response into the received o.
func (o *ListEnterprisePoolsReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) {
switch response.Code() {
case 200:
result := NewListEnterprisePoolsOK()
if err := result.readResponse(response, consumer, o.formats); err != nil {
return nil, err
}
return result, nil
default:
result := NewListEnterprisePoolsDefault(response.Code())
if err := result.readResponse(response, consumer, o.formats); err != nil {
return nil, err
}
if response.Code()/100 == 2 {
return result, nil
}
return nil, result
}
}
// NewListEnterprisePoolsOK creates a ListEnterprisePoolsOK with default headers values
func NewListEnterprisePoolsOK() *ListEnterprisePoolsOK {
return &ListEnterprisePoolsOK{}
}
/*
ListEnterprisePoolsOK describes a response with status code 200, with default header values.
Pools
*/
type ListEnterprisePoolsOK struct {
Payload garm_params.Pools
}
// IsSuccess returns true when this list enterprise pools o k response has a 2xx status code
func (o *ListEnterprisePoolsOK) IsSuccess() bool {
return true
}
// IsRedirect returns true when this list enterprise pools o k response has a 3xx status code
func (o *ListEnterprisePoolsOK) IsRedirect() bool {
return false
}
// IsClientError returns true when this list enterprise pools o k response has a 4xx status code
func (o *ListEnterprisePoolsOK) IsClientError() bool {
return false
}
// IsServerError returns true when this list enterprise pools o k response has a 5xx status code
func (o *ListEnterprisePoolsOK) IsServerError() bool {
return false
}
// IsCode returns true when this list enterprise pools o k response a status code equal to that given
func (o *ListEnterprisePoolsOK) IsCode(code int) bool {
return code == 200
}
// Code gets the status code for the list enterprise pools o k response
func (o *ListEnterprisePoolsOK) Code() int {
return 200
}
func (o *ListEnterprisePoolsOK) Error() string {
return fmt.Sprintf("[GET /enterprises/{enterpriseID}/pools][%d] listEnterprisePoolsOK %+v", 200, o.Payload)
}
func (o *ListEnterprisePoolsOK) String() string {
return fmt.Sprintf("[GET /enterprises/{enterpriseID}/pools][%d] listEnterprisePoolsOK %+v", 200, o.Payload)
}
func (o *ListEnterprisePoolsOK) GetPayload() garm_params.Pools {
return o.Payload
}
func (o *ListEnterprisePoolsOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error {
// response payload
if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF {
return err
}
return nil
}
// NewListEnterprisePoolsDefault creates a ListEnterprisePoolsDefault with default headers values
func NewListEnterprisePoolsDefault(code int) *ListEnterprisePoolsDefault {
return &ListEnterprisePoolsDefault{
_statusCode: code,
}
}
/*
ListEnterprisePoolsDefault describes a response with status code -1, with default header values.
APIErrorResponse
*/
type ListEnterprisePoolsDefault struct {
_statusCode int
Payload apiserver_params.APIErrorResponse
}
// IsSuccess returns true when this list enterprise pools default response has a 2xx status code
func (o *ListEnterprisePoolsDefault) IsSuccess() bool {
return o._statusCode/100 == 2
}
// IsRedirect returns true when this list enterprise pools default response has a 3xx status code
func (o *ListEnterprisePoolsDefault) IsRedirect() bool {
return o._statusCode/100 == 3
}
// IsClientError returns true when this list enterprise pools default response has a 4xx status code
func (o *ListEnterprisePoolsDefault) IsClientError() bool {
return o._statusCode/100 == 4
}
// IsServerError returns true when this list enterprise pools default response has a 5xx status code
func (o *ListEnterprisePoolsDefault) IsServerError() bool {
return o._statusCode/100 == 5
}
// IsCode returns true when this list enterprise pools default response a status code equal to that given
func (o *ListEnterprisePoolsDefault) IsCode(code int) bool {
return o._statusCode == code
}
// Code gets the status code for the list enterprise pools default response
func (o *ListEnterprisePoolsDefault) Code() int {
return o._statusCode
}
func (o *ListEnterprisePoolsDefault) Error() string {
return fmt.Sprintf("[GET /enterprises/{enterpriseID}/pools][%d] ListEnterprisePools default %+v", o._statusCode, o.Payload)
}
func (o *ListEnterprisePoolsDefault) String() string {
return fmt.Sprintf("[GET /enterprises/{enterpriseID}/pools][%d] ListEnterprisePools default %+v", o._statusCode, o.Payload)
}
func (o *ListEnterprisePoolsDefault) GetPayload() apiserver_params.APIErrorResponse {
return o.Payload
}
func (o *ListEnterprisePoolsDefault) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error {
// response payload
if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF {
return err
}
return nil
}

View file

@ -0,0 +1,128 @@
// Code generated by go-swagger; DO NOT EDIT.
package enterprises
// This file was generated by the swagger tool.
// Editing this file might prove futile when you re-run the swagger generate command
import (
"context"
"net/http"
"time"
"github.com/go-openapi/errors"
"github.com/go-openapi/runtime"
cr "github.com/go-openapi/runtime/client"
"github.com/go-openapi/strfmt"
)
// NewListEnterprisesParams creates a new ListEnterprisesParams object,
// with the default timeout for this client.
//
// Default values are not hydrated, since defaults are normally applied by the API server side.
//
// To enforce default values in parameter, use SetDefaults or WithDefaults.
func NewListEnterprisesParams() *ListEnterprisesParams {
return &ListEnterprisesParams{
timeout: cr.DefaultTimeout,
}
}
// NewListEnterprisesParamsWithTimeout creates a new ListEnterprisesParams object
// with the ability to set a timeout on a request.
func NewListEnterprisesParamsWithTimeout(timeout time.Duration) *ListEnterprisesParams {
return &ListEnterprisesParams{
timeout: timeout,
}
}
// NewListEnterprisesParamsWithContext creates a new ListEnterprisesParams object
// with the ability to set a context for a request.
func NewListEnterprisesParamsWithContext(ctx context.Context) *ListEnterprisesParams {
return &ListEnterprisesParams{
Context: ctx,
}
}
// NewListEnterprisesParamsWithHTTPClient creates a new ListEnterprisesParams object
// with the ability to set a custom HTTPClient for a request.
func NewListEnterprisesParamsWithHTTPClient(client *http.Client) *ListEnterprisesParams {
return &ListEnterprisesParams{
HTTPClient: client,
}
}
/*
ListEnterprisesParams contains all the parameters to send to the API endpoint
for the list enterprises operation.
Typically these are written to a http.Request.
*/
type ListEnterprisesParams struct {
timeout time.Duration
Context context.Context
HTTPClient *http.Client
}
// WithDefaults hydrates default values in the list enterprises params (not the query body).
//
// All values with no default are reset to their zero value.
func (o *ListEnterprisesParams) WithDefaults() *ListEnterprisesParams {
o.SetDefaults()
return o
}
// SetDefaults hydrates default values in the list enterprises params (not the query body).
//
// All values with no default are reset to their zero value.
func (o *ListEnterprisesParams) SetDefaults() {
// no default values defined for this parameter
}
// WithTimeout adds the timeout to the list enterprises params
func (o *ListEnterprisesParams) WithTimeout(timeout time.Duration) *ListEnterprisesParams {
o.SetTimeout(timeout)
return o
}
// SetTimeout adds the timeout to the list enterprises params
func (o *ListEnterprisesParams) SetTimeout(timeout time.Duration) {
o.timeout = timeout
}
// WithContext adds the context to the list enterprises params
func (o *ListEnterprisesParams) WithContext(ctx context.Context) *ListEnterprisesParams {
o.SetContext(ctx)
return o
}
// SetContext adds the context to the list enterprises params
func (o *ListEnterprisesParams) SetContext(ctx context.Context) {
o.Context = ctx
}
// WithHTTPClient adds the HTTPClient to the list enterprises params
func (o *ListEnterprisesParams) WithHTTPClient(client *http.Client) *ListEnterprisesParams {
o.SetHTTPClient(client)
return o
}
// SetHTTPClient adds the HTTPClient to the list enterprises params
func (o *ListEnterprisesParams) SetHTTPClient(client *http.Client) {
o.HTTPClient = client
}
// WriteToRequest writes these params to a swagger request
func (o *ListEnterprisesParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error {
if err := r.SetTimeout(o.timeout); err != nil {
return err
}
var res []error
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
}

View file

@ -0,0 +1,179 @@
// Code generated by go-swagger; DO NOT EDIT.
package enterprises
// This file was generated by the swagger tool.
// Editing this file might prove futile when you re-run the swagger generate command
import (
"fmt"
"io"
"github.com/go-openapi/runtime"
"github.com/go-openapi/strfmt"
apiserver_params "github.com/cloudbase/garm/apiserver/params"
garm_params "github.com/cloudbase/garm/params"
)
// ListEnterprisesReader is a Reader for the ListEnterprises structure.
type ListEnterprisesReader struct {
formats strfmt.Registry
}
// ReadResponse reads a server response into the received o.
func (o *ListEnterprisesReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) {
switch response.Code() {
case 200:
result := NewListEnterprisesOK()
if err := result.readResponse(response, consumer, o.formats); err != nil {
return nil, err
}
return result, nil
default:
result := NewListEnterprisesDefault(response.Code())
if err := result.readResponse(response, consumer, o.formats); err != nil {
return nil, err
}
if response.Code()/100 == 2 {
return result, nil
}
return nil, result
}
}
// NewListEnterprisesOK creates a ListEnterprisesOK with default headers values
func NewListEnterprisesOK() *ListEnterprisesOK {
return &ListEnterprisesOK{}
}
/*
ListEnterprisesOK describes a response with status code 200, with default header values.
Enterprises
*/
type ListEnterprisesOK struct {
Payload garm_params.Enterprises
}
// IsSuccess returns true when this list enterprises o k response has a 2xx status code
func (o *ListEnterprisesOK) IsSuccess() bool {
return true
}
// IsRedirect returns true when this list enterprises o k response has a 3xx status code
func (o *ListEnterprisesOK) IsRedirect() bool {
return false
}
// IsClientError returns true when this list enterprises o k response has a 4xx status code
func (o *ListEnterprisesOK) IsClientError() bool {
return false
}
// IsServerError returns true when this list enterprises o k response has a 5xx status code
func (o *ListEnterprisesOK) IsServerError() bool {
return false
}
// IsCode returns true when this list enterprises o k response a status code equal to that given
func (o *ListEnterprisesOK) IsCode(code int) bool {
return code == 200
}
// Code gets the status code for the list enterprises o k response
func (o *ListEnterprisesOK) Code() int {
return 200
}
func (o *ListEnterprisesOK) Error() string {
return fmt.Sprintf("[GET /enterprises][%d] listEnterprisesOK %+v", 200, o.Payload)
}
func (o *ListEnterprisesOK) String() string {
return fmt.Sprintf("[GET /enterprises][%d] listEnterprisesOK %+v", 200, o.Payload)
}
func (o *ListEnterprisesOK) GetPayload() garm_params.Enterprises {
return o.Payload
}
func (o *ListEnterprisesOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error {
// response payload
if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF {
return err
}
return nil
}
// NewListEnterprisesDefault creates a ListEnterprisesDefault with default headers values
func NewListEnterprisesDefault(code int) *ListEnterprisesDefault {
return &ListEnterprisesDefault{
_statusCode: code,
}
}
/*
ListEnterprisesDefault describes a response with status code -1, with default header values.
APIErrorResponse
*/
type ListEnterprisesDefault struct {
_statusCode int
Payload apiserver_params.APIErrorResponse
}
// IsSuccess returns true when this list enterprises default response has a 2xx status code
func (o *ListEnterprisesDefault) IsSuccess() bool {
return o._statusCode/100 == 2
}
// IsRedirect returns true when this list enterprises default response has a 3xx status code
func (o *ListEnterprisesDefault) IsRedirect() bool {
return o._statusCode/100 == 3
}
// IsClientError returns true when this list enterprises default response has a 4xx status code
func (o *ListEnterprisesDefault) IsClientError() bool {
return o._statusCode/100 == 4
}
// IsServerError returns true when this list enterprises default response has a 5xx status code
func (o *ListEnterprisesDefault) IsServerError() bool {
return o._statusCode/100 == 5
}
// IsCode returns true when this list enterprises default response a status code equal to that given
func (o *ListEnterprisesDefault) IsCode(code int) bool {
return o._statusCode == code
}
// Code gets the status code for the list enterprises default response
func (o *ListEnterprisesDefault) Code() int {
return o._statusCode
}
func (o *ListEnterprisesDefault) Error() string {
return fmt.Sprintf("[GET /enterprises][%d] ListEnterprises default %+v", o._statusCode, o.Payload)
}
func (o *ListEnterprisesDefault) String() string {
return fmt.Sprintf("[GET /enterprises][%d] ListEnterprises default %+v", o._statusCode, o.Payload)
}
func (o *ListEnterprisesDefault) GetPayload() apiserver_params.APIErrorResponse {
return o.Payload
}
func (o *ListEnterprisesDefault) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error {
// response payload
if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF {
return err
}
return nil
}

View file

@ -0,0 +1,173 @@
// Code generated by go-swagger; DO NOT EDIT.
package enterprises
// This file was generated by the swagger tool.
// Editing this file might prove futile when you re-run the swagger generate command
import (
"context"
"net/http"
"time"
"github.com/go-openapi/errors"
"github.com/go-openapi/runtime"
cr "github.com/go-openapi/runtime/client"
"github.com/go-openapi/strfmt"
garm_params "github.com/cloudbase/garm/params"
)
// NewUpdateEnterpriseParams creates a new UpdateEnterpriseParams object,
// with the default timeout for this client.
//
// Default values are not hydrated, since defaults are normally applied by the API server side.
//
// To enforce default values in parameter, use SetDefaults or WithDefaults.
func NewUpdateEnterpriseParams() *UpdateEnterpriseParams {
return &UpdateEnterpriseParams{
timeout: cr.DefaultTimeout,
}
}
// NewUpdateEnterpriseParamsWithTimeout creates a new UpdateEnterpriseParams object
// with the ability to set a timeout on a request.
func NewUpdateEnterpriseParamsWithTimeout(timeout time.Duration) *UpdateEnterpriseParams {
return &UpdateEnterpriseParams{
timeout: timeout,
}
}
// NewUpdateEnterpriseParamsWithContext creates a new UpdateEnterpriseParams object
// with the ability to set a context for a request.
func NewUpdateEnterpriseParamsWithContext(ctx context.Context) *UpdateEnterpriseParams {
return &UpdateEnterpriseParams{
Context: ctx,
}
}
// NewUpdateEnterpriseParamsWithHTTPClient creates a new UpdateEnterpriseParams object
// with the ability to set a custom HTTPClient for a request.
func NewUpdateEnterpriseParamsWithHTTPClient(client *http.Client) *UpdateEnterpriseParams {
return &UpdateEnterpriseParams{
HTTPClient: client,
}
}
/*
UpdateEnterpriseParams contains all the parameters to send to the API endpoint
for the update enterprise operation.
Typically these are written to a http.Request.
*/
type UpdateEnterpriseParams struct {
/* Body.
Parameters used to update the enterprise.
*/
Body garm_params.UpdateEntityParams
/* EnterpriseID.
The ID of the enterprise to update.
*/
EnterpriseID string
timeout time.Duration
Context context.Context
HTTPClient *http.Client
}
// WithDefaults hydrates default values in the update enterprise params (not the query body).
//
// All values with no default are reset to their zero value.
func (o *UpdateEnterpriseParams) WithDefaults() *UpdateEnterpriseParams {
o.SetDefaults()
return o
}
// SetDefaults hydrates default values in the update enterprise params (not the query body).
//
// All values with no default are reset to their zero value.
func (o *UpdateEnterpriseParams) SetDefaults() {
// no default values defined for this parameter
}
// WithTimeout adds the timeout to the update enterprise params
func (o *UpdateEnterpriseParams) WithTimeout(timeout time.Duration) *UpdateEnterpriseParams {
o.SetTimeout(timeout)
return o
}
// SetTimeout adds the timeout to the update enterprise params
func (o *UpdateEnterpriseParams) SetTimeout(timeout time.Duration) {
o.timeout = timeout
}
// WithContext adds the context to the update enterprise params
func (o *UpdateEnterpriseParams) WithContext(ctx context.Context) *UpdateEnterpriseParams {
o.SetContext(ctx)
return o
}
// SetContext adds the context to the update enterprise params
func (o *UpdateEnterpriseParams) SetContext(ctx context.Context) {
o.Context = ctx
}
// WithHTTPClient adds the HTTPClient to the update enterprise params
func (o *UpdateEnterpriseParams) WithHTTPClient(client *http.Client) *UpdateEnterpriseParams {
o.SetHTTPClient(client)
return o
}
// SetHTTPClient adds the HTTPClient to the update enterprise params
func (o *UpdateEnterpriseParams) SetHTTPClient(client *http.Client) {
o.HTTPClient = client
}
// WithBody adds the body to the update enterprise params
func (o *UpdateEnterpriseParams) WithBody(body garm_params.UpdateEntityParams) *UpdateEnterpriseParams {
o.SetBody(body)
return o
}
// SetBody adds the body to the update enterprise params
func (o *UpdateEnterpriseParams) SetBody(body garm_params.UpdateEntityParams) {
o.Body = body
}
// WithEnterpriseID adds the enterpriseID to the update enterprise params
func (o *UpdateEnterpriseParams) WithEnterpriseID(enterpriseID string) *UpdateEnterpriseParams {
o.SetEnterpriseID(enterpriseID)
return o
}
// SetEnterpriseID adds the enterpriseId to the update enterprise params
func (o *UpdateEnterpriseParams) SetEnterpriseID(enterpriseID string) {
o.EnterpriseID = enterpriseID
}
// WriteToRequest writes these params to a swagger request
func (o *UpdateEnterpriseParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error {
if err := r.SetTimeout(o.timeout); err != nil {
return err
}
var res []error
if err := r.SetBodyParam(o.Body); err != nil {
return err
}
// path param enterpriseID
if err := r.SetPathParam("enterpriseID", o.EnterpriseID); err != nil {
return err
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
}

View file

@ -0,0 +1,195 @@
// Code generated by go-swagger; DO NOT EDIT.
package enterprises
// This file was generated by the swagger tool.
// Editing this file might prove futile when you re-run the swagger generate command
import (
"context"
"net/http"
"time"
"github.com/go-openapi/errors"
"github.com/go-openapi/runtime"
cr "github.com/go-openapi/runtime/client"
"github.com/go-openapi/strfmt"
garm_params "github.com/cloudbase/garm/params"
)
// NewUpdateEnterprisePoolParams creates a new UpdateEnterprisePoolParams object,
// with the default timeout for this client.
//
// Default values are not hydrated, since defaults are normally applied by the API server side.
//
// To enforce default values in parameter, use SetDefaults or WithDefaults.
func NewUpdateEnterprisePoolParams() *UpdateEnterprisePoolParams {
return &UpdateEnterprisePoolParams{
timeout: cr.DefaultTimeout,
}
}
// NewUpdateEnterprisePoolParamsWithTimeout creates a new UpdateEnterprisePoolParams object
// with the ability to set a timeout on a request.
func NewUpdateEnterprisePoolParamsWithTimeout(timeout time.Duration) *UpdateEnterprisePoolParams {
return &UpdateEnterprisePoolParams{
timeout: timeout,
}
}
// NewUpdateEnterprisePoolParamsWithContext creates a new UpdateEnterprisePoolParams object
// with the ability to set a context for a request.
func NewUpdateEnterprisePoolParamsWithContext(ctx context.Context) *UpdateEnterprisePoolParams {
return &UpdateEnterprisePoolParams{
Context: ctx,
}
}
// NewUpdateEnterprisePoolParamsWithHTTPClient creates a new UpdateEnterprisePoolParams object
// with the ability to set a custom HTTPClient for a request.
func NewUpdateEnterprisePoolParamsWithHTTPClient(client *http.Client) *UpdateEnterprisePoolParams {
return &UpdateEnterprisePoolParams{
HTTPClient: client,
}
}
/*
UpdateEnterprisePoolParams contains all the parameters to send to the API endpoint
for the update enterprise pool operation.
Typically these are written to a http.Request.
*/
type UpdateEnterprisePoolParams struct {
/* Body.
Parameters used when updating the enterprise pool.
*/
Body garm_params.UpdatePoolParams
/* EnterpriseID.
Enterprise ID.
*/
EnterpriseID string
/* PoolID.
ID of the enterprise pool to update.
*/
PoolID string
timeout time.Duration
Context context.Context
HTTPClient *http.Client
}
// WithDefaults hydrates default values in the update enterprise pool params (not the query body).
//
// All values with no default are reset to their zero value.
func (o *UpdateEnterprisePoolParams) WithDefaults() *UpdateEnterprisePoolParams {
o.SetDefaults()
return o
}
// SetDefaults hydrates default values in the update enterprise pool params (not the query body).
//
// All values with no default are reset to their zero value.
func (o *UpdateEnterprisePoolParams) SetDefaults() {
// no default values defined for this parameter
}
// WithTimeout adds the timeout to the update enterprise pool params
func (o *UpdateEnterprisePoolParams) WithTimeout(timeout time.Duration) *UpdateEnterprisePoolParams {
o.SetTimeout(timeout)
return o
}
// SetTimeout adds the timeout to the update enterprise pool params
func (o *UpdateEnterprisePoolParams) SetTimeout(timeout time.Duration) {
o.timeout = timeout
}
// WithContext adds the context to the update enterprise pool params
func (o *UpdateEnterprisePoolParams) WithContext(ctx context.Context) *UpdateEnterprisePoolParams {
o.SetContext(ctx)
return o
}
// SetContext adds the context to the update enterprise pool params
func (o *UpdateEnterprisePoolParams) SetContext(ctx context.Context) {
o.Context = ctx
}
// WithHTTPClient adds the HTTPClient to the update enterprise pool params
func (o *UpdateEnterprisePoolParams) WithHTTPClient(client *http.Client) *UpdateEnterprisePoolParams {
o.SetHTTPClient(client)
return o
}
// SetHTTPClient adds the HTTPClient to the update enterprise pool params
func (o *UpdateEnterprisePoolParams) SetHTTPClient(client *http.Client) {
o.HTTPClient = client
}
// WithBody adds the body to the update enterprise pool params
func (o *UpdateEnterprisePoolParams) WithBody(body garm_params.UpdatePoolParams) *UpdateEnterprisePoolParams {
o.SetBody(body)
return o
}
// SetBody adds the body to the update enterprise pool params
func (o *UpdateEnterprisePoolParams) SetBody(body garm_params.UpdatePoolParams) {
o.Body = body
}
// WithEnterpriseID adds the enterpriseID to the update enterprise pool params
func (o *UpdateEnterprisePoolParams) WithEnterpriseID(enterpriseID string) *UpdateEnterprisePoolParams {
o.SetEnterpriseID(enterpriseID)
return o
}
// SetEnterpriseID adds the enterpriseId to the update enterprise pool params
func (o *UpdateEnterprisePoolParams) SetEnterpriseID(enterpriseID string) {
o.EnterpriseID = enterpriseID
}
// WithPoolID adds the poolID to the update enterprise pool params
func (o *UpdateEnterprisePoolParams) WithPoolID(poolID string) *UpdateEnterprisePoolParams {
o.SetPoolID(poolID)
return o
}
// SetPoolID adds the poolId to the update enterprise pool params
func (o *UpdateEnterprisePoolParams) SetPoolID(poolID string) {
o.PoolID = poolID
}
// WriteToRequest writes these params to a swagger request
func (o *UpdateEnterprisePoolParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error {
if err := r.SetTimeout(o.timeout); err != nil {
return err
}
var res []error
if err := r.SetBodyParam(o.Body); err != nil {
return err
}
// path param enterpriseID
if err := r.SetPathParam("enterpriseID", o.EnterpriseID); err != nil {
return err
}
// path param poolID
if err := r.SetPathParam("poolID", o.PoolID); err != nil {
return err
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
}

View file

@ -0,0 +1,179 @@
// Code generated by go-swagger; DO NOT EDIT.
package enterprises
// This file was generated by the swagger tool.
// Editing this file might prove futile when you re-run the swagger generate command
import (
"fmt"
"io"
"github.com/go-openapi/runtime"
"github.com/go-openapi/strfmt"
apiserver_params "github.com/cloudbase/garm/apiserver/params"
garm_params "github.com/cloudbase/garm/params"
)
// UpdateEnterprisePoolReader is a Reader for the UpdateEnterprisePool structure.
type UpdateEnterprisePoolReader struct {
formats strfmt.Registry
}
// ReadResponse reads a server response into the received o.
func (o *UpdateEnterprisePoolReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) {
switch response.Code() {
case 200:
result := NewUpdateEnterprisePoolOK()
if err := result.readResponse(response, consumer, o.formats); err != nil {
return nil, err
}
return result, nil
default:
result := NewUpdateEnterprisePoolDefault(response.Code())
if err := result.readResponse(response, consumer, o.formats); err != nil {
return nil, err
}
if response.Code()/100 == 2 {
return result, nil
}
return nil, result
}
}
// NewUpdateEnterprisePoolOK creates a UpdateEnterprisePoolOK with default headers values
func NewUpdateEnterprisePoolOK() *UpdateEnterprisePoolOK {
return &UpdateEnterprisePoolOK{}
}
/*
UpdateEnterprisePoolOK describes a response with status code 200, with default header values.
Pool
*/
type UpdateEnterprisePoolOK struct {
Payload garm_params.Pool
}
// IsSuccess returns true when this update enterprise pool o k response has a 2xx status code
func (o *UpdateEnterprisePoolOK) IsSuccess() bool {
return true
}
// IsRedirect returns true when this update enterprise pool o k response has a 3xx status code
func (o *UpdateEnterprisePoolOK) IsRedirect() bool {
return false
}
// IsClientError returns true when this update enterprise pool o k response has a 4xx status code
func (o *UpdateEnterprisePoolOK) IsClientError() bool {
return false
}
// IsServerError returns true when this update enterprise pool o k response has a 5xx status code
func (o *UpdateEnterprisePoolOK) IsServerError() bool {
return false
}
// IsCode returns true when this update enterprise pool o k response a status code equal to that given
func (o *UpdateEnterprisePoolOK) IsCode(code int) bool {
return code == 200
}
// Code gets the status code for the update enterprise pool o k response
func (o *UpdateEnterprisePoolOK) Code() int {
return 200
}
func (o *UpdateEnterprisePoolOK) Error() string {
return fmt.Sprintf("[PUT /enterprises/{enterpriseID}/pools/{poolID}][%d] updateEnterprisePoolOK %+v", 200, o.Payload)
}
func (o *UpdateEnterprisePoolOK) String() string {
return fmt.Sprintf("[PUT /enterprises/{enterpriseID}/pools/{poolID}][%d] updateEnterprisePoolOK %+v", 200, o.Payload)
}
func (o *UpdateEnterprisePoolOK) GetPayload() garm_params.Pool {
return o.Payload
}
func (o *UpdateEnterprisePoolOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error {
// response payload
if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF {
return err
}
return nil
}
// NewUpdateEnterprisePoolDefault creates a UpdateEnterprisePoolDefault with default headers values
func NewUpdateEnterprisePoolDefault(code int) *UpdateEnterprisePoolDefault {
return &UpdateEnterprisePoolDefault{
_statusCode: code,
}
}
/*
UpdateEnterprisePoolDefault describes a response with status code -1, with default header values.
APIErrorResponse
*/
type UpdateEnterprisePoolDefault struct {
_statusCode int
Payload apiserver_params.APIErrorResponse
}
// IsSuccess returns true when this update enterprise pool default response has a 2xx status code
func (o *UpdateEnterprisePoolDefault) IsSuccess() bool {
return o._statusCode/100 == 2
}
// IsRedirect returns true when this update enterprise pool default response has a 3xx status code
func (o *UpdateEnterprisePoolDefault) IsRedirect() bool {
return o._statusCode/100 == 3
}
// IsClientError returns true when this update enterprise pool default response has a 4xx status code
func (o *UpdateEnterprisePoolDefault) IsClientError() bool {
return o._statusCode/100 == 4
}
// IsServerError returns true when this update enterprise pool default response has a 5xx status code
func (o *UpdateEnterprisePoolDefault) IsServerError() bool {
return o._statusCode/100 == 5
}
// IsCode returns true when this update enterprise pool default response a status code equal to that given
func (o *UpdateEnterprisePoolDefault) IsCode(code int) bool {
return o._statusCode == code
}
// Code gets the status code for the update enterprise pool default response
func (o *UpdateEnterprisePoolDefault) Code() int {
return o._statusCode
}
func (o *UpdateEnterprisePoolDefault) Error() string {
return fmt.Sprintf("[PUT /enterprises/{enterpriseID}/pools/{poolID}][%d] UpdateEnterprisePool default %+v", o._statusCode, o.Payload)
}
func (o *UpdateEnterprisePoolDefault) String() string {
return fmt.Sprintf("[PUT /enterprises/{enterpriseID}/pools/{poolID}][%d] UpdateEnterprisePool default %+v", o._statusCode, o.Payload)
}
func (o *UpdateEnterprisePoolDefault) GetPayload() apiserver_params.APIErrorResponse {
return o.Payload
}
func (o *UpdateEnterprisePoolDefault) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error {
// response payload
if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF {
return err
}
return nil
}

View file

@ -0,0 +1,179 @@
// Code generated by go-swagger; DO NOT EDIT.
package enterprises
// This file was generated by the swagger tool.
// Editing this file might prove futile when you re-run the swagger generate command
import (
"fmt"
"io"
"github.com/go-openapi/runtime"
"github.com/go-openapi/strfmt"
apiserver_params "github.com/cloudbase/garm/apiserver/params"
garm_params "github.com/cloudbase/garm/params"
)
// UpdateEnterpriseReader is a Reader for the UpdateEnterprise structure.
type UpdateEnterpriseReader struct {
formats strfmt.Registry
}
// ReadResponse reads a server response into the received o.
func (o *UpdateEnterpriseReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) {
switch response.Code() {
case 200:
result := NewUpdateEnterpriseOK()
if err := result.readResponse(response, consumer, o.formats); err != nil {
return nil, err
}
return result, nil
default:
result := NewUpdateEnterpriseDefault(response.Code())
if err := result.readResponse(response, consumer, o.formats); err != nil {
return nil, err
}
if response.Code()/100 == 2 {
return result, nil
}
return nil, result
}
}
// NewUpdateEnterpriseOK creates a UpdateEnterpriseOK with default headers values
func NewUpdateEnterpriseOK() *UpdateEnterpriseOK {
return &UpdateEnterpriseOK{}
}
/*
UpdateEnterpriseOK describes a response with status code 200, with default header values.
Enterprise
*/
type UpdateEnterpriseOK struct {
Payload garm_params.Enterprise
}
// IsSuccess returns true when this update enterprise o k response has a 2xx status code
func (o *UpdateEnterpriseOK) IsSuccess() bool {
return true
}
// IsRedirect returns true when this update enterprise o k response has a 3xx status code
func (o *UpdateEnterpriseOK) IsRedirect() bool {
return false
}
// IsClientError returns true when this update enterprise o k response has a 4xx status code
func (o *UpdateEnterpriseOK) IsClientError() bool {
return false
}
// IsServerError returns true when this update enterprise o k response has a 5xx status code
func (o *UpdateEnterpriseOK) IsServerError() bool {
return false
}
// IsCode returns true when this update enterprise o k response a status code equal to that given
func (o *UpdateEnterpriseOK) IsCode(code int) bool {
return code == 200
}
// Code gets the status code for the update enterprise o k response
func (o *UpdateEnterpriseOK) Code() int {
return 200
}
func (o *UpdateEnterpriseOK) Error() string {
return fmt.Sprintf("[PUT /enterprises/{enterpriseID}][%d] updateEnterpriseOK %+v", 200, o.Payload)
}
func (o *UpdateEnterpriseOK) String() string {
return fmt.Sprintf("[PUT /enterprises/{enterpriseID}][%d] updateEnterpriseOK %+v", 200, o.Payload)
}
func (o *UpdateEnterpriseOK) GetPayload() garm_params.Enterprise {
return o.Payload
}
func (o *UpdateEnterpriseOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error {
// response payload
if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF {
return err
}
return nil
}
// NewUpdateEnterpriseDefault creates a UpdateEnterpriseDefault with default headers values
func NewUpdateEnterpriseDefault(code int) *UpdateEnterpriseDefault {
return &UpdateEnterpriseDefault{
_statusCode: code,
}
}
/*
UpdateEnterpriseDefault describes a response with status code -1, with default header values.
APIErrorResponse
*/
type UpdateEnterpriseDefault struct {
_statusCode int
Payload apiserver_params.APIErrorResponse
}
// IsSuccess returns true when this update enterprise default response has a 2xx status code
func (o *UpdateEnterpriseDefault) IsSuccess() bool {
return o._statusCode/100 == 2
}
// IsRedirect returns true when this update enterprise default response has a 3xx status code
func (o *UpdateEnterpriseDefault) IsRedirect() bool {
return o._statusCode/100 == 3
}
// IsClientError returns true when this update enterprise default response has a 4xx status code
func (o *UpdateEnterpriseDefault) IsClientError() bool {
return o._statusCode/100 == 4
}
// IsServerError returns true when this update enterprise default response has a 5xx status code
func (o *UpdateEnterpriseDefault) IsServerError() bool {
return o._statusCode/100 == 5
}
// IsCode returns true when this update enterprise default response a status code equal to that given
func (o *UpdateEnterpriseDefault) IsCode(code int) bool {
return o._statusCode == code
}
// Code gets the status code for the update enterprise default response
func (o *UpdateEnterpriseDefault) Code() int {
return o._statusCode
}
func (o *UpdateEnterpriseDefault) Error() string {
return fmt.Sprintf("[PUT /enterprises/{enterpriseID}][%d] UpdateEnterprise default %+v", o._statusCode, o.Payload)
}
func (o *UpdateEnterpriseDefault) String() string {
return fmt.Sprintf("[PUT /enterprises/{enterpriseID}][%d] UpdateEnterprise default %+v", o._statusCode, o.Payload)
}
func (o *UpdateEnterpriseDefault) GetPayload() apiserver_params.APIErrorResponse {
return o.Payload
}
func (o *UpdateEnterpriseDefault) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error {
// response payload
if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF {
return err
}
return nil
}