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/services/alerts/service.go

@@ -0,0 +1,199 @@
+package alerts
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/mchus/quoteforge/internal/config"
+	"github.com/mchus/quoteforge/internal/models"
+	"github.com/mchus/quoteforge/internal/repository"
+)
+
+type Service struct {
+	alertRepo     *repository.AlertRepository
+	componentRepo *repository.ComponentRepository
+	priceRepo     *repository.PriceRepository
+	statsRepo     *repository.StatsRepository
+	config        config.AlertsConfig
+	pricingConfig config.PricingConfig
+}
+
+func NewService(
+	alertRepo *repository.AlertRepository,
+	componentRepo *repository.ComponentRepository,
+	priceRepo *repository.PriceRepository,
+	statsRepo *repository.StatsRepository,
+	alertCfg config.AlertsConfig,
+	pricingCfg config.PricingConfig,
+) *Service {
+	return &Service{
+		alertRepo:     alertRepo,
+		componentRepo: componentRepo,
+		priceRepo:     priceRepo,
+		statsRepo:     statsRepo,
+		config:        alertCfg,
+		pricingConfig: pricingCfg,
+	}
+}
+
+func (s *Service) List(filter repository.AlertFilter, page, perPage int) ([]models.PricingAlert, int64, error) {
+	if page < 1 {
+		page = 1
+	}
+	if perPage < 1 || perPage > 100 {
+		perPage = 20
+	}
+	offset := (page - 1) * perPage
+
+	return s.alertRepo.List(filter, offset, perPage)
+}
+
+func (s *Service) Acknowledge(id uint) error {
+	return s.alertRepo.UpdateStatus(id, models.AlertStatusAcknowledged)
+}
+
+func (s *Service) Resolve(id uint) error {
+	return s.alertRepo.UpdateStatus(id, models.AlertStatusResolved)
+}
+
+func (s *Service) Ignore(id uint) error {
+	return s.alertRepo.UpdateStatus(id, models.AlertStatusIgnored)
+}
+
+func (s *Service) GetNewAlertsCount() (int64, error) {
+	return s.alertRepo.CountByStatus(models.AlertStatusNew)
+}
+
+// CheckAndGenerateAlerts scans components and creates alerts
+func (s *Service) CheckAndGenerateAlerts() error {
+	if !s.config.Enabled {
+		return nil
+	}
+
+	// Get top components by usage
+	topComponents, err := s.statsRepo.GetTopComponents(100)
+	if err != nil {
+		return err
+	}
+
+	for _, stats := range topComponents {
+		component, err := s.componentRepo.GetByLotName(stats.LotName)
+		if err != nil {
+			continue
+		}
+
+		// Check high demand + stale price
+		if err := s.checkHighDemandStalePrice(component, &stats); err != nil {
+			continue
+		}
+
+		// Check trending without price
+		if err := s.checkTrendingNoPrice(component, &stats); err != nil {
+			continue
+		}
+
+		// Check no recent quotes
+		if err := s.checkNoRecentQuotes(component, &stats); err != nil {
+			continue
+		}
+	}
+
+	return nil
+}
+
+func (s *Service) checkHighDemandStalePrice(comp *models.LotMetadata, stats *models.ComponentUsageStats) error {
+	// high_demand_stale_price: >= 5 quotes/month AND price > 60 days old
+	if stats.QuotesLast30d < s.config.HighDemandThreshold {
+		return nil
+	}
+
+	if comp.PriceUpdatedAt == nil {
+		return nil
+	}
+
+	daysSinceUpdate := int(time.Since(*comp.PriceUpdatedAt).Hours() / 24)
+	if daysSinceUpdate <= s.pricingConfig.FreshnessYellowDays {
+		return nil
+	}
+
+	// Check if alert already exists
+	exists, _ := s.alertRepo.ExistsByLotAndType(comp.LotName, models.AlertHighDemandStalePrice)
+	if exists {
+		return nil
+	}
+
+	alert := &models.PricingAlert{
+		LotName:   comp.LotName,
+		AlertType: models.AlertHighDemandStalePrice,
+		Severity:  models.SeverityCritical,
+		Message:   fmt.Sprintf("Компонент %s: высокий спрос (%d КП/мес), но цена устарела (%d дней)", comp.LotName, stats.QuotesLast30d, daysSinceUpdate),
+		Details: models.AlertDetails{
+			"quotes_30d":     stats.QuotesLast30d,
+			"days_since_update": daysSinceUpdate,
+		},
+	}
+
+	return s.alertRepo.Create(alert)
+}
+
+func (s *Service) checkTrendingNoPrice(comp *models.LotMetadata, stats *models.ComponentUsageStats) error {
+	// trending_no_price: trend > 50% AND no price
+	if stats.TrendDirection != models.TrendUp || stats.TrendPercent < float64(s.config.TrendingThresholdPercent) {
+		return nil
+	}
+
+	if comp.CurrentPrice != nil && *comp.CurrentPrice > 0 {
+		return nil
+	}
+
+	exists, _ := s.alertRepo.ExistsByLotAndType(comp.LotName, models.AlertTrendingNoPrice)
+	if exists {
+		return nil
+	}
+
+	alert := &models.PricingAlert{
+		LotName:   comp.LotName,
+		AlertType: models.AlertTrendingNoPrice,
+		Severity:  models.SeverityHigh,
+		Message:   fmt.Sprintf("Компонент %s: рост спроса +%.0f%%, но цена не установлена", comp.LotName, stats.TrendPercent),
+		Details: models.AlertDetails{
+			"trend_percent": stats.TrendPercent,
+		},
+	}
+
+	return s.alertRepo.Create(alert)
+}
+
+func (s *Service) checkNoRecentQuotes(comp *models.LotMetadata, stats *models.ComponentUsageStats) error {
+	// no_recent_quotes: popular component, no supplier quotes > 90 days
+	if stats.QuotesLast30d < 3 {
+		return nil
+	}
+
+	quoteCount, err := s.priceRepo.GetQuoteCount(comp.LotName, s.pricingConfig.FreshnessRedDays)
+	if err != nil {
+		return err
+	}
+
+	if quoteCount > 0 {
+		return nil
+	}
+
+	exists, _ := s.alertRepo.ExistsByLotAndType(comp.LotName, models.AlertNoRecentQuotes)
+	if exists {
+		return nil
+	}
+
+	alert := &models.PricingAlert{
+		LotName:   comp.LotName,
+		AlertType: models.AlertNoRecentQuotes,
+		Severity:  models.SeverityMedium,
+		Message:   fmt.Sprintf("Компонент %s: популярный (%d КП), но нет новых котировок >%d дней", comp.LotName, stats.QuotesLast30d, s.pricingConfig.FreshnessRedDays),
+		Details: models.AlertDetails{
+			"quotes_30d":       stats.QuotesLast30d,
+			"no_quotes_days": s.pricingConfig.FreshnessRedDays,
+		},
+	}
+
+	return s.alertRepo.Create(alert)
+}

