192 lines
7.7 KiB
Go
192 lines
7.7 KiB
Go
package repository
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"time"
|
|
|
|
"accounting-app/internal/models"
|
|
|
|
"gorm.io/gorm"
|
|
)
|
|
|
|
// Recurring transaction repository errors
|
|
var (
|
|
ErrRecurringTransactionNotFound = errors.New("recurring transaction not found")
|
|
)
|
|
|
|
// RecurringTransactionRepository handles database operations for recurring transactions
|
|
type RecurringTransactionRepository struct {
|
|
db *gorm.DB
|
|
}
|
|
|
|
// NewRecurringTransactionRepository creates a new RecurringTransactionRepository instance
|
|
func NewRecurringTransactionRepository(db *gorm.DB) *RecurringTransactionRepository {
|
|
return &RecurringTransactionRepository{db: db}
|
|
}
|
|
|
|
// Create creates a new recurring transaction in the database
|
|
func (r *RecurringTransactionRepository) Create(recurringTransaction *models.RecurringTransaction) error {
|
|
if err := r.db.Create(recurringTransaction).Error; err != nil {
|
|
return fmt.Errorf("failed to create recurring transaction: %w", err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// GetByID retrieves a recurring transaction by its ID
|
|
func (r *RecurringTransactionRepository) GetByID(userID uint, id uint) (*models.RecurringTransaction, error) {
|
|
var recurringTransaction models.RecurringTransaction
|
|
if err := r.db.Where("user_id = ?", userID).First(&recurringTransaction, id).Error; err != nil {
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return nil, ErrRecurringTransactionNotFound
|
|
}
|
|
return nil, fmt.Errorf("failed to get recurring transaction: %w", err)
|
|
}
|
|
return &recurringTransaction, nil
|
|
}
|
|
|
|
// GetByIDWithRelations retrieves a recurring transaction by its ID with all relations preloaded
|
|
func (r *RecurringTransactionRepository) GetByIDWithRelations(userID uint, id uint) (*models.RecurringTransaction, error) {
|
|
var recurringTransaction models.RecurringTransaction
|
|
if err := r.db.Where("user_id = ?", userID).
|
|
Preload("Category").
|
|
Preload("Account").
|
|
First(&recurringTransaction, id).Error; err != nil {
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return nil, ErrRecurringTransactionNotFound
|
|
}
|
|
return nil, fmt.Errorf("failed to get recurring transaction with relations: %w", err)
|
|
}
|
|
return &recurringTransaction, nil
|
|
}
|
|
|
|
// Update updates an existing recurring transaction in the database
|
|
func (r *RecurringTransactionRepository) Update(recurringTransaction *models.RecurringTransaction) error {
|
|
// First check if the recurring transaction exists
|
|
var existing models.RecurringTransaction
|
|
if err := r.db.Where("user_id = ?", recurringTransaction.UserID).First(&existing, recurringTransaction.ID).Error; err != nil {
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return ErrRecurringTransactionNotFound
|
|
}
|
|
return fmt.Errorf("failed to check recurring transaction existence: %w", err)
|
|
}
|
|
|
|
// Update the recurring transaction
|
|
if err := r.db.Save(recurringTransaction).Error; err != nil {
|
|
return fmt.Errorf("failed to update recurring transaction: %w", err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Delete deletes a recurring transaction by its ID (soft delete)
|
|
func (r *RecurringTransactionRepository) Delete(userID uint, id uint) error {
|
|
// First check if the recurring transaction exists
|
|
var recurringTransaction models.RecurringTransaction
|
|
if err := r.db.Where("user_id = ?", userID).First(&recurringTransaction, id).Error; err != nil {
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return ErrRecurringTransactionNotFound
|
|
}
|
|
return fmt.Errorf("failed to check recurring transaction existence: %w", err)
|
|
}
|
|
|
|
// Delete the recurring transaction (soft delete due to gorm.DeletedAt field)
|
|
if err := r.db.Delete(&recurringTransaction).Error; err != nil {
|
|
return fmt.Errorf("failed to delete recurring transaction: %w", err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// List retrieves all recurring transactions for a user
|
|
func (r *RecurringTransactionRepository) List(userID uint) ([]models.RecurringTransaction, error) {
|
|
var recurringTransactions []models.RecurringTransaction
|
|
if err := r.db.Where("user_id = ?", userID).
|
|
Preload("Category").
|
|
Preload("Account").
|
|
Order("next_occurrence ASC").
|
|
Find(&recurringTransactions).Error; err != nil {
|
|
return nil, fmt.Errorf("failed to list recurring transactions: %w", err)
|
|
}
|
|
return recurringTransactions, nil
|
|
}
|
|
|
|
// GetActive retrieves all active recurring transactions for a user
|
|
func (r *RecurringTransactionRepository) GetActive(userID uint) ([]models.RecurringTransaction, error) {
|
|
var recurringTransactions []models.RecurringTransaction
|
|
if err := r.db.Where("user_id = ? AND is_active = ?", userID, true).
|
|
Preload("Category").
|
|
Preload("Account").
|
|
Order("next_occurrence ASC").
|
|
Find(&recurringTransactions).Error; err != nil {
|
|
return nil, fmt.Errorf("failed to get active recurring transactions: %w", err)
|
|
}
|
|
return recurringTransactions, nil
|
|
}
|
|
|
|
// GetDueTransactions retrieves all active recurring transactions that are due (next_occurrence <= now) for a user
|
|
func (r *RecurringTransactionRepository) GetDueTransactions(userID uint, now time.Time) ([]models.RecurringTransaction, error) {
|
|
var recurringTransactions []models.RecurringTransaction
|
|
if err := r.db.Where("user_id = ? AND is_active = ? AND next_occurrence <= ?", userID, true, now).
|
|
Preload("Category").
|
|
Preload("Account").
|
|
Order("next_occurrence ASC").
|
|
Find(&recurringTransactions).Error; err != nil {
|
|
return nil, fmt.Errorf("failed to get due recurring transactions: %w", err)
|
|
}
|
|
return recurringTransactions, nil
|
|
}
|
|
|
|
// GetByAccountID retrieves all recurring transactions for a specific account and user
|
|
func (r *RecurringTransactionRepository) GetByAccountID(userID, accountID uint) ([]models.RecurringTransaction, error) {
|
|
var recurringTransactions []models.RecurringTransaction
|
|
if err := r.db.Where("user_id = ? AND account_id = ?", userID, accountID).
|
|
Preload("Category").
|
|
Order("next_occurrence ASC").
|
|
Find(&recurringTransactions).Error; err != nil {
|
|
return nil, fmt.Errorf("failed to get recurring transactions by account: %w", err)
|
|
}
|
|
return recurringTransactions, nil
|
|
}
|
|
|
|
// GetByCategoryID retrieves all recurring transactions for a specific category and user
|
|
func (r *RecurringTransactionRepository) GetByCategoryID(userID, categoryID uint) ([]models.RecurringTransaction, error) {
|
|
var recurringTransactions []models.RecurringTransaction
|
|
if err := r.db.Where("user_id = ? AND category_id = ?", userID, categoryID).
|
|
Preload("Account").
|
|
Order("next_occurrence ASC").
|
|
Find(&recurringTransactions).Error; err != nil {
|
|
return nil, fmt.Errorf("failed to get recurring transactions by category: %w", err)
|
|
}
|
|
return recurringTransactions, nil
|
|
}
|
|
|
|
// ExistsByID checks if a recurring transaction with the given ID exists for a user
|
|
func (r *RecurringTransactionRepository) ExistsByID(userID, id uint) (bool, error) {
|
|
var count int64
|
|
if err := r.db.Model(&models.RecurringTransaction{}).Where("user_id = ? AND id = ?", userID, id).Count(&count).Error; err != nil {
|
|
return false, fmt.Errorf("failed to check recurring transaction existence: %w", err)
|
|
}
|
|
return count > 0, nil
|
|
}
|
|
|
|
// CountByAccountID returns the count of recurring transactions for an account and user
|
|
func (r *RecurringTransactionRepository) CountByAccountID(userID, accountID uint) (int64, error) {
|
|
var count int64
|
|
if err := r.db.Model(&models.RecurringTransaction{}).
|
|
Where("user_id = ? AND account_id = ?", userID, accountID).
|
|
Count(&count).Error; err != nil {
|
|
return 0, fmt.Errorf("failed to count recurring transactions by account: %w", err)
|
|
}
|
|
return count, nil
|
|
}
|
|
|
|
// CountByCategoryID returns the count of recurring transactions for a category and user
|
|
func (r *RecurringTransactionRepository) CountByCategoryID(userID, categoryID uint) (int64, error) {
|
|
var count int64
|
|
if err := r.db.Model(&models.RecurringTransaction{}).
|
|
Where("user_id = ? AND category_id = ?", userID, categoryID).
|
|
Count(&count).Error; err != nil {
|
|
return 0, fmt.Errorf("failed to count recurring transactions by category: %w", err)
|
|
}
|
|
return count, nil
|
|
}
|