chore: build

backend/gestion/handlers/stats.go

@@ -1,38 +1,270 @@
 package handlers
 
 import (
+	"context"
 	"fmt"
 	"gestion/db"
 	"gestion/models"
 	"net/http"
+	"time"
 
 	"github.com/gin-gonic/gin"
+	"golang.org/x/sync/errgroup"
 )
 
 var weekdayNames = []string{"Dimanche", "Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi"}
 
+// sections valides pour le reset
+var validStatsSections = map[string]string{
+	"commandes": "stats_reset_commandes_at",
+	"revenus":   "stats_reset_revenus_at",
+	"produits":  "stats_reset_produits_at",
+	"heures":    "stats_reset_heures_at",
+	"jours":     "stats_reset_jours_at",
+	"doses":     "stats_reset_doses_at",
+}
+
+// ResetAdminStats réinitialise une section précise des statistiques.
+func ResetAdminStats(c *gin.Context) {
+	section := c.Param("section")
+	key, ok := validStatsSections[section]
+	if !ok {
+		c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("section invalide : %s", section)})
+		return
+	}
+
+	database := c.MustGet("database").(*db.Database)
+	now := time.Now().UTC().Format(time.RFC3339)
+
+	if err := database.ResetAdminStat(key); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("Erreur lors de la suppresion de la section statistique: %s", err)})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{"success": true, "section": section, "reset_at": now})
+}
+
+func dateFilter(t time.Time) string {
+	if t.IsZero() {
+		return ""
+	}
+	return t.Format(time.RFC3339)
+}
+
+// GetAdminStatsByMonth renvoie, pour chaque jour du mois demandé (paramètre
+// de query "month" au format YYYY-MM, mois courant par défaut), le nombre de
+// commandes, le revenu et la quantité vendue. Les jours sans commande sont
+// inclus avec des valeurs à zéro.
+func GetAdminStatsByMonth(c *gin.Context) {
+	database := c.MustGet("database").(*db.Database)
+
+	monthParam := c.Query("month")
+	monthStart := time.Now()
+	if monthParam != "" {
+		parsed, err := time.Parse("2006-01", monthParam)
+		if err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("paramètre month invalide (attendu YYYY-MM) : %s", monthParam)})
+			return
+		}
+		monthStart = parsed
+	}
+	monthStart = time.Date(monthStart.Year(), monthStart.Month(), 1, 0, 0, 0, 0, monthStart.Location())
+
+	resetCmd := database.ReadResetAt("stats_reset_commandes_at")
+
+	var rows []db.DailyMonthStatRow
+	if err := database.StatsByDayForMonth(&rows, monthStart, resetCmd); err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": fmt.Sprintf("Erreur lors de la récupération des statistiques mensuelles: %s", err)})
+		return
+	}
+
+	rowByDay := make(map[string]db.DailyMonthStatRow, len(rows))
+	for _, r := range rows {
+		rowByDay[r.Day.Format("2006-01-02")] = r
+	}
+
+	daysInMonth := monthStart.AddDate(0, 1, -1).Day()
+	byDay := make([]gin.H, daysInMonth)
+	var totalOrders int
+	var totalRevenue float64
+	var totalQuantity float64
+
+	for i := range daysInMonth {
+		day := monthStart.AddDate(0, 0, i)
+		key := day.Format("2006-01-02")
+		r, ok := rowByDay[key]
+		if !ok {
+			r = db.DailyMonthStatRow{Day: day}
+		}
+		byDay[i] = gin.H{
+			"day":      key,
+			"label":    day.Format("02/01"),
+			"count":    r.Count,
+			"revenue":  r.Revenue,
+			"quantity": r.Quantity,
+		}
+		totalOrders += r.Count
+		totalRevenue += r.Revenue
+		totalQuantity += r.Quantity
+	}
+
+	c.JSON(http.StatusOK, gin.H{
+		"month": monthStart.Format("2006-01"),
+		"summary": gin.H{
+			"total_orders":   totalOrders,
+			"total_revenue":  totalRevenue,
+			"total_quantity": totalQuantity,
+		},
+		"by_day": byDay,
+	})
+}
+
+func GetAdminDailyDetail(c *gin.Context) {
+	database := c.MustGet("database").(*db.Database)
+
+	dateParam := c.Query("date")
+	date := time.Now()
+	if dateParam != "" {
+		parsed, err := time.Parse("2006-01-02", dateParam)
+		if err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("paramètre date invalide (attendu YYYY-MM-DD) : %s", dateParam)})
+			return
+		}
+		date = parsed
+	}
+
+	var dailyRows []models.DailyProductRow
+	if err := database.DailyProductDetailForDate(&dailyRows, date); err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": fmt.Sprintf("Erreur lors de la récupération du détail du jour: %s", err)})
+		return
+	}
+
+	type dailyCatGroup struct {
+		Category      string
+		CategoryColor string
+		TotalQuantity float64
+		TotalRevenue  float64
+		Products      []gin.H
+	}
+	var dailyCats []dailyCatGroup
+	dailyCatIdx := map[string]int{}
+	dailyTotalRevenue := 0.0
+	dailyTotalQty := 0.0
+
+	for _, r := range dailyRows {
+		dailyTotalRevenue += r.Revenue
+		dailyTotalQty += r.TotalQuantity
+		idx, ok := dailyCatIdx[r.Category]
+		if !ok {
+			idx = len(dailyCats)
+			dailyCats = append(dailyCats, dailyCatGroup{
+				Category:      r.Category,
+				CategoryColor: r.CategoryColor,
+			})
+			dailyCatIdx[r.Category] = idx
+		}
+		dailyCats[idx].TotalQuantity += r.TotalQuantity
+		dailyCats[idx].TotalRevenue += r.Revenue
+		dailyCats[idx].Products = append(dailyCats[idx].Products, gin.H{
+			"product_id":  r.ProductID,
+			"name":        r.ProductName,
+			"quantity":    r.TotalQuantity,
+			"order_count": r.OrderCount,
+			"revenue":     r.Revenue,
+		})
+	}
+
+	dailyCatsJSON := make([]gin.H, len(dailyCats))
+	for i, g := range dailyCats {
+		dailyCatsJSON[i] = gin.H{
+			"category":       g.Category,
+			"category_color": g.CategoryColor,
+			"total_quantity": g.TotalQuantity,
+			"total_revenue":  g.TotalRevenue,
+			"products":       g.Products,
+		}
+	}
+
+	dailyTotalOrders, _ := database.DailyOrdersCountForDate(date)
+
+	c.JSON(http.StatusOK, gin.H{
+		"date":           date.Format("02/01/2006"),
+		"total_orders":   dailyTotalOrders,
+		"total_quantity": dailyTotalQty,
+		"total_revenue":  dailyTotalRevenue,
+		"categories":     dailyCatsJSON,
+	})
+}
+
 // GetAdminStats returns aggregated order & product statistics for the admin dashboard.
 func GetAdminStats(c *gin.Context) {
 	database := c.MustGet("database").(*db.Database)
-	gdb := database.GDB
 
-	// ── Commandes par jour de la semaine (all time, non annulées) ──────────────
-	var wdRows []models.WeekdayRow
-	gdb.Raw(`
-		SELECT EXTRACT(DOW FROM created_at)::int AS dow, COUNT(*) AS count
-		FROM commandes
-		WHERE status != 'cancelled'
-		GROUP BY dow
-		ORDER BY dow
-	`).Scan(&wdRows)
+	filters := database.LoadAdminStatsFilters()
 
+	// Toutes les requêtes sont indépendantes — on les lance en parallèle.
+	var (
+		wdRows           []models.WeekdayRow
+		dayRows          []models.DayRow
+		dayRevRows       []models.DayRevenueRow
+		hourRows         []models.HourRow
+		prodRows         []models.ProductRow
+		qtyRows          []models.QuantityBreakdownRow
+		dailyRows        []models.DailyProductRow
+		totalOrders      int64
+		totalRevenue     float64
+		dailyTotalOrders int64
+		activeDays       int64
+		last30Count      int64
+	)
+
+	eg, _ := errgroup.WithContext(context.Background())
+	eg.Go(func() error { return database.OrderPerDaysPerWeeks(&wdRows, filters.ResetJours) })
+	eg.Go(func() error { return database.OrdersByDayLast30(&dayRows, filters.ResetCommandes) })
+	eg.Go(func() error { return database.RevenueByDayLast30(&dayRevRows, filters.ResetRevenus) })
+	eg.Go(func() error { return database.OrdersAndRevenueByHour(&hourRows, filters.ResetHeures) })
+	eg.Go(func() error { return database.TopProducts(&prodRows, filters.ResetProduits, 15) })
+	eg.Go(func() error { return database.QuantityBreakdown(&qtyRows, filters.ResetDoses) })
+	eg.Go(func() error { return database.DailyProductDetail(&dailyRows) })
+	eg.Go(func() error {
+		var err error
+		totalOrders, err = database.TotalOrders(filters.ResetCommandes)
+		return err
+	})
+	eg.Go(func() error {
+		var err error
+		totalRevenue, err = database.TotalRevenue(filters.ResetRevenus)
+		return err
+	})
+	eg.Go(func() error {
+		var err error
+		dailyTotalOrders, err = database.DailyOrdersCount()
+		return err
+	})
+	eg.Go(func() error {
+		var err error
+		activeDays, err = database.ActiveDaysLast30(filters.ResetCommandes)
+		return err
+	})
+	eg.Go(func() error {
+		var err error
+		last30Count, err = database.OrdersCountLast30(filters.ResetCommandes)
+		return err
+	})
+
+	if err := eg.Wait(); err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "Erreur lors de la récupération des statistiques"})
+		return
+	}
+
+	// ── Commandes par jour de la semaine ──────────────────────────────────────
 	byWeekday := make([]gin.H, 7)
 	wdMap := make(map[int]int, len(wdRows))
 	for _, r := range wdRows {
 		wdMap[r.DOW] = r.Count
 	}
 	peakCount, peakWeekday := 0, ""
