init

2025-07-30 23:18:20 +07:00
parent 4a921df55d
commit a759e0f57c
57 changed files with 3633 additions and 190 deletions
@@ -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
+}