workflows_client.go

// Code generated by go-swagger; DO NOT EDIT.

package workflows

// This file was generated by the swagger tool.
// Editing this file might prove futile when you re-run the swagger generate command

import (
	"fmt"

	"github.com/go-openapi/runtime"
	"github.com/go-openapi/strfmt"
)

// New creates a new workflows API client.
func New(transport runtime.ClientTransport, formats strfmt.Registry) ClientService {
	return &Client{transport: transport, formats: formats}
}

/*
Client for workflows 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 {
	AwaitExecuteWorkflow(params *AwaitExecuteWorkflowParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*AwaitExecuteWorkflowOK, error)

	AwaitExecuteWorkflowBody(params *AwaitExecuteWorkflowBodyParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*AwaitExecuteWorkflowBodyOK, error)

	CreateWorkflow(params *CreateWorkflowParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateWorkflowOK, error)

	ExecuteWorkflow(params *ExecuteWorkflowParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ExecuteWorkflowOK, error)

	SetWorkflowCloudEventLogs(params *SetWorkflowCloudEventLogsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*SetWorkflowCloudEventLogsOK, error)

	ToggleWorkflow(params *ToggleWorkflowParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ToggleWorkflowOK, error)

	UpdateWorkflow(params *UpdateWorkflowParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateWorkflowOK, error)

	SetTransport(transport runtime.ClientTransport)
}

/*
  AwaitExecuteWorkflow awaits execute a workflow

  Executes a workflow. This path will wait until the workflow execution has completed and return the instance output.
NOTE: Input can also be provided with the `input.X` query parameters; Where `X` is the json key.
Only top level json keys are supported when providing input with query parameters.

*/
func (a *Client) AwaitExecuteWorkflow(params *AwaitExecuteWorkflowParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*AwaitExecuteWorkflowOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewAwaitExecuteWorkflowParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "awaitExecuteWorkflow",
		Method:             "GET",
		PathPattern:        "/api/namespaces/{namespace}/tree/{workflow}?op=wait",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &AwaitExecuteWorkflowReader{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.(*AwaitExecuteWorkflowOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for awaitExecuteWorkflow: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  AwaitExecuteWorkflowBody awaits execute a workflow with body

  Executes a workflow with optionally some input provided in the request body as json.
This path will wait until the workflow execution has completed and return the instance output.
NOTE: Input can also be provided with the `input.X` query parameters; Where `X` is the json key.
Only top level json keys are supported when providing input with query parameters.
Input query parameters are only read if the request has no body.

*/
func (a *Client) AwaitExecuteWorkflowBody(params *AwaitExecuteWorkflowBodyParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*AwaitExecuteWorkflowBodyOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewAwaitExecuteWorkflowBodyParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "awaitExecuteWorkflowBody",
		Method:             "POST",
		PathPattern:        "/api/namespaces/{namespace}/tree/{workflow}?op=wait",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &AwaitExecuteWorkflowBodyReader{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.(*AwaitExecuteWorkflowBodyOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for awaitExecuteWorkflowBody: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  CreateWorkflow creates a workflow

  Creates a workflow at the target path.
The body of this request should contain the workflow yaml.

*/
func (a *Client) CreateWorkflow(params *CreateWorkflowParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*CreateWorkflowOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCreateWorkflowParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "createWorkflow",
		Method:             "PUT",
		PathPattern:        "/api/namespaces/{namespace}/tree/{workflow}?op=create-workflow",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"text/plain"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &CreateWorkflowReader{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.(*CreateWorkflowOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*CreateWorkflowDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  ExecuteWorkflow executes a workflow

  Executes a workflow with optionally some input provided in the request body as json.

*/
func (a *Client) ExecuteWorkflow(params *ExecuteWorkflowParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ExecuteWorkflowOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewExecuteWorkflowParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "executeWorkflow",
		Method:             "POST",
		PathPattern:        "/api/namespaces/{namespace}/tree/{workflow}?op=execute",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &ExecuteWorkflowReader{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.(*ExecuteWorkflowOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	unexpectedSuccess := result.(*ExecuteWorkflowDefault)
	return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())
}

/*
  SetWorkflowCloudEventLogs sets cloud event for workflow to log to

  Set Cloud Event for Workflow to Log to.
When configured type `direktiv.instanceLog` cloud events will be generated with the `logger` parameter set to the configured value.
Workflows can be configured to generate cloud events on their namespace anything the log parameter produces data.
Please find more information on this topic here:
https://docs.direktiv.io/docs/examples/logging.html

*/
func (a *Client) SetWorkflowCloudEventLogs(params *SetWorkflowCloudEventLogsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*SetWorkflowCloudEventLogsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewSetWorkflowCloudEventLogsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "setWorkflowCloudEventLogs",
		Method:             "POST",
		PathPattern:        "/api/namespaces/{namespace}/tree/{workflow}?op=set-workflow-event-logging",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &SetWorkflowCloudEventLogsReader{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.(*SetWorkflowCloudEventLogsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for setWorkflowCloudEventLogs: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  ToggleWorkflow sets cloud event for workflow to log to

  Toggle's whether or not a workflow is active.
Disabled workflows cannot be invoked. This includes start event and scheduled workflows.

*/
func (a *Client) ToggleWorkflow(params *ToggleWorkflowParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*ToggleWorkflowOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewToggleWorkflowParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "toggleWorkflow",
		Method:             "POST",
		PathPattern:        "/api/namespaces/{namespace}/tree/{workflow}?op=toggle",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &ToggleWorkflowReader{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.(*ToggleWorkflowOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for toggleWorkflow: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  UpdateWorkflow updates a workflow

  Updates a workflow at the target path.
The body of this request should contain the workflow yaml you want to update to.

*/
func (a *Client) UpdateWorkflow(params *UpdateWorkflowParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UpdateWorkflowOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateWorkflowParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "updateWorkflow",
		Method:             "POST",
		PathPattern:        "/api/namespaces/{namespace}/tree/{workflow}?op=update-workflow",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"text/plain"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &UpdateWorkflowReader{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.(*UpdateWorkflowOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for updateWorkflow: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

// SetTransport changes the transport on the client
func (a *Client) SetTransport(transport runtime.ClientTransport) {
	a.transport = transport
}