init

internal/repository/inventory_movement_repository.go

@@ -0,0 +1,185 @@
+package repository
+
+import (
+	"context"
+
+	"apskel-pos-be/internal/entities"
+
+	"github.com/google/uuid"
+	"gorm.io/gorm"
+)
+
+type InventoryMovementRepository interface {
+	Create(ctx context.Context, movement *entities.InventoryMovement) error
+	GetByID(ctx context.Context, id uuid.UUID) (*entities.InventoryMovement, error)
+	GetWithRelations(ctx context.Context, id uuid.UUID) (*entities.InventoryMovement, error)
+	List(ctx context.Context, filters map[string]interface{}, limit, offset int) ([]*entities.InventoryMovement, int64, error)
+	GetByProductAndOutlet(ctx context.Context, productID, outletID uuid.UUID, limit, offset int) ([]*entities.InventoryMovement, int64, error)
+	GetByOrderID(ctx context.Context, orderID uuid.UUID) ([]*entities.InventoryMovement, error)
+	GetByPaymentID(ctx context.Context, paymentID uuid.UUID) ([]*entities.InventoryMovement, error)
+	Count(ctx context.Context, filters map[string]interface{}) (int64, error)
+	CreateWithTransaction(tx *gorm.DB, movement *entities.InventoryMovement) error
+}
+
+type InventoryMovementRepositoryImpl struct {
+	db *gorm.DB
+}
+
+func NewInventoryMovementRepositoryImpl(db *gorm.DB) *InventoryMovementRepositoryImpl {
+	return &InventoryMovementRepositoryImpl{
+		db: db,
+	}
+}
+
+func (r *InventoryMovementRepositoryImpl) Create(ctx context.Context, movement *entities.InventoryMovement) error {
+	return r.db.WithContext(ctx).Create(movement).Error
+}
+
+func (r *InventoryMovementRepositoryImpl) CreateWithTransaction(tx *gorm.DB, movement *entities.InventoryMovement) error {
+	return tx.Create(movement).Error
+}
+
+func (r *InventoryMovementRepositoryImpl) GetByID(ctx context.Context, id uuid.UUID) (*entities.InventoryMovement, error) {
+	var movement entities.InventoryMovement
+	err := r.db.WithContext(ctx).First(&movement, "id = ?", id).Error
+	if err != nil {
+		return nil, err
+	}
+	return &movement, nil
+}
+
+func (r *InventoryMovementRepositoryImpl) GetWithRelations(ctx context.Context, id uuid.UUID) (*entities.InventoryMovement, error) {
+	var movement entities.InventoryMovement
+	err := r.db.WithContext(ctx).
+		Preload("Organization").
+		Preload("Outlet").
+		Preload("Product").
+		Preload("Product.Category").
+		Preload("Order").
+		Preload("Payment").
+		Preload("User").
+		First(&movement, "id = ?", id).Error
+	if err != nil {
+		return nil, err
+	}
+	return &movement, nil
+}
+
+func (r *InventoryMovementRepositoryImpl) List(ctx context.Context, filters map[string]interface{}, limit, offset int) ([]*entities.InventoryMovement, int64, error) {
+	var movements []*entities.InventoryMovement
+	var total int64
+
+	query := r.db.WithContext(ctx).Model(&entities.InventoryMovement{}).
+		Preload("Product").
+		Preload("Product.Category").
+		Preload("Outlet").
+		Preload("Order").
+		Preload("Payment").
+		Preload("User")
+
+	for key, value := range filters {
+		switch key {
+		case "search":
+			searchValue := "%" + value.(string) + "%"
+			query = query.Joins("JOIN products ON inventory_movements.product_id = products.id").
+				Where("products.name ILIKE ? OR inventory_movements.reason ILIKE ?", searchValue, searchValue)
+		case "date_from":
+			query = query.Where("created_at >= ?", value)
+		case "date_to":
+			query = query.Where("created_at <= ?", value)
+		case "movement_type":
+			query = query.Where("movement_type = ?", value)
+		case "reference_type":
+			query = query.Where("reference_type = ?", value)
+		default:
+			query = query.Where(key+" = ?", value)
+		}
+	}
+
+	if err := query.Count(&total).Error; err != nil {
+		return nil, 0, err
+	}
+
+	err := query.Order("created_at DESC").Limit(limit).Offset(offset).Find(&movements).Error
+	return movements, total, err
+}
+
+func (r *InventoryMovementRepositoryImpl) GetByProductAndOutlet(ctx context.Context, productID, outletID uuid.UUID, limit, offset int) ([]*entities.InventoryMovement, int64, error) {
+	var movements []*entities.InventoryMovement
+	var total int64
+
+	query := r.db.WithContext(ctx).Model(&entities.InventoryMovement{}).
+		Preload("Product").
+		Preload("Product.Category").
+		Preload("Order").
+		Preload("Payment").
+		Preload("User").
+		Where("product_id = ? AND outlet_id = ?", productID, outletID)
+
+	if err := query.Count(&total).Error; err != nil {
+		return nil, 0, err
+	}
+
+	err := query.Order("created_at DESC").Limit(limit).Offset(offset).Find(&movements).Error
+	return movements, total, err
+}
+
+func (r *InventoryMovementRepositoryImpl) GetByOrderID(ctx context.Context, orderID uuid.UUID) ([]*entities.InventoryMovement, error) {
+	var movements []*entities.InventoryMovement
+	err := r.db.WithContext(ctx).
+		Preload("Product").
+		Preload("Product.Category").
+		Where("order_id = ?", orderID).
+		Order("created_at DESC").
+		Find(&movements).Error
+	return movements, err
+}
+
+func (r *InventoryMovementRepositoryImpl) GetByPaymentID(ctx context.Context, paymentID uuid.UUID) ([]*entities.InventoryMovement, error) {
+	var movements []*entities.InventoryMovement
+	err := r.db.WithContext(ctx).
+		Preload("Product").
+		Preload("Product.Category").
+		Where("payment_id = ?", paymentID).
+		Order("created_at DESC").
+		Find(&movements).Error
+	return movements, err
+}
+
+func (r *InventoryMovementRepositoryImpl) GetByReference(ctx context.Context, referenceType entities.InventoryMovementReferenceType, referenceID uuid.UUID) ([]*entities.InventoryMovement, error) {
+	var movements []*entities.InventoryMovement
+	err := r.db.WithContext(ctx).
+		Preload("Product").
+		Preload("Product.Category").
+		Where("reference_type = ? AND reference_id = ?", referenceType, referenceID).
+		Order("created_at DESC").
+		Find(&movements).Error
+	return movements, err
+}
+
+func (r *InventoryMovementRepositoryImpl) Count(ctx context.Context, filters map[string]interface{}) (int64, error) {
+	var count int64
+	query := r.db.WithContext(ctx).Model(&entities.InventoryMovement{})
+
+	for key, value := range filters {
+		switch key {
+		case "search":
+			searchValue := "%" + value.(string) + "%"
+			query = query.Joins("JOIN products ON inventory_movements.product_id = products.id").
+				Where("products.name ILIKE ? OR inventory_movements.reason ILIKE ?", searchValue, searchValue)
+		case "date_from":
+			query = query.Where("created_at >= ?", value)
+		case "date_to":
+			query = query.Where("created_at <= ?", value)
+		case "movement_type":
+			query = query.Where("movement_type = ?", value)
+		case "reference_type":
+			query = query.Where("reference_type = ?", value)
+		default:
+			query = query.Where(key+" = ?", value)
+		}
+	}
+
+	err := query.Count(&count).Error
+	return count, err
+}

