b2b/app/repos/ordersRepo/ordersRepo.go

package ordersRepo

import (
	"git.ma-al.com/goc_daniel/b2b/app/db"
	"git.ma-al.com/goc_daniel/b2b/app/model"
	"git.ma-al.com/goc_daniel/b2b/app/model/enums"
	"git.ma-al.com/goc_daniel/b2b/app/utils/query/filters"
	"git.ma-al.com/goc_daniel/b2b/app/utils/query/find"
)

type UIOrdersRepo interface {
	UserHasOrder(user_id uint, order_id uint) (bool, error)
	Get(orderId uint) (*model.CustomerOrder, error)
	Find(user_id uint, p find.Paging, filt *filters.FiltersList) (*find.Found[model.CustomerOrder], error)
	PlaceNewOrder(cart *model.CustomerCart, name string, country_id uint, address_info string, originalUserId uint) (*model.CustomerOrder, error)
	ChangeOrderAddress(order_id uint, country_id uint, address_info string) error
	ChangeOrderStatus(orderId uint, newStatus enums.OrderStatus, userId uint) error
	GetOrderStatus(orderID uint) (enums.OrderStatus, error)
}

type OrdersRepo struct{}

func New() UIOrdersRepo {
	return &OrdersRepo{}
}

func (repo *OrdersRepo) UserHasOrder(user_id uint, order_id uint) (bool, error) {
	var amt uint

	err := db.DB.
		Table("b2b_customer_orders").
		Select("COUNT(*) AS amt").
		Where("user_id = ? AND order_id = ?", user_id, order_id).
		Scan(&amt).
		Error

	return amt >= 1, err
}

func (repo *OrdersRepo) Get(orderId uint) (*model.CustomerOrder, error) {
	var order model.CustomerOrder

	err := db.Get().
		Model(&model.CustomerOrder{}).
		Preload("Products").
		Where("order_id = ?", orderId).
		First(&order).Error

	return &order, err
}

func (repo *OrdersRepo) Find(user_id uint, p find.Paging, filt *filters.FiltersList) (*find.Found[model.CustomerOrder], error) {
	var list []model.CustomerOrder
	var total int64

	query := db.Get().
		Model(&model.CustomerOrder{}).
		Preload("Products").
		Order("b2b_customer_orders.order_id DESC")

	// Apply all filters
	if filt != nil {
		filt.ApplyAll(query)
	}

	//  run counter first as query is without limit and offset
	err := query.Count(&total).Error
	if err != nil {
		return &find.Found[model.CustomerOrder]{}, err
	}

	err = query.
		Limit(p.Limit()).
		Offset(p.Offset()).
		Find(&list).Error
	if err != nil {
		return &find.Found[model.CustomerOrder]{}, err
	}

	return &find.Found[model.CustomerOrder]{
		Items: list,
		Count: uint(total),
	}, nil
}

func (repo *OrdersRepo) PlaceNewOrder(cart *model.CustomerCart, name string, country_id uint, address_info string, originalUserId uint) (*model.CustomerOrder, error) {
	order := model.CustomerOrder{
		UserID:        cart.UserID,
		Name:          name,
		CountryID:     country_id,
		AddressString: address_info,
		Status:        enums.OrderStatusPending,
		Products:      make([]model.OrderProduct, 0, len(cart.Products)),
	}

	for _, product := range cart.Products {
		order.Products = append(order.Products, model.OrderProduct{
			ProductID:          product.ProductID,
			ProductAttributeID: product.ProductAttributeID,
			Amount:             product.Amount,
		})
	}
	tx := db.Get().Begin()
	err := tx.Create(&order).Error
	if err != nil {
		tx.Rollback()
		return nil, err
	}
	history := model.OrderStatusHistory{
		OrderId:   order.OrderID,
		OldStatus: nil,
		NewStatus: enums.OrderStatusPending,
		UserId:    originalUserId,
	}

	err = tx.Create(&history).Error
	if err != nil {
		tx.Rollback()
		return nil, err
	}
	err = tx.Commit().Error
	if err != nil {
		return nil, err
	}

	return &order, nil
}

func (repo *OrdersRepo) ChangeOrderAddress(order_id uint, country_id uint, address_info string) error {
	return db.DB.
		Table("b2b_customer_orders").
		Where("order_id = ?", order_id).
		Updates(map[string]interface{}{
			"country_id":     country_id,
			"address_string": address_info,
		}).
		Error
}

func (repo *OrdersRepo) ChangeOrderStatus(orderID uint, newStatus enums.OrderStatus, userId uint) error {
	tx := db.Get().Begin()

	var currentStatus enums.OrderStatus
	err := tx.Table("b2b_customer_orders").
		Select("status").
		Where("order_id = ?", orderID).
		Scan(&currentStatus).Error
	if err != nil {
		tx.Rollback()
		return err
	}

	err = tx.Table("b2b_customer_orders").
		Where("order_id = ?", orderID).
		Update("status", string(newStatus)).Error
	if err != nil {
		tx.Rollback()
		return err
	}

	history := model.OrderStatusHistory{
		OrderId:   orderID,
		OldStatus: &currentStatus,
		NewStatus: newStatus,
		UserId:    userId,
	}

	err = tx.Create(&history).Error
	if err != nil {
		tx.Rollback()
		return err
	}

	return tx.Commit().Error
}

func (repo *OrdersRepo) GetOrderStatus(orderID uint) (enums.OrderStatus, error) {
	var status enums.OrderStatus
	err := db.DB.Table("b2b_customer_orders").
		Select("status").
		Where("order_id = ?", orderID).
		Scan(&status).Error
	return status, err
}