258 lines
7.1 KiB
Go
258 lines
7.1 KiB
Go
package api
|
|
|
|
import (
|
|
"cafe/hub"
|
|
"cafe/service"
|
|
"cafe/types"
|
|
ws "cafe/websocket"
|
|
"net/http"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
"github.com/gorilla/websocket"
|
|
"github.com/sirupsen/logrus"
|
|
)
|
|
|
|
// @Schemes
|
|
// @Summary get all orders
|
|
// @Description gets all orders as array
|
|
// @Tags orders
|
|
// @Produce json
|
|
// @Param table query int false "Table ID"
|
|
// @Param grouping query bool false "grouping"
|
|
// @Param filter query string false "filter"
|
|
// @Success 200 {array} service.Order
|
|
// @Router /orders [get]
|
|
func (a *Api) getOrders(c *gin.Context) {
|
|
table, _ := strconv.ParseUint(c.Query("table"), 10, 64)
|
|
grouping, _ := strconv.ParseBool(c.Query("grouping"))
|
|
stringFiler, filterPresent := c.GetQuery("filter")
|
|
var filter []string
|
|
if filterPresent {
|
|
filter = strings.Split(stringFiler, ",")
|
|
}
|
|
options := service.GetOrderOptions{TableId: table, Grouped: grouping, Filter: filter}
|
|
var orders []service.Order
|
|
if options.TableId == 0 {
|
|
orders = service.GetAllActiveOrders()
|
|
} else {
|
|
orders = service.GetAllOrdersForTable(options)
|
|
}
|
|
c.JSON(http.StatusOK, orders)
|
|
}
|
|
|
|
// @Schemes
|
|
// @Summary create new order
|
|
// @Description creates a new order and returns it
|
|
// @Tags orders
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Param item query int true "OrderItem ID"
|
|
// @Param table query int true "Table ID"
|
|
// @Success 201 {object} service.Order
|
|
// @Failure 400 {object} errorResponse
|
|
// @Failure 500 {object} errorResponse
|
|
// @Router /orders [post]
|
|
func (a *Api) createOrder(c *gin.Context) {
|
|
table, err1 := strconv.ParseUint(c.Query("table"), 10, 64)
|
|
item, err2 := strconv.ParseUint(c.Query("item"), 10, 64)
|
|
if err1 != nil || err2 != nil {
|
|
c.JSON(http.StatusBadRequest, errorResponse{types.MissingInformation.String()})
|
|
return
|
|
}
|
|
order := service.Order{TableID: table, OrderItemID: item, IsServed: false}
|
|
err := service.CreateOrder(&order)
|
|
if err != nil {
|
|
c.JSON(http.StatusInternalServerError, errorResponse{err.Error()})
|
|
} else {
|
|
c.JSON(http.StatusCreated, order)
|
|
}
|
|
}
|
|
|
|
// @Schemes
|
|
// @Summary delete an order
|
|
// @Description deletes an order from the database
|
|
// @Tags orders
|
|
// @Produce json
|
|
// @Param item query int true "OrderItem ID"
|
|
// @Param table query int true "Table ID"
|
|
// @Success 200 "OK"
|
|
// @Failure 400 {object} errorResponse
|
|
// @Failure 500 {object} errorResponse
|
|
// @Router /orders [delete]
|
|
func (a *Api) deleteOrder(c *gin.Context) {
|
|
item := c.Query("item")
|
|
table := c.Query("table")
|
|
if table == "" || item == "" {
|
|
c.JSON(http.StatusBadRequest, errorResponse{types.MissingInformation.String()})
|
|
return
|
|
}
|
|
err := service.DeleteOrder(table, item)
|
|
if err != nil {
|
|
c.JSON(http.StatusInternalServerError, errorResponse{err.Error()})
|
|
} else {
|
|
c.Status(http.StatusOK)
|
|
}
|
|
}
|
|
|
|
// @Schemes
|
|
// @Summary update an order
|
|
// @Description updates an order with provided information
|
|
// @Tags orders
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Param order body service.Order true "updated Order"
|
|
// @Success 200 {object} service.Order
|
|
// @Failure 400 {object} errorResponse
|
|
// @Failure 404 "Not Found" errorResponse
|
|
// @Failure 500 {object} errorResponse
|
|
// @Router /orders [put]
|
|
func (a *Api) updateOrder(c *gin.Context) {
|
|
var newOrder service.Order
|
|
err := c.ShouldBindJSON(&newOrder)
|
|
if err != nil {
|
|
c.JSON(http.StatusBadRequest, errorResponse{types.MissingInformation.String()})
|
|
return
|
|
}
|
|
oldOrder, err := service.DoesOrderExist(strconv.Itoa(int(newOrder.ID)))
|
|
if err != nil {
|
|
c.JSON(http.StatusNotFound, errorResponse{err.Error()})
|
|
return
|
|
}
|
|
err = service.UpdateOrder(&oldOrder, &newOrder)
|
|
if err != nil {
|
|
c.JSON(http.StatusInternalServerError, errorResponse{err.Error()})
|
|
} else {
|
|
c.JSON(http.StatusOK, newOrder)
|
|
}
|
|
}
|
|
|
|
func (a *Api) serveWs(c *gin.Context) {
|
|
conn, err := ws.Upgrader.Upgrade(c.Writer, c.Request, nil)
|
|
if err != nil {
|
|
logrus.WithField("error", err).Warning("Cannot upgrade websocket")
|
|
return
|
|
}
|
|
messageChan := make(hub.NotifierChan)
|
|
a.Hub.NewClients <- messageChan
|
|
defer func() {
|
|
a.Hub.ClosingClients <- messageChan
|
|
conn.Close()
|
|
}()
|
|
go ws.ReadPump(conn)
|
|
for {
|
|
msg, ok := <-messageChan
|
|
if !ok {
|
|
err := conn.WriteMessage(websocket.CloseMessage, []byte{})
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
err := conn.WriteJSON(msg)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
// @Schemes
|
|
// @Summary get all orderItems
|
|
// @Description gets all orderItems as array
|
|
// @Tags orderItems
|
|
// @Produce json
|
|
// @Param type query int true "ItemType"
|
|
// @Success 200 {array} service.OrderItem
|
|
// @Router /orders/items [get]
|
|
func (a *Api) getOrderItems(c *gin.Context) {
|
|
orderType := c.Query("type")
|
|
if orderType == "" {
|
|
c.JSON(http.StatusBadRequest, errorResponse{types.MissingInformation.String()})
|
|
} else {
|
|
c.JSON(http.StatusOK, service.GetOrderItemsForType(orderType))
|
|
}
|
|
}
|
|
|
|
// @Schemes
|
|
// @Summary create new orderItem
|
|
// @Description creates a new orderItem and returns it
|
|
// @Tags orderItems
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Param order body service.OrderItem true "OrderItem ID"
|
|
// @Success 201 {object} service.OrderItem
|
|
// @Failure 400 {object} errorResponse
|
|
// @Failure 500 {object} errorResponse
|
|
// @Router /orders/items [post]
|
|
func (a *Api) createOrderItem(c *gin.Context) {
|
|
var orderItem service.OrderItem
|
|
err := c.ShouldBindJSON(&orderItem)
|
|
if err != nil {
|
|
c.JSON(http.StatusBadRequest, errorResponse{types.MissingInformation.String()})
|
|
return
|
|
}
|
|
err = service.CreateOrderItem(&orderItem)
|
|
if err != nil {
|
|
c.JSON(http.StatusInternalServerError, errorResponse{err.Error()})
|
|
} else {
|
|
c.JSON(http.StatusCreated, orderItem)
|
|
}
|
|
}
|
|
|
|
// @Schemes
|
|
// @Summary update a orderItem
|
|
// @Description updates a orderItem with provided information
|
|
// @Tags orderItems
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Param orderItem body service.OrderItem true "updated OrderItem"
|
|
// @Success 200 {object} service.OrderItem
|
|
// @Failure 400 {object} errorResponse
|
|
// @Failure 404 "Not Found" errorResponse
|
|
// @Failure 500 {object} errorResponse
|
|
// @Router /orders/items [put]
|
|
func (a *Api) updateOrderItem(c *gin.Context) {
|
|
var newOrderItem service.OrderItem
|
|
err := c.ShouldBindJSON(&newOrderItem)
|
|
if err != nil {
|
|
c.JSON(http.StatusBadRequest, errorResponse{types.MissingInformation.String()})
|
|
return
|
|
}
|
|
oldOrderItem, err := service.DoesOrderItemExist(strconv.Itoa(int(newOrderItem.ID)))
|
|
if err != nil {
|
|
c.JSON(http.StatusNotFound, errorResponse{err.Error()})
|
|
return
|
|
}
|
|
err = service.UpdateOrderItem(&oldOrderItem, &newOrderItem)
|
|
if err != nil {
|
|
c.JSON(http.StatusInternalServerError, errorResponse{err.Error()})
|
|
} else {
|
|
c.JSON(http.StatusOK, newOrderItem)
|
|
}
|
|
}
|
|
|
|
// @Schemes
|
|
// @Summary delete an orderItem
|
|
// @Description deletes an orderItem from the database
|
|
// @Tags orderItems
|
|
// @Produce json
|
|
// @Param id path int true "OrderItem ID"
|
|
// @Success 200 "OK"
|
|
// @Failure 404 "Not Found"
|
|
// @Failure 500 {object} errorResponse
|
|
// @Router /orders/items/{id} [delete]
|
|
func (a *Api) deleteOrderItem(c *gin.Context) {
|
|
id := c.Param("id")
|
|
orderItem, err := service.DoesOrderItemExist(id)
|
|
if err != nil {
|
|
c.JSON(http.StatusNotFound, errorResponse{err.Error()})
|
|
return
|
|
}
|
|
err = service.DeleteOrderItem(&orderItem)
|
|
if err != nil {
|
|
c.JSON(http.StatusInternalServerError, errorResponse{err.Error()})
|
|
} else {
|
|
c.Status(http.StatusOK)
|
|
}
|
|
}
|