Build an E-Commerce Store

package models

import (
    "time"
    "gorm.io/gorm"
)

type OrderItem struct {
    ID        uint           `gorm:"primarykey" json:"id"`
    Quantity  int            `gorm:"not null" json:"quantity" binding:"required,min=1"`
    Price     float64        `gorm:"not null" json:"price"`

    // Belongs to Order
    OrderID   uint           `gorm:"index;not null" json:"order_id"`
    Order     Order          `gorm:"foreignKey:OrderID" json:"order,omitempty"`

    // References a Product
    ProductID uint           `gorm:"index;not null" json:"product_id" binding:"required"`
    Product   Product        `gorm:"foreignKey:ProductID" json:"product,omitempty"`

    CreatedAt time.Time      `json:"created_at"`
    UpdatedAt time.Time      `json:"updated_at"`
    DeletedAt gorm.DeletedAt `gorm:"index" json:"deleted_at,omitempty"`
}

Category
  └── has many Products

Product
  └── belongs to Category

Order
  ├── belongs to User (customer)
  └── has many OrderItems

OrderItem
  ├── belongs to Order
  └── belongs to Product

User (built-in)
  └── has many Orders

// UploadImage handles product image upload.
func (h *ProductHandler) UploadImage(c *gin.Context) {
    id, err := strconv.ParseUint(c.Param("id"), 10, 64)
    if err != nil {
        c.JSON(http.StatusBadRequest, gin.H{
            "error": gin.H{"code": "INVALID_ID", "message": "Invalid product ID"},
        })
        return
    }

    // Get the file from the multipart form
    file, header, err := c.Request.FormFile("image")
    if err != nil {
        c.JSON(http.StatusBadRequest, gin.H{
            "error": gin.H{"code": "NO_FILE", "message": "No image file provided"},
        })
        return
    }
    defer file.Close()

    // Validate file type
    contentType := header.Header.Get("Content-Type")
    if contentType != "image/jpeg" && contentType != "image/png" && contentType != "image/webp" {
        c.JSON(http.StatusBadRequest, gin.H{
            "error": gin.H{
                "code":    "INVALID_TYPE",
                "message": "Only JPEG, PNG, and WebP images are allowed",
            },
        })
        return
    }

    // Upload to storage (MinIO / S3)
    path := fmt.Sprintf("products/%d/%s", id, header.Filename)
    url, err := h.storage.Upload(c, path, file, contentType)
    if err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{
            "error": gin.H{"code": "UPLOAD_FAILED", "message": "Failed to upload image"},
        })
        return
    }

    // Update the product record with the image URL
    result := h.db.Model(&models.Product{}).Where("id = ?", id).Update("image_url", url)
    if result.Error != nil {
        c.JSON(http.StatusInternalServerError, gin.H{
            "error": gin.H{"code": "UPDATE_FAILED", "message": "Failed to update product"},
        })
        return
    }

    c.JSON(http.StatusOK, gin.H{
        "data":    gin.H{"image_url": url},
        "message": "Image uploaded successfully",
    })
}

// Inside the authenticated products group
products.POST("/:id/upload-image", productHandler.UploadImage)

type CreateOrderInput struct {
    Notes string `json:"notes"`
    Items []struct {
        ProductID uint `json:"product_id" binding:"required"`
        Quantity  int  `json:"quantity" binding:"required,min=1"`
    } `json:"items" binding:"required,min=1"`
}