internal/repository/inventory_repository.go

@@ -11,6 +11,27 @@ import (
 	"gorm.io/gorm"
 )
 
+type InventoryRepository interface {
+	Create(ctx context.Context, inventory *entities.Inventory) error
+	GetByID(ctx context.Context, id uuid.UUID) (*entities.Inventory, error)
+	GetWithRelations(ctx context.Context, id uuid.UUID) (*entities.Inventory, error)
+	GetByProductAndOutlet(ctx context.Context, productID, outletID uuid.UUID) (*entities.Inventory, error)
+	GetByOutlet(ctx context.Context, outletID uuid.UUID) ([]*entities.Inventory, error)
+	GetByProduct(ctx context.Context, productID uuid.UUID) ([]*entities.Inventory, error)
+	GetLowStock(ctx context.Context, outletID uuid.UUID) ([]*entities.Inventory, error)
+	GetZeroStock(ctx context.Context, outletID uuid.UUID) ([]*entities.Inventory, error)
+	Update(ctx context.Context, inventory *entities.Inventory) error
+	Delete(ctx context.Context, id uuid.UUID) error
+	List(ctx context.Context, filters map[string]interface{}, limit, offset int) ([]*entities.Inventory, int64, error)
+	Count(ctx context.Context, filters map[string]interface{}) (int64, error)
+	AdjustQuantity(ctx context.Context, productID, outletID uuid.UUID, delta int) (*entities.Inventory, error)
+	SetQuantity(ctx context.Context, productID, outletID uuid.UUID, quantity int) (*entities.Inventory, error)
+	UpdateReorderLevel(ctx context.Context, id uuid.UUID, reorderLevel int) error
+	BulkCreate(ctx context.Context, inventoryItems []*entities.Inventory) error
+	BulkAdjustQuantity(ctx context.Context, adjustments map[uuid.UUID]int, outletID uuid.UUID) error
+	GetTotalValueByOutlet(ctx context.Context, outletID uuid.UUID) (float64, error)
+}
+
 type InventoryRepositoryImpl struct {
 	db *gorm.DB
 }