internal/services/auth.go

@@ -0,0 +1,180 @@
+package services
+
+import (
+	"errors"
+	"time"
+
+	"github.com/golang-jwt/jwt/v5"
+	"github.com/mchus/quoteforge/internal/config"
+	"github.com/mchus/quoteforge/internal/models"
+	"github.com/mchus/quoteforge/internal/repository"
+	"golang.org/x/crypto/bcrypt"
+)
+
+var (
+	ErrInvalidCredentials = errors.New("invalid username or password")
+	ErrUserNotFound       = errors.New("user not found")
+	ErrUserInactive       = errors.New("user account is inactive")
+	ErrInvalidToken       = errors.New("invalid token")
+	ErrTokenExpired       = errors.New("token expired")
+)
+
+type AuthService struct {
+	userRepo *repository.UserRepository
+	config   config.AuthConfig
+}
+
+func NewAuthService(userRepo *repository.UserRepository, cfg config.AuthConfig) *AuthService {
+	return &AuthService{
+		userRepo: userRepo,
+		config:   cfg,
+	}
+}
+
+type TokenPair struct {
+	AccessToken  string `json:"access_token"`
+	RefreshToken string `json:"refresh_token"`
+	ExpiresAt    int64  `json:"expires_at"`
+}
+
+type Claims struct {
+	UserID   uint            `json:"user_id"`
+	Username string          `json:"username"`
+	Role     models.UserRole `json:"role"`
+	jwt.RegisteredClaims
+}
+
+func (s *AuthService) Login(username, password string) (*TokenPair, *models.User, error) {
+	user, err := s.userRepo.GetByUsername(username)
+	if err != nil {
+		return nil, nil, ErrInvalidCredentials
+	}
+
+	if !user.IsActive {
+		return nil, nil, ErrUserInactive
+	}
+
+	if err := bcrypt.CompareHashAndPassword([]byte(user.PasswordHash), []byte(password)); err != nil {
+		return nil, nil, ErrInvalidCredentials
+	}
+
+	tokens, err := s.generateTokenPair(user)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	return tokens, user, nil
+}
+
+func (s *AuthService) RefreshTokens(refreshToken string) (*TokenPair, error) {
+	claims, err := s.ValidateToken(refreshToken)
+	if err != nil {
+		return nil, err
+	}
+
+	user, err := s.userRepo.GetByID(claims.UserID)
+	if err != nil {
+		return nil, ErrUserNotFound
+	}
+
+	if !user.IsActive {
+		return nil, ErrUserInactive
+	}
+
+	return s.generateTokenPair(user)
+}
+
+func (s *AuthService) ValidateToken(tokenString string) (*Claims, error) {
+	token, err := jwt.ParseWithClaims(tokenString, &Claims{}, func(token *jwt.Token) (interface{}, error) {
+		return []byte(s.config.JWTSecret), nil
+	})
+
+	if err != nil {
+		if errors.Is(err, jwt.ErrTokenExpired) {
+			return nil, ErrTokenExpired
+		}
+		return nil, ErrInvalidToken
+	}
+
+	claims, ok := token.Claims.(*Claims)
+	if !ok || !token.Valid {
+		return nil, ErrInvalidToken
+	}
+
+	return claims, nil
+}
+
+func (s *AuthService) generateTokenPair(user *models.User) (*TokenPair, error) {
+	now := time.Now()
+	accessExpiry := now.Add(s.config.TokenExpiry)
+	refreshExpiry := now.Add(s.config.RefreshExpiry)
+
+	accessClaims := &Claims{
+		UserID:   user.ID,
+		Username: user.Username,
+		Role:     user.Role,
+		RegisteredClaims: jwt.RegisteredClaims{
+			ExpiresAt: jwt.NewNumericDate(accessExpiry),
+			IssuedAt:  jwt.NewNumericDate(now),
+			Subject:   user.Username,
+		},
+	}
+
+	accessToken := jwt.NewWithClaims(jwt.SigningMethodHS256, accessClaims)
+	accessTokenString, err := accessToken.SignedString([]byte(s.config.JWTSecret))
+	if err != nil {
+		return nil, err
+	}
+
+	refreshClaims := &Claims{
+		UserID:   user.ID,
+		Username: user.Username,
+		Role:     user.Role,
+		RegisteredClaims: jwt.RegisteredClaims{
+			ExpiresAt: jwt.NewNumericDate(refreshExpiry),
+			IssuedAt:  jwt.NewNumericDate(now),
+			Subject:   user.Username,
+		},
+	}
+
+	refreshToken := jwt.NewWithClaims(jwt.SigningMethodHS256, refreshClaims)
+	refreshTokenString, err := refreshToken.SignedString([]byte(s.config.JWTSecret))
+	if err != nil {
+		return nil, err
+	}
+
+	return &TokenPair{
+		AccessToken:  accessTokenString,
+		RefreshToken: refreshTokenString,
+		ExpiresAt:    accessExpiry.Unix(),
+	}, nil
+}
+
+func (s *AuthService) HashPassword(password string) (string, error) {
+	hash, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
+	if err != nil {
+		return "", err
+	}
+	return string(hash), nil
+}
+
+func (s *AuthService) CreateUser(username, email, password string, role models.UserRole) (*models.User, error) {
+	hash, err := s.HashPassword(password)
+	if err != nil {
+		return nil, err
+	}
+
+	user := &models.User{
+		Username:     username,
+		Email:        email,
+		PasswordHash: hash,
+		Role:         role,
+		IsActive:     true,
+	}
+
+	if err := s.userRepo.Create(user); err != nil {
+		return nil, err
+	}
+
+	return user, nil
+}

