ldap_client.go

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

package ldap

// 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"

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

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

/*
Client for ldap API
*/
type Client struct {
	transport runtime.ClientTransport
	formats   strfmt.Registry
}

/*
DeleteLdap deletes l d a p config by id

LDAP server integration enables the user to provide a central place to store usernames and passwords for the users of his/her clusters.
*/
func (a *Client) DeleteLdap(params *DeleteLdapParams) error {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteLdapParams()
	}

	_, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "deleteLdap",
		Method:             "DELETE",
		PathPattern:        "/ldap/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &DeleteLdapReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return err
	}
	return nil

}

/*
DeletePrivateLdap deletes private l d a p config by name

LDAP server integration enables the user to provide a central place to store usernames and passwords for the users of his/her clusters.
*/
func (a *Client) DeletePrivateLdap(params *DeletePrivateLdapParams) error {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeletePrivateLdapParams()
	}

	_, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "deletePrivateLdap",
		Method:             "DELETE",
		PathPattern:        "/ldap/user/{name}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &DeletePrivateLdapReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return err
	}
	return nil

}

/*
DeletePublicLdap deletes public owned or private l d a p config by name

LDAP server integration enables the user to provide a central place to store usernames and passwords for the users of his/her clusters.
*/
func (a *Client) DeletePublicLdap(params *DeletePublicLdapParams) error {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeletePublicLdapParams()
	}

	_, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "deletePublicLdap",
		Method:             "DELETE",
		PathPattern:        "/ldap/account/{name}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &DeletePublicLdapReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return err
	}
	return nil

}

/*
GetLdap retrieves l d a p config by id

LDAP server integration enables the user to provide a central place to store usernames and passwords for the users of his/her clusters.
*/
func (a *Client) GetLdap(params *GetLdapParams) (*GetLdapOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetLdapParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "getLdap",
		Method:             "GET",
		PathPattern:        "/ldap/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &GetLdapReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetLdapOK), nil

}

/*
GetPrivateLdap retrieves a private l d a p config by name

LDAP server integration enables the user to provide a central place to store usernames and passwords for the users of his/her clusters.
*/
func (a *Client) GetPrivateLdap(params *GetPrivateLdapParams) (*GetPrivateLdapOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetPrivateLdapParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "getPrivateLdap",
		Method:             "GET",
		PathPattern:        "/ldap/user/{name}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &GetPrivateLdapReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetPrivateLdapOK), nil

}

/*
GetPrivatesLdap retrieves private l d a p configs

LDAP server integration enables the user to provide a central place to store usernames and passwords for the users of his/her clusters.
*/
func (a *Client) GetPrivatesLdap(params *GetPrivatesLdapParams) (*GetPrivatesLdapOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetPrivatesLdapParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "getPrivatesLdap",
		Method:             "GET",
		PathPattern:        "/ldap/user",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &GetPrivatesLdapReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetPrivatesLdapOK), nil

}

/*
GetPublicLdap retrieves a public or private owned l d a p config by name

LDAP server integration enables the user to provide a central place to store usernames and passwords for the users of his/her clusters.
*/
func (a *Client) GetPublicLdap(params *GetPublicLdapParams) (*GetPublicLdapOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetPublicLdapParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "getPublicLdap",
		Method:             "GET",
		PathPattern:        "/ldap/account/{name}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &GetPublicLdapReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetPublicLdapOK), nil

}

/*
GetPublicsLdap retrieves public and private owned l d a p configs

LDAP server integration enables the user to provide a central place to store usernames and passwords for the users of his/her clusters.
*/
func (a *Client) GetPublicsLdap(params *GetPublicsLdapParams) (*GetPublicsLdapOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetPublicsLdapParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "getPublicsLdap",
		Method:             "GET",
		PathPattern:        "/ldap/account",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &GetPublicsLdapReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetPublicsLdapOK), nil

}

/*
PostPrivateLdap creates l d a p config as private resource

LDAP server integration enables the user to provide a central place to store usernames and passwords for the users of his/her clusters.
*/
func (a *Client) PostPrivateLdap(params *PostPrivateLdapParams) (*PostPrivateLdapOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostPrivateLdapParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "postPrivateLdap",
		Method:             "POST",
		PathPattern:        "/ldap/user",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &PostPrivateLdapReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PostPrivateLdapOK), nil

}

/*
PostPublicLdap creates l d a p config as public resource

LDAP server integration enables the user to provide a central place to store usernames and passwords for the users of his/her clusters.
*/
func (a *Client) PostPublicLdap(params *PostPublicLdapParams) (*PostPublicLdapOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostPublicLdapParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "postPublicLdap",
		Method:             "POST",
		PathPattern:        "/ldap/account",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &PostPublicLdapReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PostPublicLdapOK), nil

}

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