user

package
v0.1.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Dec 14, 2015 License: Apache-2.0 Imports: 6 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type CreateUser 

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

CreateUser swagger:route POST /users user createUser

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) middleware.Responder
}

CreateUserHandler interface for that can handle valid create user params

type CreateUserHandlerFunc 

type CreateUserHandlerFunc func(CreateUserParams) middleware.Responder

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

func (CreateUserHandlerFunc) Handle 

func (fn CreateUserHandlerFunc) Handle(params CreateUserParams) middleware.Responder

Handle executing the request and returning a response

type CreateUserParams 

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

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

swagger:parameters createUser

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
}

CreateUsersWithArrayInput swagger:route POST /users/createWithArray user createUsersWithArrayInput

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) middleware.Responder
}

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

type CreateUsersWithArrayInputHandlerFunc 

type CreateUsersWithArrayInputHandlerFunc func(CreateUsersWithArrayInputParams) middleware.Responder

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) middleware.Responder

Handle executing the request and returning a response

type CreateUsersWithArrayInputParams 

type CreateUsersWithArrayInputParams struct {
	/*List of user object
	  In: body
	*/
	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

swagger:parameters createUsersWithArrayInput

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
}

CreateUsersWithListInput swagger:route POST /users/createWithList user createUsersWithListInput

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) middleware.Responder
}

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

type CreateUsersWithListInputHandlerFunc 

type CreateUsersWithListInputHandlerFunc func(CreateUsersWithListInputParams) middleware.Responder

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) middleware.Responder

Handle executing the request and returning a response

type CreateUsersWithListInputParams 

type CreateUsersWithListInputParams struct {
	/*List of user object
	  In: body
	*/
	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

swagger:parameters createUsersWithListInput

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
}

DeleteUser swagger:route DELETE /users/{username} user deleteUser

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 DeleteUserBadRequest 

type DeleteUserBadRequest struct {
}

DeleteUserBadRequest Invalid username supplied

swagger:response deleteUserBadRequest

func (*DeleteUserBadRequest) WriteResponse 

func (o *DeleteUserBadRequest) WriteResponse(rw http.ResponseWriter, producer httpkit.Producer)

WriteResponse to the client

type DeleteUserHandler 

type DeleteUserHandler interface {
	Handle(DeleteUserParams) middleware.Responder
}

DeleteUserHandler interface for that can handle valid delete user params

type DeleteUserHandlerFunc 

type DeleteUserHandlerFunc func(DeleteUserParams) middleware.Responder

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

func (DeleteUserHandlerFunc) Handle 

func (fn DeleteUserHandlerFunc) Handle(params DeleteUserParams) middleware.Responder

Handle executing the request and returning a response

type DeleteUserNotFound 

type DeleteUserNotFound struct {
}

DeleteUserNotFound User not found

swagger:response deleteUserNotFound

func (*DeleteUserNotFound) WriteResponse 

func (o *DeleteUserNotFound) WriteResponse(rw http.ResponseWriter, producer httpkit.Producer)

WriteResponse to the client

type DeleteUserParams 

type DeleteUserParams struct {
	/*The name that needs to be deleted
	  Required: true
	  In: path
	*/
	Username string
}

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

swagger:parameters deleteUser

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
}

GetUserByName swagger:route GET /users/{username} user getUserByName

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 GetUserByNameBadRequest 

type GetUserByNameBadRequest struct {
}

GetUserByNameBadRequest Invalid username supplied

swagger:response getUserByNameBadRequest

func (*GetUserByNameBadRequest) WriteResponse 

func (o *GetUserByNameBadRequest) WriteResponse(rw http.ResponseWriter, producer httpkit.Producer)

WriteResponse to the client

type GetUserByNameHandler 

type GetUserByNameHandler interface {
	Handle(GetUserByNameParams) middleware.Responder
}

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

type GetUserByNameHandlerFunc 

type GetUserByNameHandlerFunc func(GetUserByNameParams) middleware.Responder

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

func (GetUserByNameHandlerFunc) Handle 

func (fn GetUserByNameHandlerFunc) Handle(params GetUserByNameParams) middleware.Responder

Handle executing the request and returning a response

type GetUserByNameNotFound 

type GetUserByNameNotFound struct {
}

