144 lines
4.3 KiB
Go
144 lines
4.3 KiB
Go
// Package service provides business logic for the application
|
|
package service
|
|
|
|
import (
|
|
"accounting-app/internal/models"
|
|
"accounting-app/internal/repository"
|
|
"errors"
|
|
)
|
|
|
|
// Template service errors
|
|
var (
|
|
ErrTemplateNotFound = errors.New("template not found")
|
|
ErrInvalidTemplate = errors.New("invalid template data")
|
|
)
|
|
|
|
// TemplateInput represents input for creating/updating a template
|
|
type TemplateInput struct {
|
|
Name string `json:"name" binding:"required"`
|
|
Amount float64 `json:"amount"`
|
|
Type models.TransactionType `json:"type" binding:"required"`
|
|
CategoryID uint `json:"category_id" binding:"required"`
|
|
AccountID uint `json:"account_id" binding:"required"`
|
|
Currency models.Currency `json:"currency"`
|
|
Note string `json:"note"`
|
|
SortOrder int `json:"sort_order"`
|
|
}
|
|
|
|
// TemplateService handles business logic for transaction templates
|
|
type TemplateService struct {
|
|
templateRepo *repository.TemplateRepository
|
|
categoryRepo *repository.CategoryRepository
|
|
accountRepo *repository.AccountRepository
|
|
}
|
|
|
|
// NewTemplateService creates a new TemplateService instance
|
|
func NewTemplateService(
|
|
templateRepo *repository.TemplateRepository,
|
|
categoryRepo *repository.CategoryRepository,
|
|
accountRepo *repository.AccountRepository,
|
|
) *TemplateService {
|
|
return &TemplateService{
|
|
templateRepo: templateRepo,
|
|
categoryRepo: categoryRepo,
|
|
accountRepo: accountRepo,
|
|
}
|
|
}
|
|
|
|
// CreateTemplate creates a new transaction template
|
|
func (s *TemplateService) CreateTemplate(userID uint, input TemplateInput) (*models.TransactionTemplate, error) {
|
|
if _, err := s.categoryRepo.GetByID(userID, input.CategoryID); err != nil {
|
|
return nil, errors.New("category not found")
|
|
}
|
|
if _, err := s.accountRepo.GetByID(userID, input.AccountID); err != nil {
|
|
return nil, errors.New("account not found")
|
|
}
|
|
|
|
currency := input.Currency
|
|
if currency == "" {
|
|
currency = models.CurrencyCNY
|
|
}
|
|
|
|
template := &models.TransactionTemplate{
|
|
UserID: &userID,
|
|
Name: input.Name,
|
|
Amount: input.Amount,
|
|
Type: input.Type,
|
|
CategoryID: input.CategoryID,
|
|
AccountID: input.AccountID,
|
|
Currency: currency,
|
|
Note: input.Note,
|
|
SortOrder: input.SortOrder,
|
|
}
|
|
|
|
if err := s.templateRepo.Create(template); err != nil {
|
|
return nil, err
|
|
}
|
|
return s.templateRepo.GetByID(userID, template.ID)
|
|
}
|
|
|
|
// GetTemplate retrieves a template by ID
|
|
func (s *TemplateService) GetTemplate(userID uint, id uint) (*models.TransactionTemplate, error) {
|
|
template, err := s.templateRepo.GetByID(userID, id)
|
|
if err != nil {
|
|
if errors.Is(err, repository.ErrTemplateNotFound) {
|
|
return nil, ErrTemplateNotFound
|
|
}
|
|
return nil, err
|
|
}
|
|
return template, nil
|
|
}
|
|
|
|
// GetAllTemplates retrieves all templates for a user
|
|
func (s *TemplateService) GetAllTemplates(userID uint) ([]models.TransactionTemplate, error) {
|
|
return s.templateRepo.GetAll(userID)
|
|
}
|
|
|
|
// UpdateTemplate updates a template
|
|
func (s *TemplateService) UpdateTemplate(userID uint, id uint, input TemplateInput) (*models.TransactionTemplate, error) {
|
|
template, err := s.templateRepo.GetByID(userID, id)
|
|
if err != nil {
|
|
if errors.Is(err, repository.ErrTemplateNotFound) {
|
|
return nil, ErrTemplateNotFound
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
if _, err := s.categoryRepo.GetByID(userID, input.CategoryID); err != nil {
|
|
return nil, errors.New("category not found")
|
|
}
|
|
if _, err := s.accountRepo.GetByID(userID, input.AccountID); err != nil {
|
|
return nil, errors.New("account not found")
|
|
}
|
|
|
|
template.Name = input.Name
|
|
template.Amount = input.Amount
|
|
template.Type = input.Type
|
|
template.CategoryID = input.CategoryID
|
|
template.AccountID = input.AccountID
|
|
if input.Currency != "" {
|
|
template.Currency = input.Currency
|
|
}
|
|
template.Note = input.Note
|
|
template.SortOrder = input.SortOrder
|
|
|
|
if err := s.templateRepo.Update(template); err != nil {
|
|
return nil, err
|
|
}
|
|
return s.templateRepo.GetByID(userID, id)
|
|
}
|
|
|
|
// DeleteTemplate deletes a template
|
|
func (s *TemplateService) DeleteTemplate(userID uint, id uint) error {
|
|
err := s.templateRepo.Delete(userID, id)
|
|
if errors.Is(err, repository.ErrTemplateNotFound) {
|
|
return ErrTemplateNotFound
|
|
}
|
|
return err
|
|
}
|
|
|
|
// UpdateSortOrder updates the sort order of templates
|
|
func (s *TemplateService) UpdateSortOrder(userID uint, ids []uint) error {
|
|
return s.templateRepo.UpdateSortOrder(userID, ids)
|
|
}
|