func (h *OrderHandler) CreateOrder(c *gin.Context) {
    user, _ := c.Get("user")
    currentUser := user.(*models.User)

    var input CreateOrderInput
    if err := c.ShouldBindJSON(&input); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{
            "error": gin.H{"code": "VALIDATION_ERROR", "message": err.Error()},
        })
        return
    }

    // Use a transaction to ensure atomicity
    tx := h.db.Begin()
    defer func() {
        if r := recover(); r != nil {
            tx.Rollback()
        }
    }()

    var total float64
    var orderItems []models.OrderItem

    for _, item := range input.Items {
        // Lock the product row for update
        var product models.Product
        if err := tx.Set("gorm:query_option", "FOR UPDATE").
            First(&product, item.ProductID).Error; err != nil {
            tx.Rollback()
            c.JSON(http.StatusBadRequest, gin.H{
                "error": gin.H{
                    "code":    "PRODUCT_NOT_FOUND",
                    "message": fmt.Sprintf("Product %d not found", item.ProductID),
                },
            })
            return
        }

        // Validate stock
        if product.Stock < item.Quantity {
            tx.Rollback()
            c.JSON(http.StatusBadRequest, gin.H{
                "error": gin.H{
                    "code": "INSUFFICIENT_STOCK",
                    "message": fmt.Sprintf(
                        "Insufficient stock for %s: requested %d, available %d",
                        product.Name, item.Quantity, product.Stock,
                    ),
                },
            })
            return
        }

        // Decrement stock
        tx.Model(&product).Update("stock", product.Stock-item.Quantity)

        // Calculate line total
        lineTotal := product.Price * float64(item.Quantity)
        total += lineTotal

        orderItems = append(orderItems, models.OrderItem{
            ProductID: product.ID,
            Quantity:  item.Quantity,
            Price:     product.Price, // snapshot the price at time of purchase
        })
    }

    // Create the order
    order := models.Order{
        UserID: currentUser.ID,
        Status: models.OrderStatusPending,
        Total:  total,
        Notes:  input.Notes,
    }

    if err := tx.Create(&order).Error; err != nil {
        tx.Rollback()
        c.JSON(http.StatusInternalServerError, gin.H{
            "error": gin.H{"code": "CREATE_FAILED", "message": "Failed to create order"},
        })
        return
    }

    // Create order items
    for i := range orderItems {
        orderItems[i].OrderID = order.ID
    }
    if err := tx.Create(&orderItems).Error; err != nil {
        tx.Rollback()
        c.JSON(http.StatusInternalServerError, gin.H{
            "error": gin.H{"code": "CREATE_FAILED", "message": "Failed to create order items"},
        })
        return
    }

    tx.Commit()

    // Enqueue confirmation email (non-blocking)
    _ = h.jobClient.EnqueueOrderConfirmation(jobs.OrderConfirmationPayload{
        OrderID:    order.ID,
        UserEmail:  currentUser.Email,
        UserName:   currentUser.Name,
        Total:      total,
        ItemCount:  len(orderItems),
    })

    // Reload with relationships
    h.db.Preload("Items.Product").Preload("User").First(&order, order.ID)

    c.JSON(http.StatusCreated, gin.H{
        "data":    order,
        "message": "Order created successfully",
    })
}

package jobs

import (
    "context"
    "encoding/json"
    "fmt"

    "github.com/hibiken/asynq"
    "shopgrit/apps/api/internal/mail"
)

const TypeOrderConfirmation = "order:confirmation"

type OrderConfirmationPayload struct {
    OrderID   uint    `json:"order_id"`
    UserEmail string  `json:"user_email"`
    UserName  string  `json:"user_name"`
    Total     float64 `json:"total"`
    ItemCount int     `json:"item_count"`
}

// EnqueueOrderConfirmation creates a new order confirmation email job.
func (c *Client) EnqueueOrderConfirmation(payload OrderConfirmationPayload) error {
    data, err := json.Marshal(payload)
    if err != nil {
        return fmt.Errorf("failed to marshal payload: %w", err)
    }

    task := asynq.NewTask(TypeOrderConfirmation, data)
    _, err = c.client.Enqueue(task, asynq.MaxRetry(5), asynq.Queue("critical"))
    return err
}

// HandleOrderConfirmation processes the order confirmation email.
func HandleOrderConfirmation(mailer *mail.Mailer) asynq.HandlerFunc {
    return func(ctx context.Context, t *asynq.Task) error {
        var payload OrderConfirmationPayload
        if err := json.Unmarshal(t.Payload(), &payload); err != nil {
            return fmt.Errorf("failed to unmarshal payload: %w", err)
        }

        return mailer.Send(ctx, mail.SendOptions{
            To:       payload.UserEmail,
            Subject:  fmt.Sprintf("Order #%d Confirmed", payload.OrderID),
            Template: "order-confirmation",
            Data: map[string]interface{}{
                "Name":      payload.UserName,
                "OrderID":   payload.OrderID,
                "Total":     fmt.Sprintf("$%.2f", payload.Total),
                "ItemCount": payload.ItemCount,
            },
        })
    }
}

