init

internal/service/refund_service.go

@@ -0,0 +1,152 @@
+package service
+
+import (
+	"errors"
+	"fmt"
+	"time"
+
+	"accounting-app/internal/models"
+	"accounting-app/internal/repository"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+)
+
+// Refund service errors
+var (
+	ErrInvalidRefundAmount    = errors.New("refund amount must be greater than 0 and not exceed original amount")
+	ErrAlreadyRefunded        = errors.New("transaction already refunded")
+	ErrRefundCategoryNotFound = errors.New("refund system category not found")
+)
+
+// RefundService handles business logic for refund operations
+// Feature: accounting-feature-upgrade
+// Validates: Requirements 8.10-8.18
+type RefundService struct {
+	db              *gorm.DB
+	transactionRepo *repository.TransactionRepository
+	accountRepo     *repository.AccountRepository
+}
+
+// NewRefundService creates a new RefundService instance
+func NewRefundService(
+	db *gorm.DB,
+	transactionRepo *repository.TransactionRepository,
+	accountRepo *repository.AccountRepository,
+) *RefundService {
+	return &RefundService{
+		db:              db,
+		transactionRepo: transactionRepo,
+		accountRepo:     accountRepo,
+	}
+}
+
+// ProcessRefund processes a refund on an expense transaction
+// This automatically creates a refund income record and updates the original transaction
+// Feature: accounting-feature-upgrade
+// Validates: Requirements 8.10-8.18, 8.28
+func (s *RefundService) ProcessRefund(userID uint, transactionID uint, refundAmount float64) (*models.Transaction, error) {
+	var refundIncome *models.Transaction
+
+	err := s.db.Transaction(func(tx *gorm.DB) error {
+		txTransactionRepo := repository.NewTransactionRepository(tx)
+		txAccountRepo := repository.NewAccountRepository(tx)
+
+		// Get the original transaction with lock
+		originalTxn, err := txTransactionRepo.GetByID(userID, transactionID)
+		if err != nil {
+			if errors.Is(err, repository.ErrTransactionNotFound) {
+				return ErrTransactionNotFound
+			}
+			return fmt.Errorf("failed to get transaction: %w", err)
+		}
+
+		// Lock the transaction for update
+		if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).
+			First(&models.Transaction{}, transactionID).Error; err != nil {
+			return fmt.Errorf("failed to lock transaction: %w", err)
+		}
+
+		// Validate: must be an expense transaction
+		if originalTxn.Type != models.TransactionTypeExpense {
+			return ErrNotExpenseTransaction
+		}
+
+		// Validate: cannot refund if already refunded
+		if originalTxn.RefundStatus != "none" {
+			return ErrAlreadyRefunded
+		}
+
+		// Validate: refund amount must be positive and not exceed original amount
+		if refundAmount <= 0 || refundAmount > originalTxn.Amount {
+			return ErrInvalidRefundAmount
+		}
+
+		// Get the refund system category
+		var refundCategory models.SystemCategory
+		if err := tx.Where("code = ?", "refund").First(&refundCategory).Error; err != nil {
+			if errors.Is(err, gorm.ErrRecordNotFound) {
+				return ErrRefundCategoryNotFound
+			}
+			return fmt.Errorf("failed to get refund category: %w", err)
+		}
+
+		// Get the account to update balance
+		account, err := txAccountRepo.GetByID(userID, originalTxn.AccountID)
+		if err != nil {
+			return fmt.Errorf("failed to get account: %w", err)
+		}
+
+		// Create the refund income record
+		refundIncome = &models.Transaction{
+			UserID:                userID,
+			Type:                  models.TransactionTypeIncome,
+			Amount:                refundAmount,
+			CategoryID:            uint(refundCategory.ID),
+			AccountID:             originalTxn.AccountID,
+			Currency:              originalTxn.Currency,
+			TransactionDate:       time.Now(),
+			Note:                  fmt.Sprintf("閫€娆?- %s", originalTxn.Note),
+			IncomeType:            "refund",
+			OriginalTransactionID: &transactionID,
+			LedgerID:              originalTxn.LedgerID, // Same ledger as original transaction (Requirement 8.28)
+		}
+
+		if err := txTransactionRepo.Create(refundIncome); err != nil {
+			return fmt.Errorf("failed to create refund income: %w", err)
+		}
+
+		// Determine refund status: partial or full
+		refundStatus := "partial"
+		if refundAmount == originalTxn.Amount {
+			refundStatus = "full"
+		}
+
+		// Update the original transaction status
+		updates := map[string]interface{}{
+			"refund_status":    refundStatus,
+			"refund_amount":    refundAmount,
+			"refund_income_id": refundIncome.ID,
+		}
+
+		if err := tx.Model(&models.Transaction{}).
+			Where("id = ?", transactionID).
+			Updates(updates).Error; err != nil {
+			return fmt.Errorf("failed to update transaction status: %w", err)
+		}
+
+		// Update account balance (add the refund income)
+		newBalance := account.Balance + refundAmount
+		if err := txAccountRepo.UpdateBalance(userID, originalTxn.AccountID, newBalance); err != nil {
+			return fmt.Errorf("failed to update account balance: %w", err)
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		return nil, err
+	}
+
+	return refundIncome, nil
+}