store

type DeleteOrder ¶

type DeleteOrder struct {
	Context *middleware.Context
	Params  DeleteOrderParams
	Handler DeleteOrderHandler
}

DeleteOrder swagger:route DELETE /store/order/{orderId} store deleteOrder

Delete purchase order by ID ¶

For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors

func NewDeleteOrder(ctx *middleware.Context, handler DeleteOrderHandler) *DeleteOrder

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

type DeleteOrderBadRequest ¶

type DeleteOrderBadRequest struct {
}

DeleteOrderBadRequest Invalid ID supplied

swagger:response deleteOrderBadRequest

func NewDeleteOrderBadRequest() DeleteOrderBadRequest

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

type DeleteOrderHandler ¶

type DeleteOrderHandler interface {
	Handle(DeleteOrderParams) middleware.Responder
}

DeleteOrderHandler interface for that can handle valid delete order params

type DeleteOrderHandlerFunc ¶

type DeleteOrderHandlerFunc func(DeleteOrderParams) middleware.Responder

DeleteOrderHandlerFunc turns a function with the right signature into a delete order handler

func (fn DeleteOrderHandlerFunc) Handle(params DeleteOrderParams) middleware.Responder

type DeleteOrderNotFound ¶

type DeleteOrderNotFound struct {
}

DeleteOrderNotFound Order not found

swagger:response deleteOrderNotFound

func NewDeleteOrderNotFound() DeleteOrderNotFound

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

type DeleteOrderParams ¶

type DeleteOrderParams struct {
	/*ID of the order that needs to be deleted
	  Required: true
	  Min Length: 1
	  In: path
	*/
	OrderID string
}

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

swagger:parameters deleteOrder

func NewDeleteOrderParams() DeleteOrderParams

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

type GetInventory ¶ added in v0.2.0

type GetInventory struct {
	Context *middleware.Context
	Handler GetInventoryHandler
}

GetInventory swagger:route GET /store/inventory store getInventory

Returns pet inventories by status ¶

Returns a map of status codes to quantities

func NewGetInventory(ctx *middleware.Context, handler GetInventoryHandler) *GetInventory

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

type GetInventoryHandler ¶ added in v0.2.0

type GetInventoryHandler interface {
	Handle(interface{}) middleware.Responder
}

GetInventoryHandler interface for that can handle valid get inventory params

type GetInventoryHandlerFunc ¶ added in v0.2.0

type GetInventoryHandlerFunc func(interface{}) middleware.Responder

GetInventoryHandlerFunc turns a function with the right signature into a get inventory handler

func (fn GetInventoryHandlerFunc) Handle(principal interface{}) middleware.Responder

type GetInventoryOK ¶ added in v0.2.0

type GetInventoryOK struct {

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

GetInventoryOK successful operation

swagger:response getInventoryOK

func NewGetInventoryOK() GetInventoryOK

func (o *GetInventoryOK) WithPayload(payload GetInventoryOKBodyBody) *GetInventoryOK

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

type GetInventoryOKBodyBody ¶ added in v0.2.0

type GetInventoryOKBodyBody map[string]int32

GetInventoryOKBodyBody get inventory o k body body

swagger:model GetInventoryOKBodyBody

func (o GetInventoryOKBodyBody) Validate(formats strfmt.Registry) error

type GetOrderByID ¶

type GetOrderByID struct {
	Context *middleware.Context
	Params  GetOrderByIDParams
	Handler GetOrderByIDHandler
}

GetOrderByID swagger:route GET /store/order/{orderId} store getOrderById

Find purchase order by ID ¶

For valid response try integer IDs with value <= 5 or > 10. Other values will generated exceptions

func NewGetOrderByID(ctx *middleware.Context, handler GetOrderByIDHandler) *GetOrderByID

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

type GetOrderByIDBadRequest ¶

type GetOrderByIDBadRequest struct {
}

GetOrderByIDBadRequest Invalid ID supplied

swagger:response getOrderByIdBadRequest

func NewGetOrderByIDBadRequest() GetOrderByIDBadRequest

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

type GetOrderByIDHandler ¶

type GetOrderByIDHandler interface {
	Handle(GetOrderByIDParams) middleware.Responder
}

GetOrderByIDHandler interface for that can handle valid get order by id params

type GetOrderByIDHandlerFunc ¶

type GetOrderByIDHandlerFunc func(GetOrderByIDParams) middleware.Responder

GetOrderByIDHandlerFunc turns a function with the right signature into a get order by id handler

func (fn GetOrderByIDHandlerFunc) Handle(params GetOrderByIDParams) middleware.Responder

type GetOrderByIDNotFound ¶

type GetOrderByIDNotFound struct {
}

GetOrderByIDNotFound Order not found

swagger:response getOrderByIdNotFound

func NewGetOrderByIDNotFound() GetOrderByIDNotFound

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

type GetOrderByIDOK ¶

type GetOrderByIDOK struct {

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

GetOrderByIDOK successful operation

swagger:response getOrderByIdOK

func NewGetOrderByIDOK() GetOrderByIDOK

func (o *GetOrderByIDOK) WithPayload(payload *models.Order) *GetOrderByIDOK

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

type GetOrderByIDParams ¶

type GetOrderByIDParams struct {
	/*ID of pet that needs to be fetched
	  Required: true
	  Maximum: 5
	  Minimum: 1
	  In: path
	*/
	OrderID int64
}

GetOrderByIDParams contains all the bound params for the get order by id operation typically these are obtained from a http.Request

swagger:parameters getOrderById

func NewGetOrderByIDParams() GetOrderByIDParams

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

type PlaceOrder ¶

type PlaceOrder struct {
	Context *middleware.Context
	Params  PlaceOrderParams
	Handler PlaceOrderHandler
}

PlaceOrder swagger:route POST /store/order store placeOrder

Place an order for a pet

func NewPlaceOrder(ctx *middleware.Context, handler PlaceOrderHandler) *PlaceOrder

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

type PlaceOrderBadRequest ¶

type PlaceOrderBadRequest struct {
}

PlaceOrderBadRequest Invalid Order

swagger:response placeOrderBadRequest

func NewPlaceOrderBadRequest() PlaceOrderBadRequest

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

type PlaceOrderHandler ¶

type PlaceOrderHandler interface {
	Handle(PlaceOrderParams) middleware.Responder
}

PlaceOrderHandler interface for that can handle valid place order params

type PlaceOrderHandlerFunc ¶

type PlaceOrderHandlerFunc func(PlaceOrderParams) middleware.Responder

PlaceOrderHandlerFunc turns a function with the right signature into a place order handler

func (fn PlaceOrderHandlerFunc) Handle(params PlaceOrderParams) middleware.Responder

type PlaceOrderOK ¶

type PlaceOrderOK struct {

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

PlaceOrderOK successful operation

swagger:response placeOrderOK

func NewPlaceOrderOK() PlaceOrderOK

func (o *PlaceOrderOK) WithPayload(payload *models.Order) *PlaceOrderOK

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

type PlaceOrderParams ¶

type PlaceOrderParams struct {
	/*order placed for purchasing the pet
	  Required: true
	  In: body
	*/
	Body *models.Order
}

PlaceOrderParams contains all the bound params for the place order operation typically these are obtained from a http.Request

swagger:parameters placeOrder

func NewPlaceOrderParams() PlaceOrderParams

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