// GetRevenueStats returns store-wide revenue and order statistics.
func (h *OrderHandler) GetRevenueStats(c *gin.Context) {
    var totalRevenue float64
    var totalOrders int64
    var pendingOrders int64
    var totalProducts int64
    var lowStockProducts int64

    // Revenue from non-cancelled orders
    h.db.Model(&models.Order{}).
        Where("status != ?", models.OrderStatusCancelled).
        Select("COALESCE(SUM(total), 0)").
        Scan(&totalRevenue)

    h.db.Model(&models.Order{}).Count(&totalOrders)

    h.db.Model(&models.Order{}).
        Where("status = ?", models.OrderStatusPending).
        Count(&pendingOrders)

    h.db.Model(&models.Product{}).
        Where("published = ?", true).
        Count(&totalProducts)

    // Products with stock below 10
    h.db.Model(&models.Product{}).
        Where("stock < ? AND published = ?", 10, true).
        Count(&lowStockProducts)

    // Revenue by day for the last 7 days
    type DailyRevenue struct {
        Date    string  `json:"date"`
        Revenue float64 `json:"revenue"`
    }
    var dailyRevenue []DailyRevenue
    h.db.Model(&models.Order{}).
        Select("DATE(created_at) as date, SUM(total) as revenue").
        Where("created_at >= NOW() - INTERVAL '7 days' AND status != ?",
            models.OrderStatusCancelled).
        Group("DATE(created_at)").
        Order("date ASC").
        Scan(&dailyRevenue)

    c.JSON(http.StatusOK, gin.H{
        "data": gin.H{
            "total_revenue":     totalRevenue,
            "total_orders":      totalOrders,
            "pending_orders":    pendingOrders,
            "total_products":    totalProducts,
            "low_stock_products": lowStockProducts,
            "daily_revenue":     dailyRevenue,
        },
    })
}

package services

import (
    "encoding/json"
    "fmt"
    "time"

    "gorm.io/gorm"
    "shopgrit/apps/api/internal/cache"
    "shopgrit/apps/api/internal/models"
)

type ProductService struct {
    db    *gorm.DB
    cache *cache.Cache
}

func NewProductService(db *gorm.DB, c *cache.Cache) *ProductService {
    return &ProductService{db: db, cache: c}
}

// GetByID retrieves a product by ID, using the Redis cache.
func (s *ProductService) GetByID(id uint) (*models.Product, error) {
    cacheKey := fmt.Sprintf("product:%d", id)

    // Try cache first
    cached, err := s.cache.Get(cacheKey)
    if err == nil && cached != "" {
        var product models.Product
        if err := json.Unmarshal([]byte(cached), &product); err == nil {
            return &product, nil
        }
    }

    // Cache miss — query the database
    var product models.Product
    result := s.db.Preload("Category").First(&product, id)
    if result.Error != nil {
        return nil, fmt.Errorf("product not found: %w", result.Error)
    }

    // Store in cache for 5 minutes
    data, _ := json.Marshal(product)
    _ = s.cache.Set(cacheKey, string(data), 5*time.Minute)

    return &product, nil
}

// Update updates a product and invalidates the cache.
func (s *ProductService) Update(id uint, input map[string]interface{}) (*models.Product, error) {
    result := s.db.Model(&models.Product{}).Where("id = ?", id).Updates(input)
    if result.Error != nil {
        return nil, fmt.Errorf("failed to update product: %w", result.Error)
    }

    // Invalidate the cache for this product
    cacheKey := fmt.Sprintf("product:%d", id)
    _ = s.cache.Delete(cacheKey)

    // Also invalidate the published products list cache
    _ = s.cache.DeletePattern("products:published:*")

    return s.GetByID(id)
}

// GetPublished returns published products with caching.
func (s *ProductService) GetPublished(page, pageSize int) ([]models.Product, int64, error) {
    cacheKey := fmt.Sprintf("products:published:%d:%d", page, pageSize)

    // Try cache first
    type cachedResult struct {
        Products []models.Product `json:"products"`
        Total    int64            `json:"total"`
    }

    cached, err := s.cache.Get(cacheKey)
    if err == nil && cached != "" {
        var result cachedResult
        if err := json.Unmarshal([]byte(cached), &result); err == nil {
            return result.Products, result.Total, nil
        }
    }

    // Cache miss — query the database
    var products []models.Product
    var total int64

    query := s.db.Model(&models.Product{}).Where("published = ?", true)
    query.Count(&total)

    offset := (page - 1) * pageSize
    query.Preload("Category").
        Order("created_at DESC").
        Offset(offset).
        Limit(pageSize).
        Find(&products)

    // Cache for 2 minutes
    data, _ := json.Marshal(cachedResult{Products: products, Total: total})
    _ = s.cache.Set(cacheKey, string(data), 2*time.Minute)

    return products, total, nil
}