internal/services/component.go

@@ -0,0 +1,187 @@
+package services
+
+import (
+	"strings"
+
+	"github.com/mchus/quoteforge/internal/models"
+	"github.com/mchus/quoteforge/internal/repository"
+)
+
+type ComponentService struct {
+	componentRepo *repository.ComponentRepository
+	categoryRepo  *repository.CategoryRepository
+	statsRepo     *repository.StatsRepository
+}
+
+func NewComponentService(
+	componentRepo *repository.ComponentRepository,
+	categoryRepo *repository.CategoryRepository,
+	statsRepo *repository.StatsRepository,
+) *ComponentService {
+	return &ComponentService{
+		componentRepo: componentRepo,
+		categoryRepo:  categoryRepo,
+		statsRepo:     statsRepo,
+	}
+}
+
+// ParsePartNumber extracts category, vendor, model from lot_name
+// "CPU_AMD_9654" → category="CPU", vendor="AMD", model="9654"
+// "MB_INTEL_4.Sapphire_2S_32xDDR5" → category="MB", vendor="INTEL", model="4.Sapphire_2S_32xDDR5"
+func ParsePartNumber(lotName string) (category, vendor, model string) {
+	parts := strings.SplitN(lotName, "_", 3)
+	if len(parts) >= 1 {
+		category = parts[0]
+	}
+	if len(parts) >= 2 {
+		vendor = parts[1]
+	}
+	if len(parts) >= 3 {
+		model = parts[2]
+	}
+	return
+}
+
+type ComponentListResult struct {
+	Components []ComponentView `json:"components"`
+	Total      int64           `json:"total"`
+	Page       int             `json:"page"`
+	PerPage    int             `json:"per_page"`
+}
+
+type ComponentView struct {
+	LotName         string                  `json:"lot_name"`
+	Description     string                  `json:"description"`
+	Category        string                  `json:"category"`
+	CategoryName    string                  `json:"category_name"`
+	Vendor          string                  `json:"vendor"`
+	Model           string                  `json:"model"`
+	CurrentPrice    *float64                `json:"current_price"`
+	PriceFreshness  models.PriceFreshness   `json:"price_freshness"`
+	PopularityScore float64                 `json:"popularity_score"`
+	Specs           models.Specs            `json:"specs,omitempty"`
+}
+
+func (s *ComponentService) List(filter repository.ComponentFilter, page, perPage int) (*ComponentListResult, error) {
+	if page < 1 {
+		page = 1
+	}
+	if perPage < 1 || perPage > 100 {
+		perPage = 20
+	}
+	offset := (page - 1) * perPage
+
+	components, total, err := s.componentRepo.List(filter, offset, perPage)
+	if err != nil {
+		return nil, err
+	}
+
+	views := make([]ComponentView, len(components))
+	for i, c := range components {
+		view := ComponentView{
+			LotName:         c.LotName,
+			Vendor:          c.Vendor,
+			Model:           c.Model,
+			CurrentPrice:    c.CurrentPrice,
+			PriceFreshness:  c.GetPriceFreshness(30, 60, 90, 3),
+			PopularityScore: c.PopularityScore,
+			Specs:           c.Specs,
+		}
+
+		if c.Lot != nil {
+			view.Description = c.Lot.LotDescription
+		}
+		if c.Category != nil {
+			view.Category = c.Category.Code
+			view.CategoryName = c.Category.Name
+		}
+
+		views[i] = view
+	}
+
+	return &ComponentListResult{
+		Components: views,
+		Total:      total,
+		Page:       page,
+		PerPage:    perPage,
+	}, nil
+}
+
+func (s *ComponentService) GetByLotName(lotName string) (*ComponentView, error) {
+	c, err := s.componentRepo.GetByLotName(lotName)
+	if err != nil {
+		return nil, err
+	}
+
+	// Track usage
+	_ = s.componentRepo.IncrementRequestCount(lotName)
+
+	view := &ComponentView{
+		LotName:         c.LotName,
+		Vendor:          c.Vendor,
+		Model:           c.Model,
+		CurrentPrice:    c.CurrentPrice,
+		PriceFreshness:  c.GetPriceFreshness(30, 60, 90, 3),
+		PopularityScore: c.PopularityScore,
+		Specs:           c.Specs,
+	}
+
+	if c.Lot != nil {
+		view.Description = c.Lot.LotDescription
+	}
+	if c.Category != nil {
+		view.Category = c.Category.Code
+		view.CategoryName = c.Category.Name
+	}
+
+	return view, nil
+}
+
+func (s *ComponentService) GetCategories() ([]models.Category, error) {
+	return s.categoryRepo.GetAll()
+}
+
+func (s *ComponentService) GetVendors(category string) ([]string, error) {
+	return s.componentRepo.GetVendors(category)
+}
+
+// ImportFromLot creates metadata entries for lots that don't have them
+func (s *ComponentService) ImportFromLot() (int, error) {
+	lots, err := s.componentRepo.GetLotsWithoutMetadata()
+	if err != nil {
+		return 0, err
+	}
+
+	categories, err := s.categoryRepo.GetAll()
+	if err != nil {
+		return 0, err
+	}
+
+	categoryMap := make(map[string]uint)
+	for _, cat := range categories {
+		categoryMap[cat.Code] = cat.ID
+	}
+
+	imported := 0
+	for _, lot := range lots {
+		category, vendor, model := ParsePartNumber(lot.LotName)
+
+		metadata := &models.LotMetadata{
+			LotName: lot.LotName,
+			Vendor:  vendor,
+			Model:   model,
+			Specs:   make(models.Specs),
+		}
+
+		if catID, ok := categoryMap[category]; ok {
+			metadata.CategoryID = &catID
+		}
+
+		if err := s.componentRepo.Create(metadata); err != nil {
+			continue
+		}
+		imported++
+	}
+
+	return imported, nil
+}