-	for i := 0; i < 7; i++ {
+	for i := range 7 {
 		cnt := wdMap[i]
 		byWeekday[i] = gin.H{"weekday": weekdayNames[i], "count": cnt}
 		if cnt > peakCount {
@@ -42,16 +274,6 @@ func GetAdminStats(c *gin.Context) {
 	}
 
 	// ── Commandes par jour sur 30 jours ───────────────────────────────────────
-	var dayRows []models.DayRow
-	gdb.Raw(`
-		SELECT DATE(created_at) AS day, COUNT(*) AS count
-		FROM commandes
-		WHERE created_at >= NOW() - INTERVAL '30 days'
-		  AND status != 'cancelled'
-		GROUP BY DATE(created_at)
-		ORDER BY day
-	`).Scan(&dayRows)
-
 	byDay := make([]gin.H, len(dayRows))
 	for i, r := range dayRows {
 		byDay[i] = gin.H{
@@ -61,17 +283,7 @@ func GetAdminStats(c *gin.Context) {
 		}
 	}
 
-	// ── Revenus par jour sur 30 jours (commandes approuvées) ─────────────────
-	var dayRevRows []models.DayRevenueRow
-	gdb.Raw(`
-		SELECT DATE(created_at) AS day, COALESCE(SUM(total_prix - COALESCE(referral_used, 0)), 0) AS revenue
-		FROM commandes
-		WHERE created_at >= NOW() - INTERVAL '30 days'
-		  AND status = 'approved'
-		GROUP BY DATE(created_at)
-		ORDER BY day
-	`).Scan(&dayRevRows)
-
+	// ── Revenus par jour sur 30 jours ─────────────────────────────────────────
 	byDayRevenue := make([]gin.H, len(dayRevRows))
 	for i, r := range dayRevRows {
 		byDayRevenue[i] = gin.H{
@@ -81,25 +293,13 @@ func GetAdminStats(c *gin.Context) {
 		}
 	}
 
-	// ── Commandes & revenus par heure (all time, non annulées) ───────────────
-	var hourRows []models.HourRow
-	gdb.Raw(`
-		SELECT
-			EXTRACT(HOUR FROM created_at)::int AS hour,
-			COUNT(*)                           AS count,
-			COALESCE(SUM(total_prix - COALESCE(referral_used, 0)), 0) AS revenue
-		FROM commandes
-		WHERE status != 'cancelled'
-		GROUP BY hour
-		ORDER BY hour
-	`).Scan(&hourRows)
-
+	// ── Commandes & revenus par heure ─────────────────────────────────────────
 	hourMap := make(map[int]models.HourRow, len(hourRows))
 	for _, r := range hourRows {
 		hourMap[r.Hour] = r
 	}
 	byHour := make([]gin.H, 24)
-	for h := 0; h < 24; h++ {
+	for h := range 24 {
 		r := hourMap[h]
 		byHour[h] = gin.H{
 			"hour":    h,
@@ -109,27 +309,7 @@ func GetAdminStats(c *gin.Context) {
 		}
 	}
 
-	// ── Top produits (quantité vendue, commandes terminées) ───────────────────
-	var prodRows []models.ProductRow
-	gdb.Raw(`
-		SELECT
-			ci.product_id,
-			ci.produit                              AS name,
-			SUM(ci.quantite)                        AS total_quantity,
-			COUNT(DISTINCT ci.command_id)           AS order_count,
-			SUM(ci.prix)              AS revenue,
-			COALESCE(p.category, '')                AS category,
-			COALESCE(cat.color, '#7c3aed')          AS category_color
-		FROM command_items ci
-		JOIN commandes c ON c.id = ci.command_id
-		LEFT JOIN products p   ON p.id = ci.product_id
-		LEFT JOIN categories cat ON cat.name = p.category
-		WHERE c.status != 'cancelled'
-		GROUP BY ci.product_id, ci.produit, p.category, cat.color
-		ORDER BY total_quantity DESC
-		LIMIT 15
-	`).Scan(&prodRows)
-
+	// ── Top produits ──────────────────────────────────────────────────────────
 	topProducts := make([]gin.H, len(prodRows))
 	topProductName := ""
 	for i, r := range prodRows {
@@ -147,26 +327,7 @@ func GetAdminStats(c *gin.Context) {
 		}
 	}
 
-	// ── Répartition des doses/quantités par produit ───────────────────────────
-	var qtyRows []models.QuantityBreakdownRow
-	gdb.Raw(`
-		SELECT
-			ci.product_id,
-			ci.produit                           AS product_name,
-			ci.quantite                          AS quantity,
-			COUNT(DISTINCT ci.command_id)        AS order_count,
-			SUM(ci.quantite)                     AS total_sold,
-			SUM(ci.prix)           AS revenue,
-			COALESCE(cat.color, '#7c3aed')       AS category_color
-		FROM command_items ci
-		JOIN commandes c ON c.id = ci.command_id
-		LEFT JOIN products p   ON p.id = ci.product_id
-		LEFT JOIN categories cat ON cat.name = p.category
-		WHERE c.status != 'cancelled'
-		GROUP BY ci.product_id, ci.produit, ci.quantite, cat.color
-		ORDER BY ci.product_id, COUNT(DISTINCT ci.command_id) DESC
-	`).Scan(&qtyRows)
-
+	// ── Répartition des doses/quantités ───────────────────────────────────────
 	type productGroup struct {
 		ProductID     int
 		Name          string
@@ -195,7 +356,6 @@ func GetAdminStats(c *gin.Context) {
 			"revenue":     r.Revenue,
 		})
 	}
-	// Trier par total de commandes décroissant, garder 15 max
 	for i := 0; i < len(groups)-1; i++ {
 		for j := i + 1; j < len(groups); j++ {
 			if groups[j].TotalOrders > groups[i].TotalOrders {
@@ -207,39 +367,65 @@ func GetAdminStats(c *gin.Context) {
 		groups = groups[:15]
 	}
 	byQuantity := make([]gin.H, len(groups))
-	for i, g := range groups {
+	for i, grp := range groups {
 		byQuantity[i] = gin.H{
-			"product_id":     g.ProductID,
-			"name":           g.Name,
-			"category_color": g.CategoryColor,
-			"total_orders":   g.TotalOrders,
-			"quantities":     g.Quantities,
+			"product_id":     grp.ProductID,
+			"name":           grp.Name,
+			"category_color": grp.CategoryColor,
+			"total_orders":   grp.TotalOrders,
+			"quantities":     grp.Quantities,
+		}
+	}
+
+	// ── Détail du jour ────────────────────────────────────────────────────────
+	type dailyCatGroup struct {
+		Category      string
+		CategoryColor string
+		TotalQuantity float64
+		TotalRevenue  float64
+		Products      []gin.H
+	}
+	var dailyCats []dailyCatGroup
+	dailyCatIdx := map[string]int{}
+	dailyTotalRevenue := 0.0
+	dailyTotalQty := 0.0
+	for _, r := range dailyRows {
+		dailyTotalRevenue += r.Revenue
+		dailyTotalQty += r.TotalQuantity
+		idx, ok := dailyCatIdx[r.Category]
+		if !ok {
+			idx = len(dailyCats)
+			dailyCats = append(dailyCats, dailyCatGroup{
+				Category:      r.Category,
+				CategoryColor: r.CategoryColor,
+			})
+			dailyCatIdx[r.Category] = idx
+		}
+		dailyCats[idx].TotalQuantity += r.TotalQuantity
+		dailyCats[idx].TotalRevenue += r.Revenue
+		dailyCats[idx].Products = append(dailyCats[idx].Products, gin.H{
+			"product_id":  r.ProductID,
+			"name":        r.ProductName,
+			"quantity":    r.TotalQuantity,
+			"order_count": r.OrderCount,
+			"revenue":     r.Revenue,
+		})
+	}
+	dailyCatsJSON := make([]gin.H, len(dailyCats))
+	for i, grp := range dailyCats {
+		dailyCatsJSON[i] = gin.H{
+			"category":       grp.Category,
+			"category_color": grp.CategoryColor,
+			"total_quantity": grp.TotalQuantity,
+			"total_revenue":  grp.TotalRevenue,
+			"products":       grp.Products,
 		}
 	}
 
 	// ── Résumé global ─────────────────────────────────────────────────────────
-	var totalOrders int64
-	var totalRevenue float64
-	gdb.Raw(`SELECT COUNT(*) FROM commandes WHERE status != 'cancelled'`).Scan(&totalOrders)
-	gdb.Raw(`SELECT COALESCE(SUM(total_prix - COALESCE(referral_used, 0)), 0) FROM commandes WHERE status = 'approved'`).Scan(&totalRevenue)
-
 	avgPerDay := 0.0
-	if totalOrders > 0 {
-		// average over the last 30 days with data
-		var activeDays int64
-		gdb.Raw(`
-			SELECT COUNT(DISTINCT DATE(created_at))
-			FROM commandes
-			WHERE created_at >= NOW() - INTERVAL '30 days' AND status != 'cancelled'
-		`).Scan(&activeDays)
-		if activeDays > 0 {
-			var last30Count int64
-			gdb.Raw(`
-				SELECT COUNT(*) FROM commandes
-				WHERE created_at >= NOW() - INTERVAL '30 days' AND status != 'cancelled'
-			`).Scan(&last30Count)
-			avgPerDay = float64(last30Count) / float64(activeDays)
-		}
+	if totalOrders > 0 && activeDays > 0 {
+		avgPerDay = float64(last30Count) / float64(activeDays)
 	}
 
 	c.JSON(http.StatusOK, gin.H{
@@ -250,11 +436,24 @@ func GetAdminStats(c *gin.Context) {
 			"top_product":   topProductName,
 			"avg_per_day":   avgPerDay,
 		},
-		"by_weekday":     byWeekday,
-		"by_day_30":      byDay,
-		"by_day_revenue": byDayRevenue,
-		"by_hour":        byHour,
-		"top_products":   topProducts,
-		"by_quantity":    byQuantity,
+		"reset_at_commandes": dateFilter(filters.ResetCommandes),
+		"reset_at_revenus":   dateFilter(filters.ResetRevenus),
+		"reset_at_produits":  dateFilter(filters.ResetProduits),
+		"reset_at_heures":    dateFilter(filters.ResetHeures),
+		"reset_at_jours":     dateFilter(filters.ResetJours),
+		"reset_at_doses":     dateFilter(filters.ResetDoses),
+		"by_weekday":         byWeekday,
+		"by_day_30":          byDay,
+		"by_day_revenue":     byDayRevenue,
+		"by_hour":            byHour,
+		"top_products":       topProducts,
+		"by_quantity":        byQuantity,
+		"daily_detail": gin.H{
+			"date":           time.Now().Format("02/01/2006"),
+			"total_orders":   dailyTotalOrders,
+			"total_quantity": dailyTotalQty,
+			"total_revenue":  dailyTotalRevenue,
+			"categories":     dailyCatsJSON,
+		},
 	})
 }