user

Documentation

Index

• type CreateUser
  • func NewCreateUser(ctx *middleware.Context, handler CreateUserHandler) *CreateUser
  • func (o *CreateUser) ServeHTTP(rw http.ResponseWriter, r *http.Request)
• type CreateUserHandler
• type CreateUserHandlerFunc
  • func (fn CreateUserHandlerFunc) Handle(params CreateUserParams) error
• type CreateUserParams
  • func (o *CreateUserParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error
• type CreateUsersWithArrayInput
  • func NewCreateUsersWithArrayInput(ctx *middleware.Context, handler CreateUsersWithArrayInputHandler) *CreateUsersWithArrayInput
  • func (o *CreateUsersWithArrayInput) ServeHTTP(rw http.ResponseWriter, r *http.Request)
• type CreateUsersWithArrayInputHandler
• type CreateUsersWithArrayInputHandlerFunc
  • func (fn CreateUsersWithArrayInputHandlerFunc) Handle(params CreateUsersWithArrayInputParams) error
• type CreateUsersWithArrayInputParams
  • func (o *CreateUsersWithArrayInputParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error
• type CreateUsersWithListInput
  • func NewCreateUsersWithListInput(ctx *middleware.Context, handler CreateUsersWithListInputHandler) *CreateUsersWithListInput
  • func (o *CreateUsersWithListInput) ServeHTTP(rw http.ResponseWriter, r *http.Request)
• type CreateUsersWithListInputHandler
• type CreateUsersWithListInputHandlerFunc
  • func (fn CreateUsersWithListInputHandlerFunc) Handle(params CreateUsersWithListInputParams) error
• type CreateUsersWithListInputParams
  • func (o *CreateUsersWithListInputParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error
• type DeleteUser
  • func NewDeleteUser(ctx *middleware.Context, handler DeleteUserHandler) *DeleteUser
  • func (o *DeleteUser) ServeHTTP(rw http.ResponseWriter, r *http.Request)
• type DeleteUserHandler
• type DeleteUserHandlerFunc
  • func (fn DeleteUserHandlerFunc) Handle(params DeleteUserParams) error
• type DeleteUserParams
  • func (o *DeleteUserParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error
• type GetUserByName
  • func NewGetUserByName(ctx *middleware.Context, handler GetUserByNameHandler) *GetUserByName
  • func (o *GetUserByName) ServeHTTP(rw http.ResponseWriter, r *http.Request)
• type GetUserByNameHandler
• type GetUserByNameHandlerFunc
  • func (fn GetUserByNameHandlerFunc) Handle(params GetUserByNameParams) (*models.User, error)
• type GetUserByNameParams
  • func (o *GetUserByNameParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error
• type LoginUser
  • func NewLoginUser(ctx *middleware.Context, handler LoginUserHandler) *LoginUser
  • func (o *LoginUser) ServeHTTP(rw http.ResponseWriter, r *http.Request)
• type LoginUserHandler
• type LoginUserHandlerFunc
  • func (fn LoginUserHandlerFunc) Handle(params LoginUserParams) (string, error)
• type LoginUserParams
  • func (o *LoginUserParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error
• type LogoutUser
  • func NewLogoutUser(ctx *middleware.Context, handler LogoutUserHandler) *LogoutUser
  • func (o *LogoutUser) ServeHTTP(rw http.ResponseWriter, r *http.Request)
• type LogoutUserHandler
• type LogoutUserHandlerFunc
  • func (fn LogoutUserHandlerFunc) Handle() error
• type UpdateUser
  • func NewUpdateUser(ctx *middleware.Context, handler UpdateUserHandler) *UpdateUser
  • func (o *UpdateUser) ServeHTTP(rw http.ResponseWriter, r *http.Request)
• type UpdateUserHandler
• type UpdateUserHandlerFunc
  • func (fn UpdateUserHandlerFunc) Handle(params UpdateUserParams) error
• type UpdateUserParams
  • func (o *UpdateUserParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error

Types

type CreateUser

type CreateUser struct {
	Context *middleware.Context
	Params  CreateUserParams
	Handler CreateUserHandler
}

Create user

This can only be done by the logged in user.

func NewCreateUser

func NewCreateUser(ctx *middleware.Context, handler CreateUserHandler) *CreateUser

NewCreateUser creates a new http.Handler for the create user operation

func (*CreateUser) ServeHTTP

func (o *CreateUser) ServeHTTP(rw http.ResponseWriter, r *http.Request)

type CreateUserHandler

type CreateUserHandler interface {
	Handle(CreateUserParams) error
}

CreateUserHandler interface for that can handle valid create user params

type CreateUserHandlerFunc

type CreateUserHandlerFunc func(CreateUserParams) error

CreateUserHandlerFunc turns a function with the right signature into a create user handler

func (CreateUserHandlerFunc) Handle

func (fn CreateUserHandlerFunc) Handle(params CreateUserParams) error

type CreateUserParams

type CreateUserParams struct {
	// Created user object
	Body *models.User
}

CreateUserParams contains all the bound params for the create user operation typically these are obtained from a http.Request

func (*CreateUserParams) BindRequest

func (o *CreateUserParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error

BindRequest both binds and validates a request, it assumes that complex things implement a Validatable(strfmt.Registry) error interface for simple values it will use straight method calls

type CreateUsersWithArrayInput

type CreateUsersWithArrayInput struct {
	Context *middleware.Context
	Params  CreateUsersWithArrayInputParams
	Handler CreateUsersWithArrayInputHandler
}

Creates list of users with given input array

func NewCreateUsersWithArrayInput

func NewCreateUsersWithArrayInput(ctx *middleware.Context, handler CreateUsersWithArrayInputHandler) *CreateUsersWithArrayInput

NewCreateUsersWithArrayInput creates a new http.Handler for the create users with array input operation

func (*CreateUsersWithArrayInput) ServeHTTP

func (o *CreateUsersWithArrayInput) ServeHTTP(rw http.ResponseWriter, r *http.Request)

type CreateUsersWithArrayInputHandler

type CreateUsersWithArrayInputHandler interface {
	Handle(CreateUsersWithArrayInputParams) error
}

CreateUsersWithArrayInputHandler interface for that can handle valid create users with array input params

type CreateUsersWithArrayInputHandlerFunc

type CreateUsersWithArrayInputHandlerFunc func(CreateUsersWithArrayInputParams) error

CreateUsersWithArrayInputHandlerFunc turns a function with the right signature into a create users with array input handler

func (CreateUsersWithArrayInputHandlerFunc) Handle

func (fn CreateUsersWithArrayInputHandlerFunc) Handle(params CreateUsersWithArrayInputParams) error

type CreateUsersWithArrayInputParams

type CreateUsersWithArrayInputParams struct {
	// List of user object
	Body []models.User
}

CreateUsersWithArrayInputParams contains all the bound params for the create users with array input operation typically these are obtained from a http.Request

func (*CreateUsersWithArrayInputParams) BindRequest

func (o *CreateUsersWithArrayInputParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error

BindRequest both binds and validates a request, it assumes that complex things implement a Validatable(strfmt.Registry) error interface for simple values it will use straight method calls

type CreateUsersWithListInput

type CreateUsersWithListInput struct {
	Context *middleware.Context
	Params  CreateUsersWithListInputParams
	Handler CreateUsersWithListInputHandler
}

Creates list of users with given input array

func NewCreateUsersWithListInput

func NewCreateUsersWithListInput(ctx *middleware.Context, handler CreateUsersWithListInputHandler) *CreateUsersWithListInput

NewCreateUsersWithListInput creates a new http.Handler for the create users with list input operation

func (*CreateUsersWithListInput) ServeHTTP

func (o *CreateUsersWithListInput) ServeHTTP(rw http.ResponseWriter, r *http.Request)

type CreateUsersWithListInputHandler

type CreateUsersWithListInputHandler interface {
	Handle(CreateUsersWithListInputParams) error
}

CreateUsersWithListInputHandler interface for that can handle valid create users with list input params

type CreateUsersWithListInputHandlerFunc

type CreateUsersWithListInputHandlerFunc func(CreateUsersWithListInputParams) error

CreateUsersWithListInputHandlerFunc turns a function with the right signature into a create users with list input handler

func (CreateUsersWithListInputHandlerFunc) Handle

func (fn CreateUsersWithListInputHandlerFunc) Handle(params CreateUsersWithListInputParams) error

type CreateUsersWithListInputParams

type CreateUsersWithListInputParams struct {
	// List of user object
	Body []models.User
}

CreateUsersWithListInputParams contains all the bound params for the create users with list input operation typically these are obtained from a http.Request

func (*CreateUsersWithListInputParams) BindRequest

func (o *CreateUsersWithListInputParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error

BindRequest both binds and validates a request, it assumes that complex things implement a Validatable(strfmt.Registry) error interface for simple values it will use straight method calls

type DeleteUser

type DeleteUser struct {
	Context *middleware.Context
	Params  DeleteUserParams
	Handler DeleteUserHandler
}

Delete user

This can only be done by the logged in user.

func NewDeleteUser

func NewDeleteUser(ctx *middleware.Context, handler DeleteUserHandler) *DeleteUser

NewDeleteUser creates a new http.Handler for the delete user operation

func (*DeleteUser) ServeHTTP

func (o *DeleteUser) ServeHTTP(rw http.ResponseWriter, r *http.Request)

type DeleteUserHandler

type DeleteUserHandler interface {
	Handle(DeleteUserParams) error
}

DeleteUserHandler interface for that can handle valid delete user params

type DeleteUserHandlerFunc

type DeleteUserHandlerFunc func(DeleteUserParams) error

DeleteUserHandlerFunc turns a function with the right signature into a delete user handler

func (DeleteUserHandlerFunc) Handle

func (fn DeleteUserHandlerFunc) Handle(params DeleteUserParams) error

type DeleteUserParams

type DeleteUserParams struct {
	// The name that needs to be deleted
	Username string
}

DeleteUserParams contains all the bound params for the delete user operation typically these are obtained from a http.Request

func (*DeleteUserParams) BindRequest

func (o *DeleteUserParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error

BindRequest both binds and validates a request, it assumes that complex things implement a Validatable(strfmt.Registry) error interface for simple values it will use straight method calls

type GetUserByName

type GetUserByName struct {
	Context *middleware.Context
	Params  GetUserByNameParams
	Handler GetUserByNameHandler
}

Get user by user name

func NewGetUserByName

func NewGetUserByName(ctx *middleware.Context, handler GetUserByNameHandler) *GetUserByName

NewGetUserByName creates a new http.Handler for the get user by name operation

func (*GetUserByName) ServeHTTP

func (o *GetUserByName) ServeHTTP(rw http.ResponseWriter, r *http.Request)

type GetUserByNameHandler

type GetUserByNameHandler interface {
	Handle(GetUserByNameParams) (*models.User, error)
}

GetUserByNameHandler interface for that can handle valid get user by name params

type GetUserByNameHandlerFunc

type GetUserByNameHandlerFunc func(GetUserByNameParams) (*models.User, error)

GetUserByNameHandlerFunc turns a function with the right signature into a get user by name handler

func (GetUserByNameHandlerFunc) Handle

func (fn GetUserByNameHandlerFunc) Handle(params GetUserByNameParams) (*models.User, error)

type GetUserByNameParams

type GetUserByNameParams struct {
	// The name that needs to be fetched. Use user1 for testing.
	Username string
}

GetUserByNameParams contains all the bound params for the get user by name operation typically these are obtained from a http.Request

func (*GetUserByNameParams) BindRequest

func (o *GetUserByNameParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error

BindRequest both binds and validates a request, it assumes that complex things implement a Validatable(strfmt.Registry) error interface for simple values it will use straight method calls

type LoginUser

type LoginUser struct {
	Context *middleware.Context
	Params  LoginUserParams
	Handler LoginUserHandler
}

Logs user into the system

func NewLoginUser

func NewLoginUser(ctx *middleware.Context, handler LoginUserHandler) *LoginUser

NewLoginUser creates a new http.Handler for the login user operation

func (*LoginUser) ServeHTTP

func (o *LoginUser) ServeHTTP(rw http.ResponseWriter, r *http.Request)

type LoginUserHandler

type LoginUserHandler interface {
	Handle(LoginUserParams) (string, error)
}

LoginUserHandler interface for that can handle valid login user params

type LoginUserHandlerFunc

type LoginUserHandlerFunc func(LoginUserParams) (string, error)

LoginUserHandlerFunc turns a function with the right signature into a login user handler

func (LoginUserHandlerFunc) Handle

func (fn LoginUserHandlerFunc) Handle(params LoginUserParams) (string, error)

type LoginUserParams

type LoginUserParams struct {
	// The user name for login
	Username string
	// The password for login in clear text
	Password string
}

LoginUserParams contains all the bound params for the login user operation typically these are obtained from a http.Request

func (*LoginUserParams) BindRequest

func (o *LoginUserParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error

BindRequest both binds and validates a request, it assumes that complex things implement a Validatable(strfmt.Registry) error interface for simple values it will use straight method calls

type LogoutUser

type LogoutUser struct {
	Context *middleware.Context
	Handler LogoutUserHandler
}

Logs out current logged in user session

func NewLogoutUser

func NewLogoutUser(ctx *middleware.Context, handler LogoutUserHandler) *LogoutUser

NewLogoutUser creates a new http.Handler for the logout user operation

func (*LogoutUser) ServeHTTP

func (o *LogoutUser) ServeHTTP(rw http.ResponseWriter, r *http.Request)

type LogoutUserHandler

type LogoutUserHandler interface {
	Handle() error
}

LogoutUserHandler interface for that can handle valid logout user params

type LogoutUserHandlerFunc

type LogoutUserHandlerFunc func() error

LogoutUserHandlerFunc turns a function with the right signature into a logout user handler

func (LogoutUserHandlerFunc) Handle

func (fn LogoutUserHandlerFunc) Handle() error

type UpdateUser

type UpdateUser struct {
	Context *middleware.Context
	Params  UpdateUserParams
	Handler UpdateUserHandler
}

Updated user

This can only be done by the logged in user.

func NewUpdateUser

func NewUpdateUser(ctx *middleware.Context, handler UpdateUserHandler) *UpdateUser

NewUpdateUser creates a new http.Handler for the update user operation

func (*UpdateUser) ServeHTTP

func (o *UpdateUser) ServeHTTP(rw http.ResponseWriter, r *http.Request)

type UpdateUserHandler

type UpdateUserHandler interface {
	Handle(UpdateUserParams) error
}

UpdateUserHandler interface for that can handle valid update user params

type UpdateUserHandlerFunc

type UpdateUserHandlerFunc func(UpdateUserParams) error

UpdateUserHandlerFunc turns a function with the right signature into a update user handler

func (UpdateUserHandlerFunc) Handle

func (fn UpdateUserHandlerFunc) Handle(params UpdateUserParams) error

type UpdateUserParams

type UpdateUserParams struct {
	// name that need to be deleted
	Username string
	// Updated user object
	Body *models.User
}

UpdateUserParams contains all the bound params for the update user operation typically these are obtained from a http.Request

func (*UpdateUserParams) BindRequest

func (o *UpdateUserParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error

BindRequest both binds and validates a request, it assumes that complex things implement a Validatable(strfmt.Registry) error interface for simple values it will use straight method calls