internal/services/configuration.go

@@ -0,0 +1,176 @@
+package services
+
+import (
+	"encoding/json"
+	"errors"
+
+	"github.com/google/uuid"
+	"github.com/mchus/quoteforge/internal/models"
+	"github.com/mchus/quoteforge/internal/repository"
+)
+
+var (
+	ErrConfigNotFound   = errors.New("configuration not found")
+	ErrConfigForbidden  = errors.New("access to configuration forbidden")
+)
+
+type ConfigurationService struct {
+	configRepo    *repository.ConfigurationRepository
+	componentRepo *repository.ComponentRepository
+	quoteService  *QuoteService
+}
+
+func NewConfigurationService(
+	configRepo *repository.ConfigurationRepository,
+	componentRepo *repository.ComponentRepository,
+	quoteService *QuoteService,
+) *ConfigurationService {
+	return &ConfigurationService{
+		configRepo:    configRepo,
+		componentRepo: componentRepo,
+		quoteService:  quoteService,
+	}
+}
+
+type CreateConfigRequest struct {
+	Name       string              `json:"name"`
+	Items      models.ConfigItems  `json:"items"`
+	Notes      string              `json:"notes"`
+	IsTemplate bool                `json:"is_template"`
+}
+
+func (s *ConfigurationService) Create(userID uint, req *CreateConfigRequest) (*models.Configuration, error) {
+	total := req.Items.Total()
+
+	config := &models.Configuration{
+		UUID:       uuid.New().String(),
+		UserID:     userID,
+		Name:       req.Name,
+		Items:      req.Items,
+		TotalPrice: &total,
+		Notes:      req.Notes,
+		IsTemplate: req.IsTemplate,
+	}
+
+	if err := s.configRepo.Create(config); err != nil {
+		return nil, err
+	}
+
+	// Record usage stats
+	_ = s.quoteService.RecordUsage(req.Items)
+
+	return config, nil
+}
+
+func (s *ConfigurationService) GetByUUID(uuid string, userID uint) (*models.Configuration, error) {
+	config, err := s.configRepo.GetByUUID(uuid)
+	if err != nil {
+		return nil, ErrConfigNotFound
+	}
+
+	// Allow access if user owns config or it's a template
+	if config.UserID != userID && !config.IsTemplate {
+		return nil, ErrConfigForbidden
+	}
+
+	return config, nil
+}
+
+func (s *ConfigurationService) Update(uuid string, userID uint, req *CreateConfigRequest) (*models.Configuration, error) {
+	config, err := s.configRepo.GetByUUID(uuid)
+	if err != nil {
+		return nil, ErrConfigNotFound
+	}
+
+	if config.UserID != userID {
+		return nil, ErrConfigForbidden
+	}
+
+	total := req.Items.Total()
+
+	config.Name = req.Name
+	config.Items = req.Items
+	config.TotalPrice = &total
+	config.Notes = req.Notes
+	config.IsTemplate = req.IsTemplate
+
+	if err := s.configRepo.Update(config); err != nil {
+		return nil, err
+	}
+
+	return config, nil
+}
+
+func (s *ConfigurationService) Delete(uuid string, userID uint) error {
+	config, err := s.configRepo.GetByUUID(uuid)
+	if err != nil {
+		return ErrConfigNotFound
+	}
+
+	if config.UserID != userID {
+		return ErrConfigForbidden
+	}
+
+	return s.configRepo.Delete(config.ID)
+}
+
+func (s *ConfigurationService) ListByUser(userID uint, page, perPage int) ([]models.Configuration, int64, error) {
+	if page < 1 {
+		page = 1
+	}
+	if perPage < 1 || perPage > 100 {
+		perPage = 20
+	}
+	offset := (page - 1) * perPage
+
+	return s.configRepo.ListByUser(userID, offset, perPage)
+}
+
+func (s *ConfigurationService) ListTemplates(page, perPage int) ([]models.Configuration, int64, error) {
+	if page < 1 {
+		page = 1
+	}
+	if perPage < 1 || perPage > 100 {
+		perPage = 20
+	}
+	offset := (page - 1) * perPage
+
+	return s.configRepo.ListTemplates(offset, perPage)
+}
+
+// Export configuration as JSON
+type ConfigExport struct {
+	Name  string             `json:"name"`
+	Notes string             `json:"notes"`
+	Items models.ConfigItems `json:"items"`
+}
+
+func (s *ConfigurationService) ExportJSON(uuid string, userID uint) ([]byte, error) {
+	config, err := s.GetByUUID(uuid, userID)
+	if err != nil {
+		return nil, err
+	}
+
+	export := ConfigExport{
+		Name:  config.Name,
+		Notes: config.Notes,
+		Items: config.Items,
+	}
+
+	return json.MarshalIndent(export, "", "  ")
+}
+
+func (s *ConfigurationService) ImportJSON(userID uint, data []byte) (*models.Configuration, error) {
+	var export ConfigExport
+	if err := json.Unmarshal(data, &export); err != nil {
+		return nil, err
+	}
+
+	req := &CreateConfigRequest{
+		Name:  export.Name,
+		Notes: export.Notes,
+		Items: export.Items,
+	}
+
+	return s.Create(userID, req)
+}

