97 lines
2.7 KiB
Go
97 lines
2.7 KiB
Go
package handler
|
|
|
|
import (
|
|
"errors"
|
|
"strconv"
|
|
|
|
"accounting-app/pkg/api"
|
|
"accounting-app/internal/models"
|
|
"accounting-app/internal/service"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
)
|
|
|
|
// RefundServiceInterface defines the interface for refund operations
|
|
type RefundServiceInterface interface {
|
|
ProcessRefund(userID uint, transactionID uint, amount float64) (*models.Transaction, error)
|
|
}
|
|
|
|
// RefundHandler handles HTTP requests for refund operations
|
|
// Feature: accounting-feature-upgrade
|
|
// Validates: Requirements 8.10-8.18
|
|
type RefundHandler struct {
|
|
refundService RefundServiceInterface
|
|
}
|
|
|
|
// NewRefundHandler creates a new RefundHandler instance
|
|
func NewRefundHandler(refundService RefundServiceInterface) *RefundHandler {
|
|
return &RefundHandler{
|
|
refundService: refundService,
|
|
}
|
|
}
|
|
|
|
// ProcessRefundInput represents the input for processing a refund
|
|
type ProcessRefundInput struct {
|
|
Amount float64 `json:"amount" binding:"required,gt=0"`
|
|
}
|
|
|
|
// ProcessRefund handles PUT /api/v1/transactions/:id/refund
|
|
// Processes a refund on an expense transaction, automatically creating a refund income record
|
|
// Feature: accounting-feature-upgrade
|
|
// Validates: Requirements 8.10-8.18, 8.28
|
|
func (h *RefundHandler) ProcessRefund(c *gin.Context) {
|
|
userId, exists := c.Get("user_id")
|
|
if !exists {
|
|
api.Unauthorized(c, "User not authenticated")
|
|
return
|
|
}
|
|
|
|
id, err := strconv.ParseUint(c.Param("id"), 10, 32)
|
|
if err != nil {
|
|
api.BadRequest(c, "Invalid transaction ID")
|
|
return
|
|
}
|
|
|
|
var input ProcessRefundInput
|
|
if err := c.ShouldBindJSON(&input); err != nil {
|
|
api.ValidationError(c, "Invalid request body: "+err.Error())
|
|
return
|
|
}
|
|
|
|
refundIncome, err := h.refundService.ProcessRefund(userId.(uint), uint(id), input.Amount)
|
|
if err != nil {
|
|
if errors.Is(err, service.ErrTransactionNotFound) {
|
|
api.NotFound(c, "Transaction not found")
|
|
return
|
|
}
|
|
if errors.Is(err, service.ErrNotExpenseTransaction) {
|
|
api.BadRequest(c, "Only expense transactions can be refunded")
|
|
return
|
|
}
|
|
if errors.Is(err, service.ErrAlreadyRefunded) {
|
|
api.BadRequest(c, "Transaction already refunded")
|
|
return
|
|
}
|
|
if errors.Is(err, service.ErrInvalidRefundAmount) {
|
|
api.BadRequest(c, "Refund amount must be greater than 0 and not exceed original amount")
|
|
return
|
|
}
|
|
if errors.Is(err, service.ErrRefundCategoryNotFound) {
|
|
api.InternalError(c, "Refund system category not found. Please run database migrations.")
|
|
return
|
|
}
|
|
api.InternalError(c, "Failed to process refund: "+err.Error())
|
|
return
|
|
}
|
|
|
|
api.Success(c, refundIncome)
|
|
}
|
|
|
|
// RegisterRoutes registers all refund routes to the given router group
|
|
func (h *RefundHandler) RegisterRoutes(rg *gin.RouterGroup) {
|
|
transactions := rg.Group("/transactions")
|
|
{
|
|
transactions.PUT("/:id/refund", h.ProcessRefund)
|
|
}
|
|
}
|