GetUserByNameNotFound User not found

swagger:response getUserByNameNotFound

func (*GetUserByNameNotFound) WriteResponse 

func (o *GetUserByNameNotFound) WriteResponse(rw http.ResponseWriter, producer httpkit.Producer)

WriteResponse to the client

type GetUserByNameOK 

type GetUserByNameOK struct {

	// In: body
	Payload *models.User `json:"body,omitempty"`
}

GetUserByNameOK successful operation

swagger:response getUserByNameOK

func (*GetUserByNameOK) WriteResponse 

func (o *GetUserByNameOK) WriteResponse(rw http.ResponseWriter, producer httpkit.Producer)

WriteResponse to the client

type GetUserByNameParams 

type GetUserByNameParams struct {
	/*The name that needs to be fetched. Use user1 for testing.
	  Required: true
	  In: path
	*/
	Username string
}

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

swagger:parameters getUserByName

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
}

LoginUser swagger:route GET /users/login user loginUser

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 LoginUserBadRequest 

type LoginUserBadRequest struct {
}

LoginUserBadRequest Invalid username/password supplied

swagger:response loginUserBadRequest

func (*LoginUserBadRequest) WriteResponse 

func (o *LoginUserBadRequest) WriteResponse(rw http.ResponseWriter, producer httpkit.Producer)

WriteResponse to the client

type LoginUserHandler 

type LoginUserHandler interface {
	Handle(LoginUserParams) middleware.Responder
}

LoginUserHandler interface for that can handle valid login user params

type LoginUserHandlerFunc 

type LoginUserHandlerFunc func(LoginUserParams) middleware.Responder

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

func (LoginUserHandlerFunc) Handle 

func (fn LoginUserHandlerFunc) Handle(params LoginUserParams) middleware.Responder

Handle executing the request and returning a response

type LoginUserOK 

type LoginUserOK struct {

	// In: body
	Payload string `json:"body,omitempty"`
}

LoginUserOK successful operation

swagger:response loginUserOK

func (*LoginUserOK) WriteResponse 

func (o *LoginUserOK) WriteResponse(rw http.ResponseWriter, producer httpkit.Producer)

WriteResponse to the client

type LoginUserParams 

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

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

swagger:parameters loginUser

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
}

LogoutUser swagger:route GET /users/logout user logoutUser

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() middleware.Responder
}

LogoutUserHandler interface for that can handle valid logout user params

type LogoutUserHandlerFunc 

type LogoutUserHandlerFunc func() middleware.Responder

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

func (LogoutUserHandlerFunc) Handle 

func (fn LogoutUserHandlerFunc) Handle() middleware.Responder

Handle executing the request and returning a response

type UpdateUser 

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

UpdateUser swagger:route PUT /users/{username} user updateUser

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 UpdateUserBadRequest 

type UpdateUserBadRequest struct {
}

UpdateUserBadRequest Invalid user supplied

swagger:response updateUserBadRequest

func (*UpdateUserBadRequest) WriteResponse 

func (o *UpdateUserBadRequest) WriteResponse(rw http.ResponseWriter, producer httpkit.Producer)

WriteResponse to the client

type UpdateUserHandler 

type UpdateUserHandler interface {
	Handle(UpdateUserParams) middleware.Responder
}

UpdateUserHandler interface for that can handle valid update user params

type UpdateUserHandlerFunc 

type UpdateUserHandlerFunc func(UpdateUserParams) middleware.Responder

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

func (UpdateUserHandlerFunc) Handle 

func (fn UpdateUserHandlerFunc) Handle(params UpdateUserParams) middleware.Responder

Handle executing the request and returning a response

type UpdateUserNotFound 

type UpdateUserNotFound struct {
}

UpdateUserNotFound User not found

swagger:response updateUserNotFound

func (*UpdateUserNotFound) WriteResponse 

func (o *UpdateUserNotFound) WriteResponse(rw http.ResponseWriter, producer httpkit.Producer)

WriteResponse to the client

type UpdateUserParams 

type UpdateUserParams struct {
	/*Updated user object
	  In: body
	*/
	Body *models.User
	/*name that need to be deleted
	  Required: true
	  In: path
	*/
	Username string
}

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

swagger:parameters updateUser

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

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.