internal/services/export.go

@@ -0,0 +1,175 @@
+package services
+
+import (
+	"bytes"
+	"encoding/csv"
+	"fmt"
+	"time"
+
+	"github.com/mchus/quoteforge/internal/config"
+	"github.com/mchus/quoteforge/internal/models"
+	"github.com/xuri/excelize/v2"
+)
+
+type ExportService struct {
+	config config.ExportConfig
+}
+
+func NewExportService(cfg config.ExportConfig) *ExportService {
+	return &ExportService{config: cfg}
+}
+
+type ExportData struct {
+	Name       string
+	Items      []ExportItem
+	Total      float64
+	Notes      string
+	CreatedAt  time.Time
+}
+
+type ExportItem struct {
+	LotName     string
+	Description string
+	Category    string
+	Quantity    int
+	UnitPrice   float64
+	TotalPrice  float64
+}
+
+func (s *ExportService) ToCSV(data *ExportData) ([]byte, error) {
+	var buf bytes.Buffer
+	w := csv.NewWriter(&buf)
+
+	// Header
+	headers := []string{"Артикул", "Описание", "Категория", "Количество", "Цена за единицу", "Сумма"}
+	if err := w.Write(headers); err != nil {
+		return nil, err
+	}
+
+	// Items
+	for _, item := range data.Items {
+		row := []string{
+			item.LotName,
+			item.Description,
+			item.Category,
+			fmt.Sprintf("%d", item.Quantity),
+			fmt.Sprintf("%.2f", item.UnitPrice),
+			fmt.Sprintf("%.2f", item.TotalPrice),
+		}
+		if err := w.Write(row); err != nil {
+			return nil, err
+		}
+	}
+
+	// Total row
+	if err := w.Write([]string{"", "", "", "", "ИТОГО:", fmt.Sprintf("%.2f", data.Total)}); err != nil {
+		return nil, err
+	}
+
+	w.Flush()
+	return buf.Bytes(), w.Error()
+}
+
+func (s *ExportService) ToXLSX(data *ExportData) ([]byte, error) {
+	f := excelize.NewFile()
+	sheet := "Конфигурация"
+	f.SetSheetName("Sheet1", sheet)
+
+	// Styles
+	headerStyle, _ := f.NewStyle(&excelize.Style{
+		Font:      &excelize.Font{Bold: true, Size: 12, Color: "#FFFFFF"},
+		Fill:      excelize.Fill{Type: "pattern", Color: []string{"#4472C4"}, Pattern: 1},
+		Alignment: &excelize.Alignment{Horizontal: "center", Vertical: "center"},
+		Border: []excelize.Border{
+			{Type: "left", Color: "#000000", Style: 1},
+			{Type: "top", Color: "#000000", Style: 1},
+			{Type: "bottom", Color: "#000000", Style: 1},
+			{Type: "right", Color: "#000000", Style: 1},
+		},
+	})
+
+	totalStyle, _ := f.NewStyle(&excelize.Style{
+		Font: &excelize.Font{Bold: true, Size: 12},
+		Fill: excelize.Fill{Type: "pattern", Color: []string{"#E2EFDA"}, Pattern: 1},
+	})
+
+	priceStyle, _ := f.NewStyle(&excelize.Style{
+		NumFmt: 4, // #,##0.00
+	})
+
+	// Title
+	f.SetCellValue(sheet, "A1", s.config.CompanyName)
+	f.SetCellValue(sheet, "A2", "Коммерческое предложение: "+data.Name)
+	f.SetCellValue(sheet, "A3", "Дата: "+data.CreatedAt.Format("02.01.2006"))
+
+	// Headers
+	headers := []string{"Артикул", "Описание", "Категория", "Кол-во", "Цена", "Сумма"}
+	for i, h := range headers {
+		cell := fmt.Sprintf("%c5", 'A'+i)
+		f.SetCellValue(sheet, cell, h)
+		f.SetCellStyle(sheet, cell, cell, headerStyle)
+	}
+
+	// Data rows
+	row := 6
+	for _, item := range data.Items {
+		f.SetCellValue(sheet, fmt.Sprintf("A%d", row), item.LotName)
+		f.SetCellValue(sheet, fmt.Sprintf("B%d", row), item.Description)
+		f.SetCellValue(sheet, fmt.Sprintf("C%d", row), item.Category)
+		f.SetCellValue(sheet, fmt.Sprintf("D%d", row), item.Quantity)
+		f.SetCellValue(sheet, fmt.Sprintf("E%d", row), item.UnitPrice)
+		f.SetCellValue(sheet, fmt.Sprintf("F%d", row), item.TotalPrice)
+		f.SetCellStyle(sheet, fmt.Sprintf("E%d", row), fmt.Sprintf("F%d", row), priceStyle)
+		row++
+	}
+
+	// Total row
+	f.SetCellValue(sheet, fmt.Sprintf("E%d", row), "ИТОГО:")
+	f.SetCellValue(sheet, fmt.Sprintf("F%d", row), data.Total)
+	f.SetCellStyle(sheet, fmt.Sprintf("E%d", row), fmt.Sprintf("F%d", row), totalStyle)
+
+	// Notes
+	if data.Notes != "" {
+		row += 2
+		f.SetCellValue(sheet, fmt.Sprintf("A%d", row), "Примечания: "+data.Notes)
+	}
+
+	// Column widths
+	f.SetColWidth(sheet, "A", "A", 25)
+	f.SetColWidth(sheet, "B", "B", 50)
+	f.SetColWidth(sheet, "C", "C", 15)
+	f.SetColWidth(sheet, "D", "D", 10)
+	f.SetColWidth(sheet, "E", "E", 15)
+	f.SetColWidth(sheet, "F", "F", 15)
+
+	var buf bytes.Buffer
+	if err := f.Write(&buf); err != nil {
+		return nil, err
+	}
+
+	return buf.Bytes(), nil
+}
+
+func (s *ExportService) ConfigToExportData(config *models.Configuration) *ExportData {
+	items := make([]ExportItem, len(config.Items))
+	var total float64
+
+	for i, item := range config.Items {
+		itemTotal := item.UnitPrice * float64(item.Quantity)
+		items[i] = ExportItem{
+			LotName:    item.LotName,
+			Quantity:   item.Quantity,
+			UnitPrice:  item.UnitPrice,
+			TotalPrice: itemTotal,
+		}
+		total += itemTotal
+	}
+
+	return &ExportData{
+		Name:      config.Name,
+		Items:     items,
+		Total:     total,
+		Notes:     config.Notes,
+		CreatedAt: config.CreatedAt,
+	}
+}

