This commit is contained in:
Florian Hoss 2023-07-04 11:51:13 +02:00
commit f90fdc0598
99 changed files with 15260 additions and 0 deletions

124
service/bill.go Normal file
View file

@ -0,0 +1,124 @@
package service
import (
"cafe/config"
"cafe/types"
"fmt"
"strconv"
"time"
)
type (
Bill struct {
ID uint64 `gorm:"primaryKey" json:"id" validate:"optional"`
TableID uint64 `json:"table_id" validate:"required"`
Total float32 `json:"total" validate:"required"`
CreatedAt int64 `json:"created_at" validate:"optional"`
}
BillItem struct {
ID uint64 `gorm:"primaryKey" json:"id" validate:"optional"`
BillID uint64 `json:"bill_id" validate:"required"`
Description string `json:"description" validate:"required"`
Total float32 `json:"total" validate:"required"`
Price float32 `json:"price" validate:"required"`
Amount uint64 `json:"amount" validate:"required"`
ItemType types.ItemType `json:"item_type" validate:"required"`
}
)
func DoesBillExist(id string) (Bill, error) {
var bill Bill
result := config.Cafe.Database.ORM.Limit(1).Find(&bill, id)
if result.RowsAffected == 0 {
return bill, fmt.Errorf(types.CannotFind.String())
}
return bill, nil
}
func GetAllBillItems(billId uint64) ([]BillItem, error) {
var billItems []BillItem
result := config.Cafe.Database.ORM.Where("bill_id = ?", billId).Find(&billItems)
if result.RowsAffected == 0 {
return billItems, fmt.Errorf(types.CannotFind.String())
}
return billItems, nil
}
func getDate(year string, month string, day string) (time.Time, error) {
yearI, yearErr := strconv.Atoi(year)
if yearErr != nil {
return time.Time{}, fmt.Errorf("jahr " + types.CannotParse.String())
}
monthI, monthErr := strconv.Atoi(month)
if monthErr != nil {
return time.Time{}, fmt.Errorf("monat " + types.CannotParse.String())
}
dayI, dayErr := strconv.Atoi(day)
if dayErr != nil {
return time.Time{}, fmt.Errorf("tag " + types.CannotParse.String())
}
loc, locErr := time.LoadLocation("Local")
if locErr != nil {
return time.Time{}, fmt.Errorf("timezone " + types.CannotParse.String())
}
return time.Date(yearI, time.Month(monthI), dayI, 0, 0, 0, 0, loc), nil
}
func GetAllBills(year string, month string, day string) ([]Bill, error) {
var bills []Bill
today, err := getDate(year, month, day)
if err != nil {
return bills, err
}
beginningOfDay := today.Unix()
endOfDay := today.Add(23 * time.Hour).Add(59 * time.Minute).Add(59 * time.Second).Unix()
config.Cafe.Database.ORM.Where("created_at BETWEEN ? AND ?", beginningOfDay, endOfDay).Order("created_at").Find(&bills)
return bills, nil
}
func CreateBill(options GetOrderOptions) (Bill, error) {
orders := GetAllOrdersForTable(options)
var bill Bill
var total float32 = 0
for _, order := range orders {
total += order.Total
}
bill.TableID = options.TableId
bill.Total = total
err := config.Cafe.Database.ORM.Create(&bill).Error
if err != nil {
return bill, fmt.Errorf(types.CannotCreate.String())
}
for _, order := range orders {
billItem := BillItem{
BillID: bill.ID,
Description: order.OrderItem.Description,
Total: order.Total,
Price: order.OrderItem.Price,
Amount: order.OrderCount,
ItemType: order.OrderItem.ItemType,
}
config.Cafe.Database.ORM.Create(&billItem)
}
ordersToDelete := GetAllOrdersForTable(GetOrderOptions{TableId: options.TableId, Grouped: false, Filter: options.Filter})
err = config.Cafe.Database.ORM.Delete(&ordersToDelete).Error
if err != nil {
return bill, fmt.Errorf(types.CannotDelete.String())
}
LiveCh <- WebSocketMsg{
Type: types.DeleteAll,
Payload: ordersToDelete,
}
return bill, nil
}
func DeleteBill(bill *Bill) error {
err := config.Cafe.Database.ORM.Delete(bill).Error
if err != nil {
return fmt.Errorf(types.CannotDelete.String())
}
billItemsToDelete, _ := GetAllBillItems(bill.ID)
config.Cafe.Database.ORM.Delete(&billItemsToDelete)
return nil
}

169
service/order.go Normal file
View file

