init

internal/handler/allocation_record_handler.go

@@ -0,0 +1,221 @@
+package handler
+
+import (
+	"strconv"
+	"time"
+
+	"accounting-app/pkg/api"
+	"accounting-app/internal/service"
+
+	"github.com/gin-gonic/gin"
+)
+
+// AllocationRecordHandler handles HTTP requests for allocation record operations
+type AllocationRecordHandler struct {
+	service *service.AllocationRecordService
+}
+
+// NewAllocationRecordHandler creates a new AllocationRecordHandler instance
+func NewAllocationRecordHandler(service *service.AllocationRecordService) *AllocationRecordHandler {
+	return &AllocationRecordHandler{
+		service: service,
+	}
+}
+
+// RegisterRoutes registers allocation record-related routes
+func (h *AllocationRecordHandler) RegisterRoutes(rg *gin.RouterGroup) {
+	allocationRecords := rg.Group("/allocation-records")
+	{
+		allocationRecords.GET("", h.GetAllAllocationRecords)
+		allocationRecords.GET("/recent", h.GetRecentAllocationRecords)
+		allocationRecords.GET("/statistics", h.GetStatistics)
+		allocationRecords.GET("/:id", h.GetAllocationRecord)
+		allocationRecords.DELETE("/:id", h.DeleteAllocationRecord)
+	}
+}
+
+// GetAllocationRecord handles GET /api/v1/allocation-records/:id
+func (h *AllocationRecordHandler) GetAllocationRecord(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 allocation record ID")
+		return
+	}
+
+	record, err := h.service.GetAllocationRecord(userId.(uint), uint(id))
+	if err != nil {
+		if err == service.ErrAllocationRecordNotFound {
+			api.NotFound(c, "Allocation record not found")
+			return
+		}
+		api.InternalError(c, "Failed to get allocation record")
+		return
+	}
+
+	api.Success(c, record)
+}
+
+// GetAllAllocationRecords handles GET /api/v1/allocation-records
+func (h *AllocationRecordHandler) GetAllAllocationRecords(c *gin.Context) {
+	userId, exists := c.Get("user_id")
+	if !exists {
+		api.Unauthorized(c, "User not authenticated")
+		return
+	}
+
+	// Check for filters
+	ruleIDStr := c.Query("rule_id")
+	accountIDStr := c.Query("account_id")
+	startDateStr := c.Query("start_date")
+	endDateStr := c.Query("end_date")
+
+	var records []interface{}
+	var err error
+
+	// Filter by rule ID
+	if ruleIDStr != "" {
+		ruleID, parseErr := strconv.ParseUint(ruleIDStr, 10, 32)
+		if parseErr != nil {
+			api.BadRequest(c, "Invalid rule_id")
+			return
+		}
+		result, serviceErr := h.service.GetAllocationRecordsByRule(userId.(uint), uint(ruleID))
+		if serviceErr != nil {
+			api.InternalError(c, "Failed to get allocation records")
+			return
+		}
+		for _, r := range result {
+			records = append(records, r)
+		}
+		api.Success(c, records)
+		return
+	}
+
+	// Filter by source account ID
+	if accountIDStr != "" {
+		accountID, parseErr := strconv.ParseUint(accountIDStr, 10, 32)
+		if parseErr != nil {
+			api.BadRequest(c, "Invalid account_id")
+			return
+		}
+		result, serviceErr := h.service.GetAllocationRecordsBySourceAccount(userId.(uint), uint(accountID))
+		if serviceErr != nil {
+			api.InternalError(c, "Failed to get allocation records")
+			return
+		}
+		for _, r := range result {
+			records = append(records, r)
+		}
+		api.Success(c, records)
+		return
+	}
+
+	// Filter by date range
+	if startDateStr != "" && endDateStr != "" {
+		startDate, parseErr := time.Parse("2006-01-02", startDateStr)
+		if parseErr != nil {
+			api.BadRequest(c, "Invalid start_date format. Use YYYY-MM-DD")
+			return
+		}
+		endDate, parseErr := time.Parse("2006-01-02", endDateStr)
+		if parseErr != nil {
+			api.BadRequest(c, "Invalid end_date format. Use YYYY-MM-DD")
+			return
+		}
+		result, serviceErr := h.service.GetAllocationRecordsByDateRange(userId.(uint), startDate, endDate)
+		if serviceErr != nil {
+			api.InternalError(c, "Failed to get allocation records")
+			return
+		}
+		for _, r := range result {
+			records = append(records, r)
+		}
+		api.Success(c, records)
+		return
+	}
+
+	// Get all records
+	result, err := h.service.GetAllAllocationRecords(userId.(uint))
+	if err != nil {
+		api.InternalError(c, "Failed to get allocation records")
+		return
+	}
+
+	api.Success(c, result)
+}
+
+// GetRecentAllocationRecords handles GET /api/v1/allocation-records/recent
+func (h *AllocationRecordHandler) GetRecentAllocationRecords(c *gin.Context) {
+	userId, exists := c.Get("user_id")
+	if !exists {
+		api.Unauthorized(c, "User not authenticated")
+		return
+	}
+
+	limitStr := c.Query("limit")
+	limit := 10
+	if limitStr != "" {
+		parsedLimit, err := strconv.Atoi(limitStr)
+		if err == nil && parsedLimit > 0 {
+			limit = parsedLimit
+		}
+	}
+
+	records, err := h.service.GetRecentAllocationRecords(userId.(uint), limit)
+	if err != nil {
+		api.InternalError(c, "Failed to get recent allocation records")
+		return
+	}
+
+	api.Success(c, records)
+}
+
+// DeleteAllocationRecord handles DELETE /api/v1/allocation-records/:id
+func (h *AllocationRecordHandler) DeleteAllocationRecord(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 allocation record ID")
+		return
+	}
+
+	err = h.service.DeleteAllocationRecord(userId.(uint), uint(id))
+	if err != nil {
+		if err == service.ErrAllocationRecordNotFound {
+			api.NotFound(c, "Allocation record not found")
+			return
+		}
+		api.InternalError(c, "Failed to delete allocation record")
+		return
+	}
+
+	api.NoContent(c)
+}
+
+// GetStatistics handles GET /api/v1/allocation-records/statistics
+func (h *AllocationRecordHandler) GetStatistics(c *gin.Context) {
+	userId, exists := c.Get("user_id")
+	if !exists {
+		api.Unauthorized(c, "User not authenticated")
+		return
+	}
+
+	stats, err := h.service.GetStatistics(userId.(uint))
+	if err != nil {
+		api.InternalError(c, "Failed to get allocation statistics")
+		return
+	}
+
+	api.Success(c, stats)
+}