internal/services/pricing/calculator.go

@@ -0,0 +1,121 @@
+package pricing
+
+import (
+	"math"
+	"sort"
+	"time"
+
+	"github.com/mchus/quoteforge/internal/repository"
+)
+
+// CalculateMedian returns the median of prices
+func CalculateMedian(prices []float64) float64 {
+	if len(prices) == 0 {
+		return 0
+	}
+
+	sorted := make([]float64, len(prices))
+	copy(sorted, prices)
+	sort.Float64s(sorted)
+
+	n := len(sorted)
+	if n%2 == 0 {
+		return (sorted[n/2-1] + sorted[n/2]) / 2
+	}
+	return sorted[n/2]
+}
+
+// CalculateAverage returns the arithmetic mean of prices
+func CalculateAverage(prices []float64) float64 {
+	if len(prices) == 0 {
+		return 0
+	}
+
+	var sum float64
+	for _, p := range prices {
+		sum += p
+	}
+	return sum / float64(len(prices))
+}
+
+// CalculateWeightedMedian calculates median with exponential decay weights
+// More recent prices have higher weight
+func CalculateWeightedMedian(points []repository.PricePoint, decayDays int) float64 {
+	if len(points) == 0 {
+		return 0
+	}
+
+	type weightedPrice struct {
+		price  float64
+		weight float64
+	}
+
+	now := time.Now()
+	weighted := make([]weightedPrice, len(points))
+	var totalWeight float64
+
+	for i, p := range points {
+		daysSince := now.Sub(p.Date).Hours() / 24
+		// weight = e^(-days / decay_days)
+		weight := math.Exp(-daysSince / float64(decayDays))
+		weighted[i] = weightedPrice{price: p.Price, weight: weight}
+		totalWeight += weight
+	}
+
+	// Sort by price
+	sort.Slice(weighted, func(i, j int) bool {
+		return weighted[i].price < weighted[j].price
+	})
+
+	// Find weighted median
+	targetWeight := totalWeight / 2
+	var cumulativeWeight float64
+
+	for _, wp := range weighted {
+		cumulativeWeight += wp.weight
+		if cumulativeWeight >= targetWeight {
+			return wp.price
+		}
+	}
+
+	return weighted[len(weighted)-1].price
+}
+
+// CalculatePercentile calculates the nth percentile of prices
+func CalculatePercentile(prices []float64, percentile float64) float64 {
+	if len(prices) == 0 {
+		return 0
+	}
+
+	sorted := make([]float64, len(prices))
+	copy(sorted, prices)
+	sort.Float64s(sorted)
+
+	index := (percentile / 100) * float64(len(sorted)-1)
+	lower := int(math.Floor(index))
+	upper := int(math.Ceil(index))
+
+	if lower == upper {
+		return sorted[lower]
+	}
+
+	fraction := index - float64(lower)
+	return sorted[lower]*(1-fraction) + sorted[upper]*fraction
+}
+
+// CalculateStdDev calculates standard deviation
+func CalculateStdDev(prices []float64) float64 {
+	if len(prices) < 2 {
+		return 0
+	}
+
+	mean := CalculateAverage(prices)
+	var sumSquares float64
+
+	for _, p := range prices {
+		diff := p - mean
+		sumSquares += diff * diff
+	}
+
+	return math.Sqrt(sumSquares / float64(len(prices)-1))
+}

