Add initial backend implementation

- Go module with Gin, GORM, JWT, excelize dependencies
- Configuration loading from YAML with all settings
- GORM models for users, categories, components, configurations, alerts
- Repository layer for all entities
- Services: auth (JWT), pricing (median/average/weighted), components,
  quotes, configurations, export (CSV/XLSX), alerts
- Middleware: JWT auth, role-based access, CORS
- HTTP handlers for all API endpoints
- Main server with dependency injection and graceful shutdown

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

internal/handlers/auth.go

@@ -0,0 +1,113 @@
+package handlers
+
+import (
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+	"github.com/mchus/quoteforge/internal/middleware"
+	"github.com/mchus/quoteforge/internal/repository"
+	"github.com/mchus/quoteforge/internal/services"
+)
+
+type AuthHandler struct {
+	authService *services.AuthService
+	userRepo    *repository.UserRepository
+}
+
+func NewAuthHandler(authService *services.AuthService, userRepo *repository.UserRepository) *AuthHandler {
+	return &AuthHandler{
+		authService: authService,
+		userRepo:    userRepo,
+	}
+}
+
+type LoginRequest struct {
+	Username string `json:"username" binding:"required"`
+	Password string `json:"password" binding:"required"`
+}
+
+type LoginResponse struct {
+	AccessToken  string `json:"access_token"`
+	RefreshToken string `json:"refresh_token"`
+	ExpiresAt    int64  `json:"expires_at"`
+	User         UserResponse `json:"user"`
+}
+
+type UserResponse struct {
+	ID       uint   `json:"id"`
+	Username string `json:"username"`
+	Email    string `json:"email"`
+	Role     string `json:"role"`
+}
+
+func (h *AuthHandler) Login(c *gin.Context) {
+	var req LoginRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	tokens, user, err := h.authService.Login(req.Username, req.Password)
+	if err != nil {
+		c.JSON(http.StatusUnauthorized, gin.H{"error": err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusOK, LoginResponse{
+		AccessToken:  tokens.AccessToken,
+		RefreshToken: tokens.RefreshToken,
+		ExpiresAt:    tokens.ExpiresAt,
+		User: UserResponse{
+			ID:       user.ID,
+			Username: user.Username,
+			Email:    user.Email,
+			Role:     string(user.Role),
+		},
+	})
+}
+
+type RefreshRequest struct {
+	RefreshToken string `json:"refresh_token" binding:"required"`
+}
+
+func (h *AuthHandler) Refresh(c *gin.Context) {
+	var req RefreshRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	tokens, err := h.authService.RefreshTokens(req.RefreshToken)
+	if err != nil {
+		c.JSON(http.StatusUnauthorized, gin.H{"error": err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusOK, tokens)
+}
+
+func (h *AuthHandler) Me(c *gin.Context) {
+	claims := middleware.GetClaims(c)
+	if claims == nil {
+		c.JSON(http.StatusUnauthorized, gin.H{"error": "not authenticated"})
+		return
+	}
+
+	user, err := h.userRepo.GetByID(claims.UserID)
+	if err != nil {
+		c.JSON(http.StatusNotFound, gin.H{"error": "user not found"})
+		return
+	}
+
+	c.JSON(http.StatusOK, UserResponse{
+		ID:       user.ID,
+		Username: user.Username,
+		Email:    user.Email,
+		Role:     string(user.Role),
+	})
+}
+
+func (h *AuthHandler) Logout(c *gin.Context) {
+	// JWT is stateless, logout is handled on client by discarding tokens
+	c.JSON(http.StatusOK, gin.H{"message": "logged out"})
+}

internal/handlers/component.go

@@ -0,0 +1,72 @@
+package handlers
+
+import (
+	"net/http"
+	"strconv"
+
+	"github.com/gin-gonic/gin"
+	"github.com/mchus/quoteforge/internal/repository"
+	"github.com/mchus/quoteforge/internal/services"
+)
+
+type ComponentHandler struct {
+	componentService *services.ComponentService
+}
+
+func NewComponentHandler(componentService *services.ComponentService) *ComponentHandler {
+	return &ComponentHandler{componentService: componentService}
+}
+
+func (h *ComponentHandler) List(c *gin.Context) {
+	page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
+	perPage, _ := strconv.Atoi(c.DefaultQuery("per_page", "20"))
+
+	filter := repository.ComponentFilter{
+		Category: c.Query("category"),
+		Vendor:   c.Query("vendor"),
+		Search:   c.Query("search"),
+		HasPrice: c.Query("has_price") == "true",
+	}
+
+	result, err := h.componentService.List(filter, page, perPage)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusOK, result)
+}
+
+func (h *ComponentHandler) Get(c *gin.Context) {
+	lotName := c.Param("lot_name")
+
+	component, err := h.componentService.GetByLotName(lotName)
+	if err != nil {
+		c.JSON(http.StatusNotFound, gin.H{"error": "component not found"})
+		return
+	}
+
+	c.JSON(http.StatusOK, component)
+}
+
+func (h *ComponentHandler) GetCategories(c *gin.Context) {
+	categories, err := h.componentService.GetCategories()
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusOK, categories)
+}
+
+func (h *ComponentHandler) GetVendors(c *gin.Context) {
+	category := c.Query("category")
+
+	vendors, err := h.componentService.GetVendors(category)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusOK, vendors)
+}

internal/handlers/configuration.go

@@ -0,0 +1,156 @@
+package handlers
+
+import (
+	"io"
+	"net/http"
+	"strconv"
+
+	"github.com/gin-gonic/gin"
+	"github.com/mchus/quoteforge/internal/middleware"
+	"github.com/mchus/quoteforge/internal/services"
+)
+
+type ConfigurationHandler struct {
+	configService *services.ConfigurationService
+	exportService *services.ExportService
+}
+
+func NewConfigurationHandler(
+	configService *services.ConfigurationService,
+	exportService *services.ExportService,
+) *ConfigurationHandler {
+	return &ConfigurationHandler{
+		configService: configService,
+		exportService: exportService,
+	}
+}
+
+func (h *ConfigurationHandler) List(c *gin.Context) {
+	userID := middleware.GetUserID(c)
+	page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
+	perPage, _ := strconv.Atoi(c.DefaultQuery("per_page", "20"))
+
+	configs, total, err := h.configService.ListByUser(userID, page, perPage)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{
+		"configurations": configs,
+		"total":          total,
+		"page":           page,
+		"per_page":       perPage,
+	})
+}
+
+func (h *ConfigurationHandler) Create(c *gin.Context) {
+	userID := middleware.GetUserID(c)
+
+	var req services.CreateConfigRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	config, err := h.configService.Create(userID, &req)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusCreated, config)
+}
+
+func (h *ConfigurationHandler) Get(c *gin.Context) {
+	userID := middleware.GetUserID(c)
+	uuid := c.Param("uuid")
+
+	config, err := h.configService.GetByUUID(uuid, userID)
+	if err != nil {
+		status := http.StatusNotFound
+		if err == services.ErrConfigForbidden {
+			status = http.StatusForbidden
+		}
+		c.JSON(status, gin.H{"error": err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusOK, config)
+}
+
+func (h *ConfigurationHandler) Update(c *gin.Context) {
+	userID := middleware.GetUserID(c)
+	uuid := c.Param("uuid")
+
+	var req services.CreateConfigRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	config, err := h.configService.Update(uuid, userID, &req)
+	if err != nil {
+		status := http.StatusInternalServerError
+		if err == services.ErrConfigNotFound {
+			status = http.StatusNotFound
+		} else if err == services.ErrConfigForbidden {
+			status = http.StatusForbidden
+		}
+		c.JSON(status, gin.H{"error": err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusOK, config)
+}
+
+func (h *ConfigurationHandler) Delete(c *gin.Context) {
+	userID := middleware.GetUserID(c)
+	uuid := c.Param("uuid")
+
+	err := h.configService.Delete(uuid, userID)
+	if err != nil {
+		status := http.StatusInternalServerError
+		if err == services.ErrConfigNotFound {
+			status = http.StatusNotFound
+		} else if err == services.ErrConfigForbidden {
+			status = http.StatusForbidden
+		}
+		c.JSON(status, gin.H{"error": err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{"message": "deleted"})
+}
+
+func (h *ConfigurationHandler) ExportJSON(c *gin.Context) {
+	userID := middleware.GetUserID(c)
+	uuid := c.Param("uuid")
+
+	data, err := h.configService.ExportJSON(uuid, userID)
+	if err != nil {
+		c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
+		return
+	}
+
+	c.Header("Content-Disposition", "attachment; filename=config.json")
+	c.Data(http.StatusOK, "application/json", data)
+}
+
+func (h *ConfigurationHandler) ImportJSON(c *gin.Context) {
+	userID := middleware.GetUserID(c)
+
+	data, err := io.ReadAll(c.Request.Body)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "failed to read body"})
+		return
+	}
+
+	config, err := h.configService.ImportJSON(userID, data)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusCreated, config)
+}

internal/handlers/export.go

@@ -0,0 +1,174 @@
+package handlers
+
+import (
+	"fmt"
+	"net/http"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"github.com/mchus/quoteforge/internal/middleware"
+	"github.com/mchus/quoteforge/internal/models"
+	"github.com/mchus/quoteforge/internal/services"
+)
+
+type ExportHandler struct {
+	exportService    *services.ExportService
+	configService    *services.ConfigurationService
+	componentService *services.ComponentService
+}
+
+func NewExportHandler(
+	exportService *services.ExportService,
+	configService *services.ConfigurationService,
+	componentService *services.ComponentService,
+) *ExportHandler {
+	return &ExportHandler{
+		exportService:    exportService,
+		configService:    configService,
+		componentService: componentService,
+	}
+}
+
+type ExportRequest struct {
+	Name  string `json:"name" binding:"required"`
+	Items []struct {
+		LotName   string  `json:"lot_name" binding:"required"`
+		Quantity  int     `json:"quantity" binding:"required,min=1"`
+		UnitPrice float64 `json:"unit_price"`
+	} `json:"items" binding:"required,min=1"`
+	Notes string `json:"notes"`
+}
+
+func (h *ExportHandler) ExportCSV(c *gin.Context) {
+	var req ExportRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	data := h.buildExportData(&req)
+
+	csvData, err := h.exportService.ToCSV(data)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	filename := fmt.Sprintf("%s_%s.csv", req.Name, time.Now().Format("20060102"))
+	c.Header("Content-Disposition", fmt.Sprintf("attachment; filename=%s", filename))
+	c.Data(http.StatusOK, "text/csv; charset=utf-8", csvData)
+}
+
+func (h *ExportHandler) ExportXLSX(c *gin.Context) {
+	var req ExportRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	data := h.buildExportData(&req)
+
+	xlsxData, err := h.exportService.ToXLSX(data)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	filename := fmt.Sprintf("%s_%s.xlsx", req.Name, time.Now().Format("20060102"))
+	c.Header("Content-Disposition", fmt.Sprintf("attachment; filename=%s", filename))
+	c.Data(http.StatusOK, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", xlsxData)
+}
+
+func (h *ExportHandler) buildExportData(req *ExportRequest) *services.ExportData {
+	items := make([]services.ExportItem, len(req.Items))
+	var total float64
+
+	for i, item := range req.Items {
+		itemTotal := item.UnitPrice * float64(item.Quantity)
+		items[i] = services.ExportItem{
+			LotName:    item.LotName,
+			Quantity:   item.Quantity,
+			UnitPrice:  item.UnitPrice,
+			TotalPrice: itemTotal,
+		}
+		total += itemTotal
+	}
+
+	return &services.ExportData{
+		Name:      req.Name,
+		Items:     items,
+		Total:     total,
+		Notes:     req.Notes,
+		CreatedAt: time.Now(),
+	}
+}
+
+func (h *ExportHandler) ExportConfigCSV(c *gin.Context) {
+	userID := middleware.GetUserID(c)
+	uuid := c.Param("uuid")
+
+	config, err := h.configService.GetByUUID(uuid, userID)
+	if err != nil {
+		c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
+		return
+	}
+
+	data := h.configToExportData(config)
+
+	csvData, err := h.exportService.ToCSV(data)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	filename := fmt.Sprintf("%s_%s.csv", config.Name, config.CreatedAt.Format("20060102"))
+	c.Header("Content-Disposition", fmt.Sprintf("attachment; filename=%s", filename))
+	c.Data(http.StatusOK, "text/csv; charset=utf-8", csvData)
+}
+
+func (h *ExportHandler) ExportConfigXLSX(c *gin.Context) {
+	userID := middleware.GetUserID(c)
+	uuid := c.Param("uuid")
+
+	config, err := h.configService.GetByUUID(uuid, userID)
+	if err != nil {
+		c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
+		return
+	}
+
+	data := h.configToExportData(config)
+
+	xlsxData, err := h.exportService.ToXLSX(data)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	filename := fmt.Sprintf("%s_%s.xlsx", config.Name, config.CreatedAt.Format("20060102"))
+	c.Header("Content-Disposition", fmt.Sprintf("attachment; filename=%s", filename))
+	c.Data(http.StatusOK, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", xlsxData)
+}
+
+func (h *ExportHandler) configToExportData(config *models.Configuration) *services.ExportData {
+	items := make([]services.ExportItem, len(config.Items))
+	var total float64
+
+	for i, item := range config.Items {
+		itemTotal := item.UnitPrice * float64(item.Quantity)
+		items[i] = services.ExportItem{
+			LotName:    item.LotName,
+			Quantity:   item.Quantity,
+			UnitPrice:  item.UnitPrice,
+			TotalPrice: itemTotal,
+		}
+		total += itemTotal
+	}
+
+	return &services.ExportData{
+		Name:      config.Name,
+		Items:     items,
+		Total:     total,
+		Notes:     config.Notes,
+		CreatedAt: config.CreatedAt,
+	}
+}

internal/handlers/pricing.go

@@ -0,0 +1,210 @@
+package handlers
+
+import (
+	"net/http"
+	"strconv"
+
+	"github.com/gin-gonic/gin"
+	"github.com/mchus/quoteforge/internal/middleware"
+	"github.com/mchus/quoteforge/internal/models"
+	"github.com/mchus/quoteforge/internal/repository"
+	"github.com/mchus/quoteforge/internal/services/alerts"
+	"github.com/mchus/quoteforge/internal/services/pricing"
+)
+
+type PricingHandler struct {
+	pricingService *pricing.Service
+	alertService   *alerts.Service
+	componentRepo  *repository.ComponentRepository
+	statsRepo      *repository.StatsRepository
+}
+
+func NewPricingHandler(
+	pricingService *pricing.Service,
+	alertService *alerts.Service,
+	componentRepo *repository.ComponentRepository,
+	statsRepo *repository.StatsRepository,
+) *PricingHandler {
+	return &PricingHandler{
+		pricingService: pricingService,
+		alertService:   alertService,
+		componentRepo:  componentRepo,
+		statsRepo:      statsRepo,
+	}
+}
+
+func (h *PricingHandler) GetStats(c *gin.Context) {
+	newAlerts, _ := h.alertService.GetNewAlertsCount()
+	topComponents, _ := h.statsRepo.GetTopComponents(10)
+	trendingComponents, _ := h.statsRepo.GetTrendingComponents(10)
+
+	c.JSON(http.StatusOK, gin.H{
+		"new_alerts_count":     newAlerts,
+		"top_components":       topComponents,
+		"trending_components":  trendingComponents,
+	})
+}
+
+func (h *PricingHandler) ListComponents(c *gin.Context) {
+	page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
+	perPage, _ := strconv.Atoi(c.DefaultQuery("per_page", "20"))
+
+	filter := repository.ComponentFilter{
+		Category: c.Query("category"),
+		Vendor:   c.Query("vendor"),
+		Search:   c.Query("search"),
+	}
+
+	if page < 1 {
+		page = 1
+	}
+	if perPage < 1 || perPage > 100 {
+		perPage = 20
+	}
+	offset := (page - 1) * perPage
+
+	components, total, err := h.componentRepo.List(filter, offset, perPage)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{
+		"components": components,
+		"total":      total,
+		"page":       page,
+		"per_page":   perPage,
+	})
+}
+
+func (h *PricingHandler) GetComponentPricing(c *gin.Context) {
+	lotName := c.Param("lot_name")
+
+	component, err := h.componentRepo.GetByLotName(lotName)
+	if err != nil {
+		c.JSON(http.StatusNotFound, gin.H{"error": "component not found"})
+		return
+	}
+
+	stats, err := h.pricingService.GetPriceStats(lotName, 0)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{
+		"component":   component,
+		"price_stats": stats,
+	})
+}
+
+type UpdatePriceRequest struct {
+	LotName     string             `json:"lot_name" binding:"required"`
+	Method      models.PriceMethod `json:"method"`
+	PeriodDays  int                `json:"period_days"`
+	ManualPrice *float64           `json:"manual_price"`
+	Reason      string             `json:"reason"`
+}
+
+func (h *PricingHandler) UpdatePrice(c *gin.Context) {
+	userID := middleware.GetUserID(c)
+
+	var req UpdatePriceRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	if req.ManualPrice != nil && *req.ManualPrice > 0 {
+		err := h.pricingService.SetManualPrice(req.LotName, *req.ManualPrice, req.Reason, userID)
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+	}
+
+	if req.Method != "" {
+		err := h.pricingService.UpdatePriceMethod(req.LotName, req.Method, req.PeriodDays)
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+	}
+
+	c.JSON(http.StatusOK, gin.H{"message": "price updated"})
+}
+
+func (h *PricingHandler) RecalculateAll(c *gin.Context) {
+	// This would be better as a background job
+	c.JSON(http.StatusAccepted, gin.H{"message": "recalculation started"})
+}
+
+func (h *PricingHandler) ListAlerts(c *gin.Context) {
+	page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
+	perPage, _ := strconv.Atoi(c.DefaultQuery("per_page", "20"))
+
+	filter := repository.AlertFilter{
+		Status:   models.AlertStatus(c.Query("status")),
+		Severity: models.AlertSeverity(c.Query("severity")),
+		Type:     models.AlertType(c.Query("type")),
+		LotName:  c.Query("lot_name"),
+	}
+
+	alertsList, total, err := h.alertService.List(filter, page, perPage)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{
+		"alerts":   alertsList,
+		"total":    total,
+		"page":     page,
+		"per_page": perPage,
+	})
+}
+
+func (h *PricingHandler) AcknowledgeAlert(c *gin.Context) {
+	id, err := strconv.ParseUint(c.Param("id"), 10, 32)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid alert id"})
+		return
+	}
+
+	if err := h.alertService.Acknowledge(uint(id)); err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{"message": "acknowledged"})
+}
+
+func (h *PricingHandler) ResolveAlert(c *gin.Context) {
+	id, err := strconv.ParseUint(c.Param("id"), 10, 32)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid alert id"})
+		return
+	}
+
+	if err := h.alertService.Resolve(uint(id)); err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{"message": "resolved"})
+}
+
+func (h *PricingHandler) IgnoreAlert(c *gin.Context) {
+	id, err := strconv.ParseUint(c.Param("id"), 10, 32)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid alert id"})
+		return
+	}
+
+	if err := h.alertService.Ignore(uint(id)); err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{"message": "ignored"})
+}

internal/handlers/quote.go

@@ -0,0 +1,51 @@
+package handlers
+
+import (
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+	"github.com/mchus/quoteforge/internal/services"
+)
+
+type QuoteHandler struct {
+	quoteService *services.QuoteService
+}
+
+func NewQuoteHandler(quoteService *services.QuoteService) *QuoteHandler {
+	return &QuoteHandler{quoteService: quoteService}
+}
+
+func (h *QuoteHandler) Validate(c *gin.Context) {
+	var req services.QuoteRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	result, err := h.quoteService.ValidateAndCalculate(&req)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusOK, result)
+}
+
+func (h *QuoteHandler) Calculate(c *gin.Context) {
+	var req services.QuoteRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	result, err := h.quoteService.ValidateAndCalculate(&req)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{
+		"items": result.Items,
+		"total": result.Total,
+	})
+}