feat: add endpoint and logic for retrieving transaction chart data, including SQL queries, models, and service integration

internal/mapper/dashboard_mapper.go

@@ -58,3 +58,11 @@ func ToDomainAnomalyItem(r db.GetAnomalyItemsRow) models.AnomalyItem {
 		ComponentUnit: r.ComponentUnit,
 	}
 }
+
+func ToDomainTransactionChartRow(r db.GetTransactionChartDataRow) models.TransactionChartRow {
+	return models.TransactionChartRow{
+		Date:            r.Date.Time,
+		TransactionType: string(r.TransactionType),
+		TotalQuantity:   r.TotalQuantity,
+	}
+}

internal/models/dashboard_model.go

@@ -52,3 +52,19 @@ type AnomalyItem struct {
 	ComponentName string    `json:"componentName"`
 	ComponentUnit string    `json:"componentUnit"`
 }
+
+type TransactionChartRow struct {
+	Date            time.Time
+	TransactionType string
+	TotalQuantity   int64
+}
+
+type TransactionChartItem struct {
+	Date           string `json:"date"`
+	ImportQuantity int64  `json:"importQuantity"`
+	ExportQuantity int64  `json:"exportQuantity"`
+}
+
+type TransactionChartData struct {
+	Items []TransactionChartItem `json:"items"`
+}

internal/repositories/dashboard_repository.go

@@ -2,6 +2,8 @@ package repositories
 
 import (
 	"context"
+	"sort"
+	"time"
 	"wm-backend/internal/mapper"
 	"wm-backend/internal/models"
 	db "wm-backend/sqlc_gen"
@@ -83,3 +85,43 @@ func GetAnomalyItems(ctx context.Context, queries *db.Queries, warehouseID pgtyp
 	}
 	return items, nil
 }
+
+func GetTransactionChartData(ctx context.Context, queries *db.Queries, startDate, endDate time.Time, warehouseID pgtype.Int8) (models.TransactionChartData, error) {
+	results, err := queries.GetTransactionChartData(ctx, db.GetTransactionChartDataParams{
+		StartDate:   startDate,
+		EndDate:     endDate,
+		WarehouseID: warehouseID,
+	})
+	if err != nil {
+		return models.TransactionChartData{}, err
+	}
+
+	dateMap := make(map[string]*models.TransactionChartItem)
+	for _, r := range results {
+		row := mapper.ToDomainTransactionChartRow(r)
+		dateStr := row.Date.Format("2006-01-02")
+		if _, exists := dateMap[dateStr]; !exists {
+			dateMap[dateStr] = &models.TransactionChartItem{
+				Date:           dateStr,
+				ImportQuantity: 0,
+				ExportQuantity: 0,
+			}
+		}
+		switch row.TransactionType {
+		case "import":
+			dateMap[dateStr].ImportQuantity = row.TotalQuantity
+		case "export":
+			dateMap[dateStr].ExportQuantity = row.TotalQuantity
+		}
+	}
+
+	items := make([]models.TransactionChartItem, 0, len(dateMap))
+	for _, item := range dateMap {
+		items = append(items, *item)
+	}
+	sort.Slice(items, func(i, j int) bool {
+		return items[i].Date < items[j].Date
+	})
+
+	return models.TransactionChartData{Items: items}, nil
+}

internal/routers/router.go

@@ -158,6 +158,7 @@ func NewRouter() *gin.Engine {
 				dashboard.GET("/summary", utils.AsyncHandler(services.DashboardSummary))
 				dashboard.GET("/stock-alerts", utils.AsyncHandler(services.DashboardStockAlerts))
 				dashboard.GET("/anomalies", utils.AsyncHandler(services.DashboardAnomalies))
+				dashboard.GET("/transactions-chart", utils.AsyncHandler(services.DashboardTransactionsChart))
 			}
 		}
 	}

internal/services/dashboard_service.go

@@ -3,6 +3,7 @@ package services
 import (
 	"net/http"
 	"strconv"
+	"time"
 	"wm-backend/global"
 	"wm-backend/internal/repositories"
 	"wm-backend/response"
@@ -91,3 +92,57 @@ func DashboardAnomalies(c *gin.Context) error {
 	response.Ok(c, "Success", anomalies)
 	return nil
 }
+
+// @Summary      Get transactions chart data
+// @Description  Retrieve import/export transaction quantities grouped by date for chart display
+// @Tags         dashboard
+// @Accept       json
+// @Produce      json
+// @Param        period        query     string  false  "Time period: today, 7d, 30d, this_month"  default(7d)
+// @Param        warehouse_id  query     int     false  "Filter by warehouse ID"
+// @Success      200  {object}  response.SuccessResponse{data=models.TransactionChartData}
+// @Failure      400  {object}  response.ErrorResponse
+// @Failure      500  {object}  response.ErrorResponse
+// @Router       /v1/dashboard/transactions-chart [get]
+func DashboardTransactionsChart(c *gin.Context) error {
+	period := c.DefaultQuery("period", "7d")
+
+	now := time.Now()
+	var startDate, endDate time.Time
+	switch period {
+	case "today":
+		startDate = time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, now.Location())
+		endDate = startDate.AddDate(0, 0, 1)
+	case "7d":
+		startDate = time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, now.Location()).AddDate(0, 0, -6)
+		endDate = time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, now.Location()).AddDate(0, 0, 1)
+	case "30d":
+		startDate = time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, now.Location()).AddDate(0, 0, -29)
+		endDate = time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, now.Location()).AddDate(0, 0, 1)
+	case "this_month":
+		startDate = time.Date(now.Year(), now.Month(), 1, 0, 0, 0, 0, now.Location())
+		endDate = startDate.AddDate(0, 1, 0)
+	default:
+		response.BadRequestError(c, http.StatusBadRequest, "Invalid period. Use: today, 7d, 30d, this_month")
+		return nil
+	}
+
+	var warehouseID pgtype.Int8
+	if raw := c.Query("warehouse_id"); raw != "" {
+		id, err := strconv.ParseInt(raw, 10, 64)
+		if err != nil {
+			response.BadRequestError(c, http.StatusBadRequest, "Invalid warehouse_id")
+			return nil
+		}
+		warehouseID = pgtype.Int8{Int64: id, Valid: true}
+	}
+
+	data, err := repositories.GetTransactionChartData(c.Request.Context(), global.Queries, startDate, endDate, warehouseID)
+	if err != nil {
+		log.Err(err).Msg("Error when Get Transaction Chart Data")
+		response.InternalServerError(c, http.StatusInternalServerError, "Failed to get transaction chart data")
+		return nil
+	}
+	response.Ok(c, "Success", data)
+	return nil
+}