internal/services/pricing/service.go

@@ -0,0 +1,178 @@
+package pricing
+
+import (
+	"time"
+
+	"github.com/mchus/quoteforge/internal/config"
+	"github.com/mchus/quoteforge/internal/models"
+	"github.com/mchus/quoteforge/internal/repository"
+)
+
+type Service struct {
+	componentRepo *repository.ComponentRepository
+	priceRepo     *repository.PriceRepository
+	config        config.PricingConfig
+}
+
+func NewService(
+	componentRepo *repository.ComponentRepository,
+	priceRepo *repository.PriceRepository,
+	cfg config.PricingConfig,
+) *Service {
+	return &Service{
+		componentRepo: componentRepo,
+		priceRepo:     priceRepo,
+		config:        cfg,
+	}
+}
+
+// GetEffectivePrice returns the current effective price for a component
+// Priority: active override > calculated price > nil
+func (s *Service) GetEffectivePrice(lotName string) (*float64, error) {
+	// Check for active override first
+	override, err := s.priceRepo.GetPriceOverride(lotName)
+	if err == nil && override != nil {
+		return &override.Price, nil
+	}
+
+	// Get component metadata
+	component, err := s.componentRepo.GetByLotName(lotName)
+	if err != nil {
+		return nil, err
+	}
+
+	return component.CurrentPrice, nil
+}
+
+// CalculatePrice calculates price using the specified method
+func (s *Service) CalculatePrice(lotName string, method models.PriceMethod, periodDays int) (float64, error) {
+	if periodDays == 0 {
+		periodDays = s.config.DefaultPeriodDays
+	}
+
+	points, err := s.priceRepo.GetPriceHistory(lotName, periodDays)
+	if err != nil {
+		return 0, err
+	}
+
+	if len(points) == 0 {
+		return 0, nil
+	}
+
+	prices := make([]float64, len(points))
+	for i, p := range points {
+		prices[i] = p.Price
+	}
+
+	switch method {
+	case models.PriceMethodAverage:
+		return CalculateAverage(prices), nil
+	case models.PriceMethodWeightedMedian:
+		return CalculateWeightedMedian(points, s.config.DefaultPeriodDays), nil
+	case models.PriceMethodMedian:
+		fallthrough
+	default:
+		return CalculateMedian(prices), nil
+	}
+}
+
+// UpdateComponentPrice recalculates and updates the price for a component
+func (s *Service) UpdateComponentPrice(lotName string) error {
+	component, err := s.componentRepo.GetByLotName(lotName)
+	if err != nil {
+		return err
+	}
+
+	price, err := s.CalculatePrice(lotName, component.PriceMethod, component.PricePeriodDays)
+	if err != nil {
+		return err
+	}
+
+	now := time.Now()
+	if price > 0 {
+		component.CurrentPrice = &price
+		component.PriceUpdatedAt = &now
+	}
+
+	return s.componentRepo.Update(component)
+}
+
+// SetManualPrice sets a manual price override
+func (s *Service) SetManualPrice(lotName string, price float64, reason string, userID uint) error {
+	override := &models.PriceOverride{
+		LotName:   lotName,
+		Price:     price,
+		ValidFrom: time.Now(),
+		Reason:    reason,
+		CreatedBy: userID,
+	}
+	return s.priceRepo.CreatePriceOverride(override)
+}
+
+// UpdatePriceMethod changes the pricing method for a component
+func (s *Service) UpdatePriceMethod(lotName string, method models.PriceMethod, periodDays int) error {
+	component, err := s.componentRepo.GetByLotName(lotName)
+	if err != nil {
+		return err
+	}
+
+	component.PriceMethod = method
+	if periodDays > 0 {
+		component.PricePeriodDays = periodDays
+	}
+
+	if err := s.componentRepo.Update(component); err != nil {
+		return err
+	}
+
+	return s.UpdateComponentPrice(lotName)
+}
+
+// GetPriceStats returns statistics for a component's price history
+func (s *Service) GetPriceStats(lotName string, periodDays int) (*PriceStats, error) {
+	if periodDays == 0 {
+		periodDays = s.config.DefaultPeriodDays
+	}
+
+	points, err := s.priceRepo.GetPriceHistory(lotName, periodDays)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(points) == 0 {
+		return &PriceStats{QuoteCount: 0}, nil
+	}
+
+	prices := make([]float64, len(points))
+	for i, p := range points {
+		prices[i] = p.Price
+	}
+
+	return &PriceStats{
+		QuoteCount:    len(points),
+		MinPrice:      CalculatePercentile(prices, 0),
+		MaxPrice:      CalculatePercentile(prices, 100),
+		MedianPrice:   CalculateMedian(prices),
+		AveragePrice:  CalculateAverage(prices),
+		StdDeviation:  CalculateStdDev(prices),
+		LatestPrice:   points[0].Price,
+		LatestDate:    points[0].Date,
+		OldestDate:    points[len(points)-1].Date,
+		Percentile25:  CalculatePercentile(prices, 25),
+		Percentile75:  CalculatePercentile(prices, 75),
+	}, nil
+}
+
+type PriceStats struct {
+	QuoteCount   int       `json:"quote_count"`
+	MinPrice     float64   `json:"min_price"`
+	MaxPrice     float64   `json:"max_price"`
+	MedianPrice  float64   `json:"median_price"`
+	AveragePrice float64   `json:"average_price"`
+	StdDeviation float64   `json:"std_deviation"`
+	LatestPrice  float64   `json:"latest_price"`
+	LatestDate   time.Time `json:"latest_date"`
+	OldestDate   time.Time `json:"oldest_date"`
+	Percentile25 float64   `json:"percentile_25"`
+	Percentile75 float64   `json:"percentile_75"`
+}