@ -0,0 +1,169 @@
package service
import (
"cafe/config"
"cafe/types"
"fmt"
"time"
"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 DoesOrderItemExist(id string) (OrderItem, error) {
var orderItem OrderItem
result := config.Cafe.Database.ORM.Limit(1).Find(&orderItem, id)
if result.RowsAffected == 0 {
return orderItem, fmt.Errorf(types.CannotFind.String())
}
return orderItem, nil
}
func DoesOrderExist(id string) (Order, error) {
var order Order
result := config.Cafe.Database.ORM.Limit(1).Find(&order, id)
if result.RowsAffected == 0 {
return order, fmt.Errorf(types.CannotFind.String())
}
return order, nil
}
func GetAllActiveOrders() []Order {
var orders []Order
config.Cafe.Database.ORM.Model(&Order{}).Joins("OrderItem").Where("is_served = ?", 0).Order("updated_at").Find(&orders)
return orders
}
func GetAllOrdersForTable(options GetOrderOptions) []Order {
var orders []Order
if options.Grouped {
if len(options.Filter) == 0 {
config.Cafe.Database.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 {
config.Cafe.Database.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 {
config.Cafe.Database.ORM.Model(&Order{}).Joins("OrderItem").Where("table_id = ?", options.TableId).Order("item_type, description").Find(&orders)
} else {
config.Cafe.Database.ORM.Model(&Order{}).Find(&orders, options.Filter).Where("table_id = ?", options.TableId).Find(&orders)
}
}
return orders
}
func CreateOrder(order *Order) error {
err := config.Cafe.Database.ORM.Create(order).Error
if err != nil {
return fmt.Errorf(types.CannotCreate.String())
}
config.Cafe.Database.ORM.Model(&Order{}).Joins("OrderItem").First(order)
LiveCh <- WebSocketMsg{
Type: types.Create,
Payload: []Order{*order},
}
return nil
}
func UpdateOrder(old *Order, new *Order) error {
err := config.Cafe.Database.ORM.First(old).Updates(new).Error
if err != nil {
return fmt.Errorf(types.CannotUpdate.String())
}
if new.IsServed {
LiveCh <- WebSocketMsg{
Type: types.Delete,
Payload: []Order{*new},
}
}
return nil
}
func DeleteOrder(tableId string, orderItemId string) error {
var order Order
err := config.Cafe.Database.ORM.Where("table_id = ? AND order_item_id = ?", tableId, orderItemId).Last(&order).Error
if err != nil {
return fmt.Errorf(types.CannotFind.String())
}
err = config.Cafe.Database.ORM.Delete(&order).Error
if err != nil {
return fmt.Errorf(types.CannotDelete.String())
}
LiveCh <- WebSocketMsg{
Type: types.Delete,
Payload: []Order{order},
}
return nil
}
func GetOrderItemsForType(itemType string) []OrderItem {
var orderItems []OrderItem
config.Cafe.Database.ORM.Order("description").Where("item_type = ?", types.ParseItemType(itemType)).Find(&orderItems)
return orderItems
}
func CreateOrderItem(oderItem *OrderItem) error {
err := config.Cafe.Database.ORM.Create(oderItem).Error
if err != nil {
return fmt.Errorf(types.CannotCreate.String())
}
return nil
}
func UpdateOrderItem(old *OrderItem, new *OrderItem) error {
err := config.Cafe.Database.ORM.First(old).Updates(new).Error
if err != nil {
return fmt.Errorf(types.CannotUpdate.String())
}
return nil
}
func DeleteOrderItem(oderItem *OrderItem) error {
err := config.Cafe.Database.ORM.Delete(oderItem).Error
if err != nil {
return fmt.Errorf(types.CannotDelete.String())
}
return nil
}

18
service/service.go Normal file
View file

@ -0,0 +1,18 @@
package service
import (
"cafe/types"
)
type (
WebSocketMsg struct {
Type types.NotifierType `json:"type"`
Payload []Order `json:"payload"`
}
)
var LiveCh chan WebSocketMsg
func Initialize() {
LiveCh = make(chan WebSocketMsg)
}

75
service/table.go Normal file
View file

@ -0,0 +1,75 @@
package service
import (
"cafe/config"
"cafe/types"
"fmt"
"gorm.io/plugin/soft_delete"
)
type Table struct {
ID uint64 `gorm:"primaryKey" json:"id" validate:"optional"`
OrderCount uint64 `json:"order_count" validate:"required"`
Total float32 `json:"total" validate:"required"`
UpdatedAt int64 `json:"updated_at" validate:"optional"`
IsDeleted soft_delete.DeletedAt `gorm:"softDelete:flag" json:"is_deleted" swaggerignore:"true"`
}
func GetAllTables() []Table {
var tables []Table
config.Cafe.Database.ORM.Model(
&Table{},
).Joins(
"left join orders on tables.id = orders.table_id",
).Joins(
"left join order_items on orders.order_item_id = order_items.id",
).Select(
"tables.id, tables.updated_at, sum(order_items.price) as total, count(orders.id) as order_count",
).Group(
"tables.id",
).Order("tables.id").Find(&tables)
return tables
}
func CreateNewTable() (Table, error) {
var table Table
var err error
result := config.Cafe.Database.ORM.Unscoped().Where("is_deleted = ?", 1).Limit(1).Find(&table)
if result.RowsAffected == 0 {
err = config.Cafe.Database.ORM.Create(&table).Error
} else {
table.IsDeleted = 0
err = config.Cafe.Database.ORM.Unscoped().Save(&table).Error
}
if err != nil {
return table, fmt.Errorf(types.CannotCreate.String())
}
return table, nil
}
func DeleteLatestTable() error {
var table Table
err := config.Cafe.Database.ORM.Model(
&Table{},
).Joins(
"left join orders on tables.id = orders.table_id",
).Joins(
"left join order_items on orders.order_item_id = order_items.id",
).Select(
"tables.id, count(orders.id) as order_count",
).Group(
"tables.id",
).Last(&table).Error
if err != nil {
return fmt.Errorf(types.CannotFind.String())
}
if table.OrderCount != 0 {
return fmt.Errorf(types.StillInUse.String())
}
err = config.Cafe.Database.ORM.Delete(&table).Error
if err != nil {
return fmt.Errorf(types.CannotDelete.String())
}
return nil
}