@@ -209,10 +230,8 @@ func (r *InventoryRepositoryImpl) SetQuantity(ctx context.Context, productID, ou
 	var inventory entities.Inventory
 
 	err := r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
-		// Get current inventory
 		if err := tx.Where("product_id = ? AND outlet_id = ?", productID, outletID).First(&inventory).Error; err != nil {
 			if errors.Is(err, gorm.ErrRecordNotFound) {
-				// Inventory doesn't exist, create it with the specified quantity
 				inventory = entities.Inventory{
 					ProductID:    productID,
 					OutletID:     outletID,

internal/repository/payment_repository.go

@@ -2,9 +2,12 @@ package repository
 
 import (
 	"context"
+	"errors"
+	"fmt"
 	"time"
 
 	"apskel-pos-be/internal/entities"
+	"apskel-pos-be/internal/models"
 
 	"github.com/google/uuid"
 	"gorm.io/gorm"
@@ -92,3 +95,213 @@ func (r *PaymentRepositoryImpl) GetTotalPaidByOrderID(ctx context.Context, order
 		Scan(&total).Error
 	return total, err
 }
+
+func (r *PaymentRepositoryImpl) CreatePaymentWithInventoryMovement(ctx context.Context, req *models.CreatePaymentRequest, order *entities.Order, totalPaid float64) (*entities.Payment, error) {
+	var payment *entities.Payment
+	var orderJustCompleted bool
+
+	err := r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+		payment = &entities.Payment{
+			OrderID:          req.OrderID,
+			PaymentMethodID:  req.PaymentMethodID,
+			Amount:           req.Amount,
+			Status:           entities.PaymentTransactionStatusCompleted,
+			TransactionID:    req.TransactionID,
+			SplitNumber:      req.SplitNumber,
+			SplitTotal:       req.SplitTotal,
+			SplitDescription: req.SplitDescription,
+			Metadata:         entities.Metadata(req.Metadata),
+		}
+
+		if err := tx.Create(payment).Error; err != nil {
+			return fmt.Errorf("failed to create payment: %w", err)
+		}
+
+		newTotalPaid := totalPaid + req.Amount
+		if newTotalPaid >= order.TotalAmount {
+			if order.PaymentStatus != entities.PaymentStatusCompleted {
+				orderJustCompleted = true
+			}
+			if err := tx.Model(&entities.Order{}).Where("id = ?", req.OrderID).Update("payment_status", entities.PaymentStatusCompleted).Error; err != nil {
+				return fmt.Errorf("failed to update order payment status: %w", err)
+			}
+
+			if err := tx.Model(&entities.Order{}).Where("id = ?", req.OrderID).Update("status", entities.OrderStatusCompleted).Error; err != nil {
+				return fmt.Errorf("failed to update order status: %w", err)
+			}
+		} else {
+			if err := tx.Model(&entities.Order{}).Where("id = ?", req.OrderID).Update("payment_status", entities.PaymentStatusPartiallyRefunded).Error; err != nil {
+				return fmt.Errorf("failed to update order payment status: %w", err)
+			}
+		}
+
+		if orderJustCompleted {
+			orderItems, err := r.getOrderItemsWithTransaction(tx, req.OrderID)
+			if err != nil {
+				return fmt.Errorf("failed to get order items for inventory adjustment: %w", err)
+			}
+
+			for _, item := range orderItems {
+				updatedInventory, err := r.adjustInventoryWithTransaction(tx, item.ProductID, order.OutletID, -item.Quantity)
+				if err != nil {
+					return fmt.Errorf("failed to adjust inventory for product %s: %w", item.ProductID, err)
+				}
+
+				movement := &entities.InventoryMovement{
+					OrganizationID:   order.OrganizationID,
+					OutletID:         order.OutletID,
+					ProductID:        item.ProductID,
+					MovementType:     entities.InventoryMovementTypeSale,
+					Quantity:         -item.Quantity,
+					PreviousQuantity: updatedInventory.Quantity + item.Quantity, // Add back the quantity that was subtracted
+					NewQuantity:      updatedInventory.Quantity,
+					UnitCost:         item.UnitCost,
+					TotalCost:        float64(item.Quantity) * item.UnitCost,
+					ReferenceType: func() *entities.InventoryMovementReferenceType {
+						t := entities.InventoryMovementReferenceTypePayment
+						return &t
+					}(),
+					ReferenceID: &payment.ID,
+					OrderID:     &order.ID,
+					PaymentID:   &payment.ID,
+					UserID:      order.UserID,
+					Reason:      stringPtr("Sale from order payment"),
+					Notes:       stringPtr(fmt.Sprintf("Order: %s, Payment: %s", order.OrderNumber, payment.ID)),
+					Metadata:    entities.Metadata{"order_item_id": item.ID},
+				}
+
+				if err := r.createInventoryMovementWithTransaction(tx, movement); err != nil {
+					return fmt.Errorf("failed to create inventory movement for product %s: %w", item.ProductID, err)
+				}
+			}
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		return nil, err
+	}
+
+	return payment, nil
+}
+
+func (r *PaymentRepositoryImpl) RefundPaymentWithInventoryMovement(ctx context.Context, paymentID uuid.UUID, refundAmount float64, reason string, refundedBy uuid.UUID, payment *entities.Payment) error {
+	return r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+		if err := r.RefundPayment(ctx, paymentID, refundAmount, reason, refundedBy); err != nil {
+			return fmt.Errorf("failed to refund payment: %w", err)
+		}
+
+		// Get order for inventory management
+		order, err := r.getOrderWithTransaction(tx, payment.OrderID)
+		if err != nil {
+			return fmt.Errorf("failed to get order: %w", err)
+		}
+
+		// Update order refund amount
+		order.RefundAmount += refundAmount
+		if err := tx.Model(&entities.Order{}).Where("id = ?", order.ID).Update("refund_amount", order.RefundAmount).Error; err != nil {
+			return fmt.Errorf("failed to update order refund amount: %w", err)
+		}
+
+		refundRatio := refundAmount / payment.Amount
+
+		orderItems, err := r.getOrderItemsWithTransaction(tx, order.ID)
+		if err != nil {
+			return fmt.Errorf("failed to get order items for inventory adjustment: %w", err)
+		}
+
+		for _, item := range orderItems {
+			refundedQuantity := int(float64(item.Quantity) * refundRatio)
+			if refundedQuantity > 0 {
+				updatedInventory, err := r.adjustInventoryWithTransaction(tx, item.ProductID, order.OutletID, refundedQuantity)
+				if err != nil {
+					return fmt.Errorf("failed to restore inventory for product %s: %w", item.ProductID, err)
+				}
+
+				movement := &entities.InventoryMovement{
+					OrganizationID:   order.OrganizationID,
+					OutletID:         order.OutletID,
+					ProductID:        item.ProductID,
+					MovementType:     entities.InventoryMovementTypeRefund,
+					Quantity:         refundedQuantity,
+					PreviousQuantity: updatedInventory.Quantity - refundedQuantity, // Subtract the quantity that was added
+					NewQuantity:      updatedInventory.Quantity,
+					UnitCost:         item.UnitCost,
+					TotalCost:        float64(refundedQuantity) * item.UnitCost,
+					ReferenceType: func() *entities.InventoryMovementReferenceType {
+						t := entities.InventoryMovementReferenceTypeRefund
+						return &t
+					}(),
+					ReferenceID: &paymentID,
+					OrderID:     &order.ID,
+					PaymentID:   &paymentID,
+					UserID:      refundedBy,
+					Reason:      stringPtr(fmt.Sprintf("Refund: %s", reason)),
+					Notes:       stringPtr(fmt.Sprintf("Order: %s, Payment: %s, Refund Amount: %.2f", order.OrderNumber, paymentID, refundAmount)),
+					Metadata:    entities.Metadata{"order_item_id": item.ID, "refund_ratio": refundRatio},
+				}
+
+				if err := r.createInventoryMovementWithTransaction(tx, movement); err != nil {
+					return fmt.Errorf("failed to create inventory movement for refund product %s: %w", item.ProductID, err)
+				}
+			}
+		}
+
+		return nil
+	})
+}
+
+// Helper methods for transaction operations
+func (r *PaymentRepositoryImpl) getOrderWithTransaction(tx *gorm.DB, orderID uuid.UUID) (*entities.Order, error) {
+	var order entities.Order
+	err := tx.First(&order, "id = ?", orderID).Error
+	if err != nil {
+		return nil, err
+	}
+	return &order, nil
+}
+
+func (r *PaymentRepositoryImpl) getOrderItemsWithTransaction(tx *gorm.DB, orderID uuid.UUID) ([]*entities.OrderItem, error) {
+	var orderItems []*entities.OrderItem
+	err := tx.Where("order_id = ?", orderID).Find(&orderItems).Error
+	return orderItems, err
+}
+
+func (r *PaymentRepositoryImpl) adjustInventoryWithTransaction(tx *gorm.DB, productID, outletID uuid.UUID, delta int) (*entities.Inventory, error) {
+	var inventory entities.Inventory
+
+	// Try to find existing inventory
+	if err := tx.Where("product_id = ? AND outlet_id = ?", productID, outletID).First(&inventory).Error; err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			// Inventory doesn't exist, create it with initial quantity
+			inventory = entities.Inventory{
+				ProductID:    productID,
+				OutletID:     outletID,
+				Quantity:     0,
+				ReorderLevel: 0,
+			}
+			if err := tx.Create(&inventory).Error; err != nil {
+				return nil, fmt.Errorf("failed to create inventory record: %w", err)
+			}
+		} else {
+			return nil, err
+		}
+	}
+
+	inventory.UpdateQuantity(delta)
+	if err := tx.Save(&inventory).Error; err != nil {
+		return nil, err
+	}
+
+	return &inventory, nil
+}
+
+func (r *PaymentRepositoryImpl) createInventoryMovementWithTransaction(tx *gorm.DB, movement *entities.InventoryMovement) error {
+	return tx.Create(movement).Error
+}
+
+// Helper function to create string pointer
+func stringPtr(s string) *string {
+	return &s
+}

internal/repository/table_repository.go

@@ -0,0 +1,172 @@
+package repository
+
+import (
+	"apskel-pos-be/internal/entities"
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/google/uuid"
+	"gorm.io/gorm"
+)
+
+type TableRepository struct {
+	db *gorm.DB
+}
+
+func NewTableRepository(db *gorm.DB) *TableRepository {
+	return &TableRepository{db: db}
+}
+
+func (r *TableRepository) Create(ctx context.Context, table *entities.Table) error {
+	return r.db.WithContext(ctx).Create(table).Error
+}
+
+func (r *TableRepository) GetByID(ctx context.Context, id uuid.UUID) (*entities.Table, error) {
+	var table entities.Table
+	err := r.db.WithContext(ctx).
+		Preload("Organization").
+		Preload("Outlet").
+		Preload("Order").
+		Where("id = ?", id).
+		First(&table).Error
+	if err != nil {
+		return nil, err
+	}
+	return &table, nil
+}
+
+func (r *TableRepository) GetByOutletID(ctx context.Context, outletID uuid.UUID) ([]entities.Table, error) {
+	var tables []entities.Table
+	err := r.db.WithContext(ctx).
+		Preload("Organization").
+		Preload("Outlet").
+		Preload("Order").
+		Where("outlet_id = ?", outletID).
+		Order("table_name").
+		Find(&tables).Error
+	return tables, err
+}
+
+func (r *TableRepository) GetByOrganizationID(ctx context.Context, organizationID uuid.UUID) ([]entities.Table, error) {
+	var tables []entities.Table
+	err := r.db.WithContext(ctx).
+		Preload("Organization").
+		Preload("Outlet").
+		Preload("Order").
+		Where("organization_id = ?", organizationID).
+		Order("table_name").
+		Find(&tables).Error
+	return tables, err
+}
+
+func (r *TableRepository) Update(ctx context.Context, table *entities.Table) error {
+	return r.db.WithContext(ctx).Save(table).Error
+}
+
+func (r *TableRepository) Delete(ctx context.Context, id uuid.UUID) error {
+	return r.db.WithContext(ctx).Delete(&entities.Table{}, id).Error
+}
+
+func (r *TableRepository) List(ctx context.Context, organizationID, outletID *uuid.UUID, status *string, isActive *bool, search string, page, limit int) ([]entities.Table, int64, error) {
+	var tables []entities.Table
+	var total int64
+
+	query := r.db.WithContext(ctx).
+		Preload("Organization").
+		Preload("Outlet").
+		Preload("Order")
+
+	if organizationID != nil {
+		query = query.Where("organization_id = ?", *organizationID)
+	}
+
+	if outletID != nil {
+		query = query.Where("outlet_id = ?", *outletID)
+	}
+
+	if status != nil {
+		query = query.Where("status = ?", *status)
+	}
+
+	if isActive != nil {
+		query = query.Where("is_active = ?", *isActive)
+	}
+
+	if search != "" {
+		searchTerm := fmt.Sprintf("%%%s%%", search)
+		query = query.Where("table_name ILIKE ?", searchTerm)
+	}
+
+	// Count total
+	err := query.Model(&entities.Table{}).Count(&total).Error
+	if err != nil {
+		return nil, 0, err
+	}
+
+	// Get paginated results
+	offset := (page - 1) * limit
+	err = query.Offset(offset).Limit(limit).Order("table_name").Find(&tables).Error
+
+	return tables, total, err
+}
+
+func (r *TableRepository) GetAvailableTables(ctx context.Context, outletID uuid.UUID) ([]entities.Table, error) {
+	var tables []entities.Table
+	err := r.db.WithContext(ctx).
+		Preload("Organization").
+		Preload("Outlet").
+		Where("outlet_id = ? AND status = ? AND is_active = ?", outletID, "available", true).
+		Order("table_name").
+		Find(&tables).Error
+	return tables, err
+}
+
+func (r *TableRepository) GetOccupiedTables(ctx context.Context, outletID uuid.UUID) ([]entities.Table, error) {
+	var tables []entities.Table
+	err := r.db.WithContext(ctx).
+		Preload("Organization").
+		Preload("Outlet").
+		Preload("Order").
+		Where("outlet_id = ? AND status = ? AND is_active = ?", outletID, "occupied", true).
+		Order("table_name").
+		Find(&tables).Error
+	return tables, err
+}
+
+func (r *TableRepository) OccupyTable(ctx context.Context, tableID, orderID uuid.UUID, startTime *time.Time) error {
+	return r.db.WithContext(ctx).
+		Model(&entities.Table{}).
+		Where("id = ?", tableID).
+		Updates(map[string]interface{}{
+			"status":     "occupied",
+			"order_id":   orderID,
+			"start_time": startTime,
+		}).Error
+}
+
+func (r *TableRepository) ReleaseTable(ctx context.Context, tableID uuid.UUID, paymentAmount float64) error {
+	return r.db.WithContext(ctx).
+		Model(&entities.Table{}).
+		Where("id = ?", tableID).
+		Updates(map[string]interface{}{
+			"status":         "available",
+			"order_id":       nil,
+			"start_time":     nil,
+			"payment_amount": paymentAmount,
+		}).Error
+}
+
+func (r *TableRepository) GetByOrderID(ctx context.Context, orderID uuid.UUID) (*entities.Table, error) {
+	var table entities.Table
+	err := r.db.WithContext(ctx).
+		Preload("Organization").
+		Preload("Outlet").
+		Preload("Order").
+		Where("order_id = ?", orderID).
+		First(&table).Error
+	if err != nil {
+		return nil, err
+	}
+	return &table, nil
+}