internal/services/quote.go

@@ -0,0 +1,139 @@
+package services
+
+import (
+	"errors"
+
+	"github.com/mchus/quoteforge/internal/models"
+	"github.com/mchus/quoteforge/internal/repository"
+	"github.com/mchus/quoteforge/internal/services/pricing"
+)
+
+var (
+	ErrEmptyQuote       = errors.New("quote cannot be empty")
+	ErrComponentNotFound = errors.New("component not found")
+	ErrNoPriceAvailable  = errors.New("no price available for component")
+)
+
+type QuoteService struct {
+	componentRepo *repository.ComponentRepository
+	statsRepo     *repository.StatsRepository
+	pricingService *pricing.Service
+}
+
+func NewQuoteService(
+	componentRepo *repository.ComponentRepository,
+	statsRepo *repository.StatsRepository,
+	pricingService *pricing.Service,
+) *QuoteService {
+	return &QuoteService{
+		componentRepo:  componentRepo,
+		statsRepo:      statsRepo,
+		pricingService: pricingService,
+	}
+}
+
+type QuoteItem struct {
+	LotName     string  `json:"lot_name"`
+	Quantity    int     `json:"quantity"`
+	UnitPrice   float64 `json:"unit_price"`
+	TotalPrice  float64 `json:"total_price"`
+	Description string  `json:"description"`
+	Category    string  `json:"category"`
+	HasPrice    bool    `json:"has_price"`
+}
+
+type QuoteValidationResult struct {
+	Valid    bool          `json:"valid"`
+	Items    []QuoteItem   `json:"items"`
+	Errors   []string      `json:"errors"`
+	Warnings []string      `json:"warnings"`
+	Total    float64       `json:"total"`
+}
+
+type QuoteRequest struct {
+	Items []struct {
+		LotName  string `json:"lot_name"`
+		Quantity int    `json:"quantity"`
+	} `json:"items"`
+}
+
+func (s *QuoteService) ValidateAndCalculate(req *QuoteRequest) (*QuoteValidationResult, error) {
+	if len(req.Items) == 0 {
+		return nil, ErrEmptyQuote
+	}
+
+	result := &QuoteValidationResult{
+		Valid:    true,
+		Items:    make([]QuoteItem, 0, len(req.Items)),
+		Errors:   make([]string, 0),
+		Warnings: make([]string, 0),
+	}
+
+	lotNames := make([]string, len(req.Items))
+	quantities := make(map[string]int)
+	for i, item := range req.Items {
+		lotNames[i] = item.LotName
+		quantities[item.LotName] = item.Quantity
+	}
+
+	components, err := s.componentRepo.GetMultiple(lotNames)
+	if err != nil {
+		return nil, err
+	}
+
+	componentMap := make(map[string]*models.LotMetadata)
+	for i := range components {
+		componentMap[components[i].LotName] = &components[i]
+	}
+
+	var total float64
+
+	for _, reqItem := range req.Items {
+		comp, exists := componentMap[reqItem.LotName]
+		if !exists {
+			result.Valid = false
+			result.Errors = append(result.Errors, "Component not found: "+reqItem.LotName)
+			continue
+		}
+
+		item := QuoteItem{
+			LotName:  reqItem.LotName,
+			Quantity: reqItem.Quantity,
+			HasPrice: false,
+		}
+
+		if comp.Lot != nil {
+			item.Description = comp.Lot.LotDescription
+		}
+		if comp.Category != nil {
+			item.Category = comp.Category.Code
+		}
+
+		// Get effective price (override or calculated)
+		price, err := s.pricingService.GetEffectivePrice(reqItem.LotName)
+		if err == nil && price != nil && *price > 0 {
+			item.UnitPrice = *price
+			item.TotalPrice = *price * float64(reqItem.Quantity)
+			item.HasPrice = true
+			total += item.TotalPrice
+		} else {
+			result.Warnings = append(result.Warnings, "No price available for: "+reqItem.LotName)
+		}
+
+		result.Items = append(result.Items, item)
+	}
+
+	result.Total = total
+	return result, nil
+}
+
+// RecordUsage records that components were used in a quote
+func (s *QuoteService) RecordUsage(items []models.ConfigItem) error {
+	for _, item := range items {
+		revenue := item.UnitPrice * float64(item.Quantity)
+		if err := s.statsRepo.IncrementUsage(item.LotName, item.Quantity, revenue); err != nil {
+			return err
+		}
+	}
+	return nil
+}