cafe-plaetschwiesle/internal/controller/order.go

package controller

import (
	"fmt"
	"time"

	"gitlab.unjx.de/flohoss/cafe-plaetschwiesle/internal/types"
	"gorm.io/gorm"
)

type (
	Order struct {
		ID          uint64    `gorm:"primaryKey" json:"id" validate:"optional"`
		TableID     uint64    `json:"table_id" validate:"required"`
		OrderItemID uint64    `json:"order_item_id" validate:"required"`
		OrderItem   OrderItem `json:"order_item" validate:"required"`
		UpdatedAt   int64     `json:"updated_at" validate:"optional"`
		IsServed    bool      `json:"is_served" default:"false" validate:"required"`
		Total       float32   `json:"total" validate:"required"`
		OrderCount  uint64    `json:"order_count" validate:"required"`
	}

	OrderItem struct {
		ID          uint64         `gorm:"primaryKey" json:"id" validate:"optional"`
		ItemType    types.ItemType `json:"item_type" validate:"required"`
		Description string         `json:"description" validate:"required"`
		Price       float32        `json:"price" validate:"required"`
	}

	GetOrderOptions struct {
		TableId uint64   `json:"table_id"`
		Grouped bool     `json:"grouped"`
		Filter  []string `json:"filter"`
	}
)

func updateTableUpdatedAt(tx *gorm.DB, o *Order) {
	var table Table
	tx.Where("id = ?", o.TableID).First(&table)
	table.UpdatedAt = time.Now().Unix()
	tx.Save(&table)
}

func (o *Order) AfterCreate(tx *gorm.DB) (err error) {
	updateTableUpdatedAt(tx, o)
	return
}

func (o *Order) AfterDelete(tx *gorm.DB) (err error) {
	updateTableUpdatedAt(tx, o)
	return
}

func (c *Controller) doesOrderItemExist(id string) (OrderItem, error) {
	var orderItem OrderItem
	result := c.orm.Limit(1).Find(&orderItem, id)
	if result.RowsAffected == 0 {
		return orderItem, fmt.Errorf(types.CannotFind.String())
	}
	return orderItem, nil
}

func (c *Controller) doesOrderExist(id string) (Order, error) {
	var order Order
	result := c.orm.Limit(1).Find(&order, id)
	if result.RowsAffected == 0 {
		return order, fmt.Errorf(types.CannotFind.String())
	}
	return order, nil
}

func (c *Controller) getAllActiveOrders() []Order {
	var orders []Order
	c.orm.Model(&Order{}).Joins("OrderItem").Where("is_served = ?", 0).Order("updated_at").Find(&orders)
	return orders
}

func (c *Controller) getAllOrdersForTable(options GetOrderOptions) []Order {
	var orders []Order
	if options.Grouped {
		if len(options.Filter) == 0 {
			c.orm.Model(&Order{}).Joins("OrderItem").Select("table_id, order_item_id, sum(price) as total, count(order_item_id) as order_count").Group("order_item_id").Where("table_id = ?", options.TableId).Order("item_type, description").Find(&orders)
		} else {
			c.orm.Model(&Order{}).Find(&orders, options.Filter).Joins("OrderItem").Select("table_id, order_item_id, sum(price) as total, count(order_item_id) as order_count").Group("order_item_id").Where("table_id = ?", options.TableId).Order("item_type, description").Find(&orders)
		}
	} else {
		if len(options.Filter) == 0 {
			c.orm.Model(&Order{}).Joins("OrderItem").Where("table_id = ?", options.TableId).Order("item_type, description").Find(&orders)
		} else {
			c.orm.Model(&Order{}).Find(&orders, options.Filter).Where("table_id = ?", options.TableId).Find(&orders)
		}
	}
	return orders
}

func (c *Controller) createOrder(order *Order) error {
	err := c.orm.Create(order).Error
	if err != nil {
		return fmt.Errorf(types.CannotCreate.String())
	}
	c.orm.Model(&Order{}).Joins("OrderItem").First(order)
	c.publishMessage(StatusMessage{
		Type:    types.Create,
		Payload: []Order{*order},
	})
	return nil
}

func (c *Controller) updateOrder(old *Order, new *Order) error {
	err := c.orm.First(old).Updates(new).Error
	if err != nil {
		return fmt.Errorf(types.CannotUpdate.String())
	}
	if new.IsServed {
		c.publishMessage(StatusMessage{
			Type:    types.Delete,
			Payload: []Order{*new},
		})
	}
	return nil
}

func (c *Controller) deleteOrder(tableId string, orderItemId string) error {
	var order Order
	err := c.orm.Where("table_id = ? AND order_item_id = ?", tableId, orderItemId).Last(&order).Error
	if err != nil {
		return fmt.Errorf(types.CannotFind.String())
	}
	err = c.orm.Delete(&order).Error
	if err != nil {
		return fmt.Errorf(types.CannotDelete.String())
	}
	c.publishMessage(StatusMessage{
		Type:    types.Delete,
		Payload: []Order{order},
	})
	return nil
}

func (c *Controller) getOrderItemsForType(itemType string) []OrderItem {
	var orderItems []OrderItem
	c.orm.Order("description").Where("item_type = ?", types.ParseItemType(itemType)).Find(&orderItems)
	return orderItems
}

func (c *Controller) createOrderItem(oderItem *OrderItem) error {
	err := c.orm.Create(oderItem).Error
	if err != nil {
		return fmt.Errorf(types.CannotCreate.String())
	}
	return nil
}

func (c *Controller) updateOrderItem(old *OrderItem, new *OrderItem) error {
	err := c.orm.First(old).Updates(new).Error
	if err != nil {
		return fmt.Errorf(types.CannotUpdate.String())
	}
	return nil
}

func (c *Controller) deleteOrderItem(oderItem *OrderItem) error {
	err := c.orm.Delete(oderItem).Error
	if err != nil {
		return fmt.Errorf(types.CannotDelete.String())
	}
	return nil
}