user

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(ctx *middleware.Context, handler CreateUserHandler) *CreateUser

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 (fn CreateUserHandlerFunc) Handle(params CreateUserParams) middleware.Responder

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 (o *CreateUserParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error

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(ctx *middleware.Context, handler CreateUsersWithArrayInputHandler) *CreateUsersWithArrayInput

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 (fn CreateUsersWithArrayInputHandlerFunc) Handle(params CreateUsersWithArrayInputParams) middleware.Responder

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 (o *CreateUsersWithArrayInputParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error

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(ctx *middleware.Context, handler CreateUsersWithListInputHandler) *CreateUsersWithListInput

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 (fn CreateUsersWithListInputHandlerFunc) Handle(params CreateUsersWithListInputParams) middleware.Responder

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 (o *CreateUsersWithListInputParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error

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(ctx *middleware.Context, handler DeleteUserHandler) *DeleteUser

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

type DeleteUserBadRequest ¶

type DeleteUserBadRequest struct {
}

DeleteUserBadRequest Invalid username supplied

swagger:response deleteUserBadRequest

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

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 (fn DeleteUserHandlerFunc) Handle(params DeleteUserParams) middleware.Responder

type DeleteUserNotFound ¶

type DeleteUserNotFound struct {
}

DeleteUserNotFound User not found

swagger:response deleteUserNotFound

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

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 (o *DeleteUserParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error

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(ctx *middleware.Context, handler GetUserByNameHandler) *GetUserByName

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

type GetUserByNameBadRequest ¶

type GetUserByNameBadRequest struct {
}

GetUserByNameBadRequest Invalid username supplied

swagger:response getUserByNameBadRequest

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

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 (fn GetUserByNameHandlerFunc) Handle(params GetUserByNameParams) middleware.Responder

type GetUserByNameNotFound ¶

type GetUserByNameNotFound struct {
}

GetUserByNameNotFound User not found

swagger:response getUserByNameNotFound

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

type GetUserByNameOK ¶

type GetUserByNameOK struct {

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

GetUserByNameOK successful operation

swagger:response getUserByNameOK

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

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 (o *GetUserByNameParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error

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(ctx *middleware.Context, handler LoginUserHandler) *LoginUser

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

type LoginUserBadRequest ¶

type LoginUserBadRequest struct {
}

LoginUserBadRequest Invalid username/password supplied

swagger:response loginUserBadRequest

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

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 (fn LoginUserHandlerFunc) Handle(params LoginUserParams) middleware.Responder

type LoginUserOK ¶

type LoginUserOK struct {

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

LoginUserOK successful operation

swagger:response loginUserOK

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

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 (o *LoginUserParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error

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(ctx *middleware.Context, handler LogoutUserHandler) *LogoutUser

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 (fn LogoutUserHandlerFunc) Handle() middleware.Responder

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(ctx *middleware.Context, handler UpdateUserHandler) *UpdateUser

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

type UpdateUserBadRequest ¶

type UpdateUserBadRequest struct {
}

UpdateUserBadRequest Invalid user supplied

swagger:response updateUserBadRequest

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

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 (fn UpdateUserHandlerFunc) Handle(params UpdateUserParams) middleware.Responder

type UpdateUserNotFound ¶

type UpdateUserNotFound struct {
}

UpdateUserNotFound User not found

swagger:response updateUserNotFound

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

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 (o *UpdateUserParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error