Add cron job functionality and Docker integration

Update documentation to reflect actual implementation
delete dangling files
2026-01-31 00:31:43 +03:00 · 2026-01-31 00:06:46 +03:00 · 2026-01-30 23:51:24 +03:00 · 2026-01-30 22:49:11 +03:00 · 2026-01-30 20:49:59 +03:00 · 2026-01-30 17:48:44 +03:00
54 changed files with 8720 additions and 22 deletions
--- a/.dockerignore
+++ b/.dockerignore
@@ -0,0 +1,33 @@
+# Git
+.git
+.gitignore
+
+# IDE
+.idea
+.vscode
+*.swp
+*.swo
+
+# Build artifacts
+server
+*.exe
+bin/
+
+# Config with secrets
+config.yaml
+
+# Documentation
+*.md
+LICENSE
+
+# Claude
+.claude
+
+# Test files
+*_test.go
+test_*.csv
+test_*.xlsx
+
+# Misc
+.DS_Store
+*.log
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -0,0 +1,388 @@
+# QuoteForge - Claude Code Instructions
+
+## Project Overview
+
+QuoteForge — корпоративный инструмент для конфигурирования серверов и формирования коммерческих предложений (КП). Приложение интегрируется с существующей базой данных RFQ_LOG.
+
+## Tech Stack
+
+- **Language:** Go 1.22+
+- **Web Framework:** Gin (github.com/gin-gonic/gin)
+- **ORM:** GORM (gorm.io/gorm)
+- **Database:** MariaDB 11 (existing database RFQ_LOG)
+- **Frontend:** HTML templates + htmx + Tailwind CSS (CDN)
+- **Excel Export:** excelize (github.com/xuri/excelize/v2)
+- **Auth:** JWT (github.com/golang-jwt/jwt/v5)
+
+## Project Structure
+
+```
+quoteforge/
+├── cmd/
+│   ├── server/main.go           # Main HTTP server
+│   └── importer/main.go         # Import metadata from lot table
+├── internal/
+│   ├── config/config.go         # YAML config loading
+│   ├── models/                   # GORM models
+│   ├── handlers/                 # Gin HTTP handlers
+│   ├── services/                 # Business logic
+│   ├── middleware/               # Auth, CORS, roles
+│   └── repository/               # Database queries
+├── web/
+│   ├── templates/                # Go HTML templates
+│   └── static/                   # CSS, JS
+├── migrations/                   # SQL migration files
+├── config.yaml
+└── go.mod
+```
+
+## Existing Database Tables (READ-ONLY - DO NOT MODIFY)
+
+These tables are used by other systems. Our app only reads from them:
+
+```sql
+-- Component catalog
+CREATE TABLE lot (
+    lot_name CHAR(255) PRIMARY KEY,      -- e.g., "CPU_AMD_9654", "MB_INTEL_4.Sapphire_2S"
+    lot_description VARCHAR(10000)
+);
+
+-- Price history from suppliers
+CREATE TABLE lot_log (
+    lot_log_id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
+    lot CHAR(255) NOT NULL,              -- FK → lot.lot_name
+    supplier CHAR(255) NOT NULL,         -- FK → supplier.supplier_name
+    date DATE NOT NULL,
+    price DOUBLE NOT NULL,
+    quality CHAR(255),
+    comments VARCHAR(15000),
+    FOREIGN KEY (lot) REFERENCES lot(lot_name),
+    FOREIGN KEY (supplier) REFERENCES supplier(supplier_name)
+);
+
+-- Supplier catalog
+CREATE TABLE supplier (
+    supplier_name CHAR(255) PRIMARY KEY,
+    supplier_comment VARCHAR(10000)
+);
+```
+
+## New Tables (prefix qt_)
+
+QuoteForge creates these tables:
+
+```sql
+-- Users
+CREATE TABLE qt_users (
+    id INT AUTO_INCREMENT PRIMARY KEY,
+    username VARCHAR(100) UNIQUE NOT NULL,
+    email VARCHAR(255) UNIQUE NOT NULL,
+    password_hash VARCHAR(255) NOT NULL,
+    role ENUM('viewer', 'editor', 'pricing_admin', 'admin') DEFAULT 'viewer',
+    is_active BOOLEAN DEFAULT TRUE,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
+);
+
+-- Component metadata (extends lot table)
+CREATE TABLE qt_lot_metadata (
+    lot_name CHAR(255) PRIMARY KEY,
+    category_id INT,
+    model VARCHAR(100),                   -- Parsed: CPU_AMD_9654 → "9654"
+    specs JSON,
+    current_price DECIMAL(12,2),
+    price_method ENUM('manual', 'median', 'average', 'weighted_median') DEFAULT 'median',
+    price_period_days INT DEFAULT 90,
+    price_updated_at TIMESTAMP,
+    request_count INT DEFAULT 0,
+    last_request_date DATE,
+    popularity_score DECIMAL(10,4),
+    FOREIGN KEY (lot_name) REFERENCES lot(lot_name)
+);
+
+-- Categories
+CREATE TABLE qt_categories (
+    id INT AUTO_INCREMENT PRIMARY KEY,
+    code VARCHAR(20) UNIQUE NOT NULL,    -- MB, CPU, MEM, GPU, SSD, HDD, RAID, NIC, HCA, HBA, DPU, PS
+    name VARCHAR(100) NOT NULL,
+    name_ru VARCHAR(100),
+    display_order INT DEFAULT 0,
+    is_required BOOLEAN DEFAULT FALSE
+);
+
+-- Saved configurations
+CREATE TABLE qt_configurations (
+    id INT AUTO_INCREMENT PRIMARY KEY,
+    uuid VARCHAR(36) UNIQUE NOT NULL,
+    user_id INT NOT NULL,
+    name VARCHAR(200) NOT NULL,
+    items JSON NOT NULL,                  -- [{"lot_name": "CPU_AMD_9654", "quantity": 2, "unit_price": 11500}]
+    total_price DECIMAL(12,2),
+    notes TEXT,
+    is_template BOOLEAN DEFAULT FALSE,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    FOREIGN KEY (user_id) REFERENCES qt_users(id)
+);
+
+-- Price overrides
+CREATE TABLE qt_price_overrides (
+    id INT AUTO_INCREMENT PRIMARY KEY,
+    lot_name CHAR(255) NOT NULL,
+    price DECIMAL(12,2) NOT NULL,
+    valid_from DATE NOT NULL,
+    valid_until DATE,
+    reason TEXT,
+    created_by INT NOT NULL,
+    FOREIGN KEY (lot_name) REFERENCES lot(lot_name)
+);
+
+-- Alerts for pricing admins
+CREATE TABLE qt_pricing_alerts (
+    id INT AUTO_INCREMENT PRIMARY KEY,
+    lot_name CHAR(255) NOT NULL,
+    alert_type ENUM('high_demand_stale_price', 'price_spike', 'price_drop', 'no_recent_quotes', 'trending_no_price') NOT NULL,
+    severity ENUM('low', 'medium', 'high', 'critical') DEFAULT 'medium',
+    message TEXT NOT NULL,
+    details JSON,
+    status ENUM('new', 'acknowledged', 'resolved', 'ignored') DEFAULT 'new',
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Usage statistics
+CREATE TABLE qt_component_usage_stats (
+    lot_name CHAR(255) PRIMARY KEY,
+    quotes_total INT DEFAULT 0,
+    quotes_last_30d INT DEFAULT 0,
+    quotes_last_7d INT DEFAULT 0,
+    total_quantity INT DEFAULT 0,
+    total_revenue DECIMAL(14,2) DEFAULT 0,
+    trend_direction ENUM('up', 'stable', 'down') DEFAULT 'stable',
+    trend_percent DECIMAL(5,2) DEFAULT 0,
+    last_used_at TIMESTAMP
+);
+```
+
+## Key Business Logic
+
+### 1. Part Number Parsing
+
+Extract category and model from lot_name:
+```go
+// "CPU_AMD_9654" → category="CPU", model="AMD_9654"
+// "MB_INTEL_4.Sapphire_2S" → category="MB", model="INTEL_4.Sapphire_2S"
+// "MEM_DDR5_64G_5600" → category="MEM", model="DDR5_64G_5600"
+// "GPU_NV_RTX_4090_PCIe" → category="GPU", model="NV_RTX_4090_PCIe"
+
+func ParsePartNumber(lotName string) (category, model string) {
+    parts := strings.SplitN(lotName, "_", 2)
+    if len(parts) >= 1 {
+        category = parts[0]
+    }
+    if len(parts) >= 2 {
+        model = parts[1]
+    }
+    return
+}
+```
+
+### 2. Price Calculation Methods
+
+```go
+// Median - simple median of prices in period
+func CalculateMedian(prices []float64) float64
+
+// Average - arithmetic mean
+func CalculateAverage(prices []float64) float64
+
+// Weighted Median - recent prices have higher weight (exponential decay)
+// weight = e^(-days_since_quote / decay_days)
+func CalculateWeightedMedian(prices []PricePoint, decayDays int) float64
+```
+
+### 3. Price Freshness (color coding)
+
+```go
+// Green: < 30 days AND >= 3 quotes
+// Yellow: 30-60 days OR 1-2 quotes
+// Orange: 60-90 days
+// Red: > 90 days OR no price
+
+func GetPriceFreshness(daysSinceUpdate int, quoteCount int) string {
+    if daysSinceUpdate < 30 && quoteCount >= 3 {
+        return "fresh"      // green
+    } else if daysSinceUpdate < 60 {
+        return "normal"     // yellow
+    } else if daysSinceUpdate < 90 {
+        return "stale"      // orange
+    }
+    return "critical"       // red
+}
+```
+
+### 4. Component Sorting
+
+Sort by: popularity + price freshness. Components without prices go to the bottom.
+
+```go
+// Sort score = popularity_score * 10 + freshness_bonus - no_price_penalty
+// freshness_bonus: fresh=100, normal=50, stale=10, critical=0
+// no_price_penalty: -1000 if current_price is NULL or 0
+```
+
+### 5. Alert Generation
+
+Generate alerts when:
+- **high_demand_stale_price** (CRITICAL): >= 5 quotes/month AND price > 60 days old
+- **trending_no_price** (HIGH): trend_percent > 50% AND no price set
+- **no_recent_quotes** (MEDIUM): popular component, no supplier quotes > 90 days
+
+## API Endpoints
+
+### Auth
+```
+POST /api/auth/login     → {"username", "password"} → {"token", "refresh_token"}
+POST /api/auth/logout
+POST /api/auth/refresh
+GET  /api/auth/me        → current user info
+```
+
+### Components
+```
+GET /api/components                          → list with pagination
+GET /api/components?category=CPU&vendor=AMD  → filtered
+GET /api/components/:lot_name                → single component details
+GET /api/categories                          → category list
+```
+
+### Quote Builder
+```
+POST /api/quote/validate   → {"items": [...]} → {"valid": bool, "errors": [], "warnings": []}
+POST /api/quote/calculate  → {"items": [...]} → {"items": [...], "total": 45000.00}
+```
+
+### Export
+```
+POST /api/export/csv   → {"items": [...], "name": "Config 1"} → CSV file
+POST /api/export/xlsx  → {"items": [...], "name": "Config 1"} → XLSX file
+```
+
+### Configurations
+```
+GET    /api/configs           → list user's configurations
+POST   /api/configs           → save new configuration
+GET    /api/configs/:uuid     → get by UUID
+PUT    /api/configs/:uuid     → update
+DELETE /api/configs/:uuid     → delete
+GET    /api/configs/:uuid/export  → export as JSON
+```
+
+### Pricing Admin (requires role: pricing_admin or admin)
+```
+GET  /admin/pricing/stats                    → dashboard stats
+GET  /admin/pricing/components               → components with pricing info
+GET  /admin/pricing/components/:lot_name     → component pricing details
+POST /admin/pricing/update                   → update price method/value
+POST /admin/pricing/recalculate-all          → recalculate all prices
+
+GET  /admin/pricing/alerts                   → list alerts
+POST /admin/pricing/alerts/:id/acknowledge   → mark as seen
+POST /admin/pricing/alerts/:id/resolve       → mark as resolved
+POST /admin/pricing/alerts/:id/ignore        → dismiss alert
+```
+
+### htmx Partials
+```
+GET /partials/components?category=CPU&vendor=AMD  → HTML fragment
+GET /partials/cart                                → cart HTML
+GET /partials/summary                             → price summary HTML
+```
+
+## User Roles
+
+| Role | Permissions |
+|------|-------------|
+| viewer | View components, create quotes, export |
+| editor | + save/load configurations |
+| pricing_admin | + manage prices, view alerts |
+| admin | + manage users |
+
+## Frontend Guidelines
+
+- **Mobile-first** design
+- Use **htmx** for interactivity (hx-get, hx-post, hx-target, hx-swap)
+- Use **Tailwind CSS** via CDN
+- Minimal custom JavaScript
+- Color scheme for price freshness:
+  - `text-green-600 bg-green-50` - fresh
+  - `text-yellow-600 bg-yellow-50` - normal
+  - `text-orange-600 bg-orange-50` - stale
+  - `text-red-600 bg-red-50` - critical
+
+## Commands
+
+```bash
+# Run development server
+go run ./cmd/server
+
+# Run importer (one-time setup)
+go run ./cmd/importer
+
+# Run cron jobs manually
+go run ./cmd/cron -job=alerts          # Check and generate alerts
+go run ./cmd/cron -job=update-prices    # Recalculate all prices
+go run ./cmd/cron -job=reset-counters   # Reset usage counters
+go run ./cmd/cron -job=update-popularity # Update popularity scores
+
+# Build for production
+CGO_ENABLED=0 go build -ldflags="-s -w" -o bin/quoteforge ./cmd/server
+CGO_ENABLED=0 go build -ldflags="-s -w" -o bin/quoteforge-cron ./cmd/cron
+
+# Run tests
+go test ./...
+````
+
+## Cron Jobs
+
+QuoteForge now includes automated cron jobs for maintenance tasks. These can be run using the built-in cron functionality in the Docker container.
+
+### Docker Compose Setup
+
+The Docker setup includes a dedicated cron service that runs the following jobs:
+
+- **Alerts check**: Every hour (0 * * * *)
+- **Price updates**: Daily at 2 AM (0 2 * * *)
+- **Usage counter reset**: Weekly on Sunday at 1 AM (0 1 * * 0)
+- **Popularity score updates**: Daily at 3 AM (0 3 * * *)
+
+### Manual Cron Job Execution
+
+You can also run cron jobs manually using the quoteforge-cron binary:
+
+```bash
+# Check and generate alerts
+go run ./cmd/cron -job=alerts
+
+# Recalculate all prices
+go run ./cmd/cron -job=update-prices
+
+# Reset usage counters
+go run ./cmd/cron -job=reset-counters
+
+# Update popularity scores
+go run ./cmd/cron -job=update-popularity
+```
+
+### Cron Job Details
+
+- **Alerts check**: Generates alerts for components with high demand and stale prices, trending components without prices, and components with no recent quotes
+- **Price updates**: Recalculates prices for all components using configured methods (median, weighted median, average)
+- **Usage counter reset**: Resets weekly and monthly usage counters for components
+- **Popularity score updates**: Recalculates popularity scores based on supplier quote activity
+
+## Code Style
+
+- Use standard Go formatting (gofmt)
+- Error handling: always check errors, wrap with context
+- Logging: use structured logging (slog or zerolog)
+- Comments: in Russian or English, be consistent
+- File naming: snake_case for files, PascalCase for types
--- a/68
+++ b/68
@@ -0,0 +1,68 @@
+# Build stage
+FROM golang:1.24-alpine AS builder
+
+RUN apk add --no-cache git ca-certificates tzdata
+
+WORKDIR /app
+
+# Copy go mod files first for better caching
+COPY go.mod go.sum ./
+RUN go mod download
+
+# Copy source code
+COPY . .
+
+# Build the main binary
+RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build \
+    -ldflags="-s -w" \
+    -o /app/quoteforge \
+    ./cmd/server
+
+# Build the cron binary
+RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build \
+    -ldflags="-s -w" \
+    -o /app/quoteforge-cron \
+    ./cmd/cron
+
+# Final stage
+FROM alpine:3.19
+
+RUN apk add --no-cache ca-certificates tzdata cron
+
+# Create non-root user
+RUN adduser -D -g '' appuser
+
+WORKDIR /app
+
+# Copy binary from builder
+COPY --from=builder /app/quoteforge .
+COPY --from=builder /app/quoteforge-cron .
+
+# Copy cron job configuration
+COPY crontab /etc/crontabs/appuser
+RUN chmod 0600 /etc/crontabs/appuser
+
+# Create log directory
+RUN mkdir -p /var/log/cron
+
+# Copy web templates and static files
+COPY --from=builder /app/web ./web
+
+# Copy migrations
+COPY --from=builder /app/migrations ./migrations
+
+# Copy example config (actual config should be mounted)
+COPY --from=builder /app/config.example.yaml ./config.example.yaml
+
+# Set ownership
+RUN chown -R appuser:appuser /app
+
+USER appuser
+
+EXPOSE 8080
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+    CMD wget --no-verbose --tries=1 --spider http://localhost:8080/health || exit 1
+
+ENTRYPOINT ["/app/quoteforge"]
--- a/README.md
+++ b/README.md
@@ -2,7 +2,7 @@

 **Server Configuration & Quotation Tool**

-QuoteForge — корпоративный инструмент для конфигурирования серверов и формирования коммерческих предложений. Позволяет быстро собрать спецификацию сервера из каталога компонентов с автоматическим расчётом цен.
+QuoteForge — корпоративный инструмент для конфигурирования серверов и формирования коммерческих предложений (КП). Приложение интегрируется с существующей базой данных RFQ_LOG.

 ![Go Version](https://img.shields.io/badge/Go-1.22+-00ADD8?style=flat&logo=go)
 ![License](https://img.shields.io/badge/License-Proprietary-red)
@@ -16,7 +16,6 @@ QuoteForge — корпоративный инструмент для конфи
 - 💰 **Автоматический расчёт цен** — актуальные цены на основе истории закупок
 - 📊 **Экспорт в CSV/XLSX** — готовые спецификации для клиентов
 - 💾 **Сохранение конфигураций** — история и шаблоны для повторного использования
- 📤 **Импорт/экспорт JSON** — обмен конфигурациями между пользователями

 ### Для ценовых администраторов
 - 📈 **Умный расчёт цен** — медиана, взвешенная медиана, среднее
@@ -83,23 +82,23 @@ auth:
 ### 3. Миграции базы данных

 ```bash
-make migrate
+go run ./cmd/server -migrate
 ```

 ### 4. Импорт метаданных компонентов

 ```bash
-make seed
+go run ./cmd/importer
 ```

 ### 5. Запуск

 ```bash
 # Development
-make run
+go run ./cmd/server

 # Production
-make build
+CGO_ENABLED=0 go build -ldflags="-s -w" -o bin/quoteforge ./cmd/server
 ./bin/quoteforge
 ```

@@ -120,9 +119,8 @@ docker-compose up -d
 ```
 quoteforge/
 ├── cmd/
-│   ├── server/          # Основной сервер
-│   ├── priceupdater/    # Cron job обновления цен
-│   └── importer/        # Импорт данных
+│   ├── server/main.go           # Main HTTP server
+│   └── importer/main.go         # Import metadata from lot table
 ├── internal/
 │   ├── config/          # Конфигурация
 │   ├── models/          # GORM модели
@@ -137,7 +135,7 @@ quoteforge/
 ├── config.yaml          # Конфигурация
 ├── Dockerfile
 ├── docker-compose.yml
-└── Makefile
+└── go.mod
 ```

 ## Роли пользователей
@@ -165,30 +163,59 @@ GET  /api/configs             # Сохранённые конфигурации

 ## Cron Jobs

-Добавьте в crontab:
+QuoteForge now includes automated cron jobs for maintenance tasks. These can be run using the built-in cron functionality in the Docker container.
+
+### Docker Compose Setup
+
+The Docker setup includes a dedicated cron service that runs the following jobs:
+
+- **Alerts check**: Every hour (0 * * * *)
+- **Price updates**: Daily at 2 AM (0 2 * * *)
+- **Usage counter reset**: Weekly on Sunday at 1 AM (0 1 * * 0)
+- **Popularity score updates**: Daily at 3 AM (0 3 * * *)
+
+To enable cron jobs in Docker, run:

 ```bash
-# Обновление цен — каждую ночь в 2:00
-0 2 * * * /opt/quoteforge/bin/priceupdater
-
-# Генерация алертов — каждый час
-0 * * * * /opt/quoteforge/bin/priceupdater --alerts-only
+docker-compose up -d
 ```

+### Manual Cron Job Execution
+
+You can also run cron jobs manually using the quoteforge-cron binary:
+
+```bash
+# Check and generate alerts
+go run ./cmd/cron -job=alerts
+
+# Recalculate all prices
+go run ./cmd/cron -job=update-prices
+
+# Reset usage counters
+go run ./cmd/cron -job=reset-counters
+
+# Update popularity scores
+go run ./cmd/cron -job=update-popularity
+```
+
+### Cron Job Details
+
+- **Alerts check**: Generates alerts for components with high demand and stale prices, trending components without prices, and components with no recent quotes
+- **Price updates**: Recalculates prices for all components using configured methods (median, weighted median, average)
+- **Usage counter reset**: Resets weekly and monthly usage counters for components
+- **Popularity score updates**: Recalculates popularity scores based on supplier quote activity
+
 ## Разработка

 ```bash
 # Запуск в режиме разработки (hot reload)
-make dev
+go run ./cmd/server

 # Запуск тестов
-make test
-
-# Линтер
-make lint
+go test ./...

 # Сборка для Linux
-make build-linux
+CGO_ENABLED=0 go build -ldflags="-s -w" -o bin/quoteforge ./cmd/server
 ```

 ## Переменные окружения
--- a/cmd/cron/main.go
+++ b/cmd/cron/main.go
@@ -0,0 +1,85 @@
+package main
+
+import (
+	"flag"
+	"log"
+	"time"
+
+	"git.mchus.pro/mchus/quoteforge/internal/config"
+	"git.mchus.pro/mchus/quoteforge/internal/models"
+	"git.mchus.pro/mchus/quoteforge/internal/repository"
+	"git.mchus.pro/mchus/quoteforge/internal/services/alerts"
+	"git.mchus.pro/mchus/quoteforge/internal/services/pricing"
+	"gorm.io/driver/mysql"
+	"gorm.io/gorm"
+	"gorm.io/gorm/logger"
+)
+
+func main() {
+	configPath := flag.String("config", "config.yaml", "path to config file")
+	cronJob := flag.String("job", "", "type of cron job to run (alerts, update-prices)")
+	flag.Parse()
+
+	cfg, err := config.Load(*configPath)
+	if err != nil {
+		log.Fatalf("Failed to load config: %v", err)
+	}
+
+	db, err := gorm.Open(mysql.Open(cfg.Database.DSN()), &gorm.Config{
+		Logger: logger.Default.LogMode(logger.Silent),
+	})
+	if err != nil {
+		log.Fatalf("Failed to connect to database: %v", err)
+	}
+
+	// Ensure tables exist
+	if err := models.Migrate(db); err != nil {
+		log.Fatalf("Migration failed: %v", err)
+	}
+
+	// Initialize repositories
+	statsRepo := repository.NewStatsRepository(db)
+	alertRepo := repository.NewAlertRepository(db)
+	componentRepo := repository.NewComponentRepository(db)
+	priceRepo := repository.NewPriceRepository(db)
+
+	// Initialize services
+	alertService := alerts.NewService(alertRepo, componentRepo, priceRepo, statsRepo, cfg.Alerts, cfg.Pricing)
+	pricingService := pricing.NewService(componentRepo, priceRepo, cfg.Pricing)
+
+	switch *cronJob {
+	case "alerts":
+		log.Println("Running alerts check...")
+		if err := alertService.CheckAndGenerateAlerts(); err != nil {
+			log.Printf("Error running alerts check: %v", err)
+		} else {
+			log.Println("Alerts check completed successfully")
+		}
+	case "update-prices":
+		log.Println("Recalculating all prices...")
+		updated, errors := pricingService.RecalculateAllPrices()
+		log.Printf("Prices recalculated: %d updated, %d errors", updated, errors)
+	case "reset-counters":
+		log.Println("Resetting usage counters...")
+		if err := statsRepo.ResetWeeklyCounters(); err != nil {
+			log.Printf("Error resetting weekly counters: %v", err)
+		}
+		if err := statsRepo.ResetMonthlyCounters(); err != nil {
+			log.Printf("Error resetting monthly counters: %v", err)
+		}
+		log.Println("Usage counters reset completed")
+	case "update-popularity":
+		log.Println("Updating popularity scores...")
+		if err := statsRepo.UpdatePopularityScores(); err != nil {
+			log.Printf("Error updating popularity scores: %v", err)
+		} else {
+			log.Println("Popularity scores updated successfully")
+		}
+	default:
+		log.Println("No valid cron job specified. Available jobs:")
+		log.Println("  - alerts: Check and generate alerts")
+		log.Println("  - update-prices: Recalculate all prices")
+		log.Println("  - reset-counters: Reset usage counters")
+		log.Println("  - update-popularity: Update popularity scores")
+	}
+}
--- a/cmd/importer/main.go
+++ b/cmd/importer/main.go
@@ -0,0 +1,160 @@
+package main
+
+import (
+	"flag"
+	"log"
+	"strings"
+
+	"git.mchus.pro/mchus/quoteforge/internal/config"
+	"git.mchus.pro/mchus/quoteforge/internal/models"
+	"gorm.io/driver/mysql"
+	"gorm.io/gorm"
+	"gorm.io/gorm/logger"
+)
+
+func main() {
+	configPath := flag.String("config", "config.yaml", "path to config file")
+	flag.Parse()
+
+	cfg, err := config.Load(*configPath)
+	if err != nil {
+		log.Fatalf("Failed to load config: %v", err)
+	}
+
+	db, err := gorm.Open(mysql.Open(cfg.Database.DSN()), &gorm.Config{
+		Logger: logger.Default.LogMode(logger.Silent),
+	})
+	if err != nil {
+		log.Fatalf("Failed to connect to database: %v", err)
+	}
+
+	log.Println("Connected to database")
+
+	// Ensure tables exist
+	if err := models.Migrate(db); err != nil {
+		log.Fatalf("Migration failed: %v", err)
+	}
+	if err := models.SeedCategories(db); err != nil {
+		log.Fatalf("Seeding categories failed: %v", err)
+	}
+
+	// Load categories for lookup
+	var categories []models.Category
+	db.Find(&categories)
+	categoryMap := make(map[string]uint)
+	for _, c := range categories {
+		categoryMap[c.Code] = c.ID
+	}
+	log.Printf("Loaded %d categories", len(categories))
+
+	// Get all lots
+	var lots []models.Lot
+	if err := db.Find(&lots).Error; err != nil {
+		log.Fatalf("Failed to load lots: %v", err)
+	}
+	log.Printf("Found %d lots to import", len(lots))
+
+	// Import each lot
+	var imported, skipped, updated int
+	for _, lot := range lots {
+		category, model := ParsePartNumber(lot.LotName)
+
+		var categoryID *uint
+		if id, ok := categoryMap[category]; ok && id > 0 {
+			categoryID = &id
+		} else {
+			// Try to find by prefix match
+			for code, id := range categoryMap {
+				if strings.HasPrefix(category, code) {
+					categoryID = &id
+					break
+				}
+			}
+		}
+
+		// Check if already exists
+		var existing models.LotMetadata
+		result := db.Where("lot_name = ?", lot.LotName).First(&existing)
+
+		if result.Error == gorm.ErrRecordNotFound {
+			// Check if there are prices in the last 90 days
+			var recentPriceCount int64
+			db.Model(&models.LotLog{}).
+				Where("lot = ? AND date >= DATE_SUB(NOW(), INTERVAL 90 DAY)", lot.LotName).
+				Count(&recentPriceCount)
+
+			// Default to 90 days, but use "all time" (0) if no recent prices
+			periodDays := 90
+			if recentPriceCount == 0 {
+				periodDays = 0
+			}
+
+			// Create new
+			metadata := models.LotMetadata{
+				LotName:         lot.LotName,
+				CategoryID:      categoryID,
+				Model:           model,
+				PricePeriodDays: periodDays,
+			}
+			if err := db.Create(&metadata).Error; err != nil {
+				log.Printf("Failed to create metadata for %s: %v", lot.LotName, err)
+				continue
+			}
+			imported++
+		} else if result.Error == nil {
+			// Update if needed
+			needsUpdate := false
+
+			if existing.Model == "" {
+				existing.Model = model
+				needsUpdate = true
+			}
+			if existing.CategoryID == nil {
+				existing.CategoryID = categoryID
+				needsUpdate = true
+			}
+
+			// Check if using default period (90 days) but no recent prices
+			if existing.PricePeriodDays == 90 {
+				var recentPriceCount int64
+				db.Model(&models.LotLog{}).
+					Where("lot = ? AND date >= DATE_SUB(NOW(), INTERVAL 90 DAY)", lot.LotName).
+					Count(&recentPriceCount)
+
+				if recentPriceCount == 0 {
+					existing.PricePeriodDays = 0
+					needsUpdate = true
+				}
+			}
+
+			if needsUpdate {
+				db.Save(&existing)
+				updated++
+			} else {
+				skipped++
+			}
+		}
+	}
+
+	log.Printf("Import complete: %d imported, %d updated, %d skipped", imported, updated, skipped)
+
+	// Show final counts
+	var metadataCount int64
+	db.Model(&models.LotMetadata{}).Count(&metadataCount)
+	log.Printf("Total metadata records: %d", metadataCount)
+}
+
+// ParsePartNumber extracts category and model from lot_name
+// Examples:
+// "CPU_AMD_9654" → category="CPU", model="AMD_9654"
+// "MB_INTEL_4.Sapphire_2S" → category="MB", model="INTEL_4.Sapphire_2S"
+func ParsePartNumber(lotName string) (category, model string) {
+	parts := strings.SplitN(lotName, "_", 2)
+	if len(parts) >= 1 {
+		category = parts[0]
+	}
+	if len(parts) >= 2 {
+		model = parts[1]
+	}
+	return
+}
--- a/cmd/server/main.go
+++ b/cmd/server/main.go
@@ -0,0 +1,350 @@
+package main
+
+import (
+	"context"
+	"flag"
+	"log/slog"
+	"net/http"
+	"os"
+	"os/signal"
+	"syscall"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"git.mchus.pro/mchus/quoteforge/internal/config"
+	"git.mchus.pro/mchus/quoteforge/internal/handlers"
+	"git.mchus.pro/mchus/quoteforge/internal/middleware"
+	"git.mchus.pro/mchus/quoteforge/internal/models"
+	"git.mchus.pro/mchus/quoteforge/internal/repository"
+	"git.mchus.pro/mchus/quoteforge/internal/services"
+	"git.mchus.pro/mchus/quoteforge/internal/services/alerts"
+	"git.mchus.pro/mchus/quoteforge/internal/services/pricing"
+	"golang.org/x/crypto/bcrypt"
+	"gorm.io/driver/mysql"
+	"gorm.io/gorm"
+	"gorm.io/gorm/logger"
+)
+
+func main() {
+	configPath := flag.String("config", "config.yaml", "path to config file")
+	migrate := flag.Bool("migrate", false, "run database migrations")
+	flag.Parse()
+
+	cfg, err := config.Load(*configPath)
+	if err != nil {
+		slog.Error("failed to load config", "error", err)
+		os.Exit(1)
+	}
+
+	setupLogger(cfg.Logging)
+
+	slog.Info("starting QuoteForge server",
+		"host", cfg.Server.Host,
+		"port", cfg.Server.Port,
+		"mode", cfg.Server.Mode,
+	)
+
+	db, err := setupDatabase(cfg.Database)
+	if err != nil {
+		slog.Error("failed to connect to database", "error", err)
+		os.Exit(1)
+	}
+
+	if *migrate {
+		slog.Info("running database migrations...")
+		if err := models.Migrate(db); err != nil {
+			slog.Error("migration failed", "error", err)
+			os.Exit(1)
+		}
+		if err := models.SeedCategories(db); err != nil {
+			slog.Error("seeding categories failed", "error", err)
+			os.Exit(1)
+		}
+		// Create default admin user (admin / admin123)
+		adminHash, _ := bcrypt.GenerateFromPassword([]byte("admin123"), bcrypt.DefaultCost)
+		if err := models.SeedAdminUser(db, string(adminHash)); err != nil {
+			slog.Error("seeding admin user failed", "error", err)
+			os.Exit(1)
+		}
+		slog.Info("migrations completed")
+	}
+
+	gin.SetMode(cfg.Server.Mode)
+	router, err := setupRouter(db, cfg)
+	if err != nil {
+		slog.Error("failed to setup router", "error", err)
+		os.Exit(1)
+	}
+
+	srv := &http.Server{
+		Addr:         cfg.Address(),
+		Handler:      router,
+		ReadTimeout:  cfg.Server.ReadTimeout,
+		WriteTimeout: cfg.Server.WriteTimeout,
+	}
+
+	go func() {
+		slog.Info("server listening", "address", cfg.Address())
+		if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+			slog.Error("server error", "error", err)
+			os.Exit(1)
+		}
+	}()
+
+	quit := make(chan os.Signal, 1)
+	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
+	<-quit
+
+	slog.Info("shutting down server...")
+
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+
+	if err := srv.Shutdown(ctx); err != nil {
+		slog.Error("server forced to shutdown", "error", err)
+	}
+
+	slog.Info("server stopped")
+}
+
+func setupLogger(cfg config.LoggingConfig) {
+	var level slog.Level
+	switch cfg.Level {
+	case "debug":
+		level = slog.LevelDebug
+	case "warn":
+		level = slog.LevelWarn
+	case "error":
+		level = slog.LevelError
+	default:
+		level = slog.LevelInfo
+	}
+
+	opts := &slog.HandlerOptions{Level: level}
+
+	var handler slog.Handler
+	if cfg.Format == "json" {
+		handler = slog.NewJSONHandler(os.Stdout, opts)
+	} else {
+		handler = slog.NewTextHandler(os.Stdout, opts)
+	}
+
+	slog.SetDefault(slog.New(handler))
+}
+
+func setupDatabase(cfg config.DatabaseConfig) (*gorm.DB, error) {
+	gormLogger := logger.Default.LogMode(logger.Silent)
+
+	db, err := gorm.Open(mysql.Open(cfg.DSN()), &gorm.Config{
+		Logger: gormLogger,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	sqlDB, err := db.DB()
+	if err != nil {
+		return nil, err
+	}
+
+	sqlDB.SetMaxOpenConns(cfg.MaxOpenConns)
+	sqlDB.SetMaxIdleConns(cfg.MaxIdleConns)
+	sqlDB.SetConnMaxLifetime(cfg.ConnMaxLifetime)
+
+	return db, nil
+}
+
+func setupRouter(db *gorm.DB, cfg *config.Config) (*gin.Engine, error) {
+	// Repositories
+	userRepo := repository.NewUserRepository(db)
+	componentRepo := repository.NewComponentRepository(db)
+	categoryRepo := repository.NewCategoryRepository(db)
+	priceRepo := repository.NewPriceRepository(db)
+	configRepo := repository.NewConfigurationRepository(db)
+	alertRepo := repository.NewAlertRepository(db)
+	statsRepo := repository.NewStatsRepository(db)
+
+	// Services
+	authService := services.NewAuthService(userRepo, cfg.Auth)
+	pricingService := pricing.NewService(componentRepo, priceRepo, cfg.Pricing)
+	componentService := services.NewComponentService(componentRepo, categoryRepo, statsRepo)
+	quoteService := services.NewQuoteService(componentRepo, statsRepo, pricingService)
+	configService := services.NewConfigurationService(configRepo, componentRepo, quoteService)
+	exportService := services.NewExportService(cfg.Export, categoryRepo)
+	alertService := alerts.NewService(alertRepo, componentRepo, priceRepo, statsRepo, cfg.Alerts, cfg.Pricing)
+
+	// Handlers
+	authHandler := handlers.NewAuthHandler(authService, userRepo)
+	componentHandler := handlers.NewComponentHandler(componentService)
+	quoteHandler := handlers.NewQuoteHandler(quoteService)
+	configHandler := handlers.NewConfigurationHandler(configService, exportService)
+	exportHandler := handlers.NewExportHandler(exportService, configService, componentService)
+	pricingHandler := handlers.NewPricingHandler(db, pricingService, alertService, componentRepo, priceRepo, statsRepo)
+
+	// Web handler (templates)
+	webHandler, err := handlers.NewWebHandler("web/templates", componentService)
+	if err != nil {
+		return nil, err
+	}
+
+	// Router
+	router := gin.New()
+	router.Use(gin.Recovery())
+	router.Use(requestLogger())
+	router.Use(middleware.CORS())
+
+	// Static files
+	router.Static("/static", "web/static")
+
+	// Health check
+	router.GET("/health", func(c *gin.Context) {
+		c.JSON(http.StatusOK, gin.H{
+			"status": "ok",
+			"time":   time.Now().UTC().Format(time.RFC3339),
+		})
+	})
+
+	// DB status endpoint
+	router.GET("/api/db-status", func(c *gin.Context) {
+		var lotCount, lotLogCount, metadataCount int64
+		var dbOK bool = true
+		var dbError string
+
+		sqlDB, err := db.DB()
+		if err != nil {
+			dbOK = false
+			dbError = err.Error()
+		} else if err := sqlDB.Ping(); err != nil {
+			dbOK = false
+			dbError = err.Error()
+		}
+
+		db.Table("lot").Count(&lotCount)
+		db.Table("lot_log").Count(&lotLogCount)
+		db.Table("qt_lot_metadata").Count(&metadataCount)
+
+		c.JSON(http.StatusOK, gin.H{
+			"connected":      dbOK,
+			"error":          dbError,
+			"lot_count":      lotCount,
+			"lot_log_count":  lotLogCount,
+			"metadata_count": metadataCount,
+		})
+	})
+
+	// Web pages
+	router.GET("/", webHandler.Index)
+	router.GET("/login", webHandler.Login)
+	router.GET("/configs", webHandler.Configs)
+	router.GET("/configurator", webHandler.Configurator)
+	router.GET("/admin/pricing", webHandler.AdminPricing)
+
+	// htmx partials
+	partials := router.Group("/partials")
+	{
+		partials.GET("/components", webHandler.ComponentsPartial)
+	}
+
+	// API routes
+	api := router.Group("/api")
+	{
+		api.GET("/ping", func(c *gin.Context) {
+			c.JSON(http.StatusOK, gin.H{"message": "pong"})
+		})
+
+		// Auth (public)
+		auth := api.Group("/auth")
+		{
+			auth.POST("/login", authHandler.Login)
+			auth.POST("/refresh", authHandler.Refresh)
+			auth.POST("/logout", authHandler.Logout)
+			auth.GET("/me", middleware.Auth(authService), authHandler.Me)
+		}
+
+		// Components (public read, for quote builder)
+		components := api.Group("/components")
+		{
+			components.GET("", componentHandler.List)
+			components.GET("/:lot_name", componentHandler.Get)
+		}
+
+		// Categories (public)
+		api.GET("/categories", componentHandler.GetCategories)
+
+		// Quote (public, for anonymous quote building)
+		quote := api.Group("/quote")
+		{
+			quote.POST("/validate", quoteHandler.Validate)
+			quote.POST("/calculate", quoteHandler.Calculate)
+		}
+
+		// Export (public, for anonymous exports)
+		export := api.Group("/export")
+		{
+			export.POST("/csv", exportHandler.ExportCSV)
+		}
+
+		// Configurations (requires auth)
+		configs := api.Group("/configs")
+		configs.Use(middleware.Auth(authService))
+		configs.Use(middleware.RequireEditor())
+		{
+			configs.GET("", configHandler.List)
+			configs.POST("", configHandler.Create)
+			configs.GET("/:uuid", configHandler.Get)
+			configs.PUT("/:uuid", configHandler.Update)
+			configs.PATCH("/:uuid/rename", configHandler.Rename)
+			configs.POST("/:uuid/clone", configHandler.Clone)
+			configs.DELETE("/:uuid", configHandler.Delete)
+			// configs.GET("/:uuid/export", configHandler.ExportJSON)
+			configs.GET("/:uuid/csv", exportHandler.ExportConfigCSV)
+			// configs.POST("/import", configHandler.ImportJSON)
+		}
+	}
+
+	// Admin routes
+	admin := router.Group("/admin")
+	admin.Use(middleware.Auth(authService))
+	{
+		// Pricing admin
+		pricingAdmin := admin.Group("/pricing")
+		pricingAdmin.Use(middleware.RequirePricingAdmin())
+		{
+			pricingAdmin.GET("/stats", pricingHandler.GetStats)
+			pricingAdmin.GET("/components", pricingHandler.ListComponents)
+			pricingAdmin.GET("/components/:lot_name", pricingHandler.GetComponentPricing)
+			pricingAdmin.POST("/update", pricingHandler.UpdatePrice)
+			pricingAdmin.POST("/preview", pricingHandler.PreviewPrice)
+			pricingAdmin.POST("/recalculate-all", pricingHandler.RecalculateAll)
+
+			pricingAdmin.GET("/alerts", pricingHandler.ListAlerts)
+			pricingAdmin.POST("/alerts/:id/acknowledge", pricingHandler.AcknowledgeAlert)
+			pricingAdmin.POST("/alerts/:id/resolve", pricingHandler.ResolveAlert)
+			pricingAdmin.POST("/alerts/:id/ignore", pricingHandler.IgnoreAlert)
+		}
+	}
+
+	return router, nil
+}
+
+func requestLogger() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		start := time.Now()
+		path := c.Request.URL.Path
+		query := c.Request.URL.RawQuery
+
+		c.Next()
+
+		latency := time.Since(start)
+		status := c.Writer.Status()
+
+		slog.Info("request",
+			"method", c.Request.Method,
+			"path", path,
+			"query", query,
+			"status", status,
+			"latency", latency,
+			"ip", c.ClientIP(),
+		)
+	}
+}
--- a/config.example.yaml
+++ b/config.example.yaml
@@ -0,0 +1,58 @@
+# QuoteForge Configuration
+# Copy this file to config.yaml and update values
+
+server:
+  host: "0.0.0.0"
+  port: 8080
+  mode: "release"  # debug | release
+  read_timeout: "30s"
+  write_timeout: "30s"
+
+database:
+  host: "localhost"
+  port: 3306
+  name: "RFQ_LOG"
+  user: "quoteforge"
+  password: "CHANGE_ME"
+  max_open_conns: 25
+  max_idle_conns: 5
+  conn_max_lifetime: "5m"
+
+auth:
+  jwt_secret: "CHANGE_ME_MIN_32_CHARACTERS_LONG"
+  token_expiry: "24h"
+  refresh_expiry: "168h"  # 7 days
+
+pricing:
+  default_method: "weighted_median"  # median | average | weighted_median
+  default_period_days: 90
+  freshness_green_days: 30
+  freshness_yellow_days: 60
+  freshness_red_days: 90
+  min_quotes_for_median: 3
+  popularity_decay_days: 180
+
+export:
+  temp_dir: "/tmp/quoteforge-exports"
+  max_file_age: "1h"
+  company_name: "Your Company Name"
+
+alerts:
+  enabled: true
+  check_interval: "1h"
+  high_demand_threshold: 5      # КП за 30 дней
+  trending_threshold_percent: 50 # % роста для алерта
+
+notifications:
+  email_enabled: false
+  smtp_host: "smtp.example.com"
+  smtp_port: 587
+  smtp_user: ""
+  smtp_password: ""
+  from_address: "quoteforge@example.com"
+
+logging:
+  level: "info"  # debug | info | warn | error
+  format: "json" # json | text
+  output: "stdout" # stdout | file
+  file_path: "/var/log/quoteforge/app.log"
--- a/15
+++ b/15
@@ -0,0 +1,15 @@
+# Cron jobs for QuoteForge
+# Run alerts check every hour
+0 * * * * /app/quoteforge-cron -job=alerts
+
+# Run price updates daily at 2 AM
+0 2 * * * /app/quoteforge-cron -job=update-prices
+
+# Reset weekly counters every Sunday at 1 AM
+0 1 * * 0 /app/quoteforge-cron -job=reset-counters
+
+# Update popularity scores daily at 3 AM
+0 3 * * * /app/quoteforge-cron -job=update-popularity
+
+# Log rotation (optional)
+# 0 0 * * * /usr/bin/logrotate /etc/logrotate.conf
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -0,0 +1,30 @@
+version: '3.8'
+
+services:
+  quoteforge:
+    build: .
+    container_name: quoteforge
+    restart: unless-stopped
+    ports:
+      - "8080:8080"
+    volumes:
+      - ./config.yaml:/app/config.yaml:ro
+    environment:
+      - TZ=Europe/Moscow
+    healthcheck:
+      test: ["CMD", "wget", "--no-verbose", "--tries=1", "--spider", "http://localhost:8080/health"]
+      interval: 30s
+      timeout: 3s
+      retries: 3
+      start_period: 5s
+
+  quoteforge-cron:
+    build: .
+    container_name: quoteforge-cron
+    restart: unless-stopped
+    volumes:
+      - ./config.yaml:/app/config.yaml:ro
+      - ./logs:/app/logs
+    command: /usr/sbin/crond -f -l 8
+    environment:
+      - TZ=Europe/Moscow
--- a/go.mod
+++ b/go.mod
@@ -0,0 +1,42 @@
+module git.mchus.pro/mchus/quoteforge
+
+go 1.24.0
+
+require (
+	github.com/gin-gonic/gin v1.9.1
+	github.com/golang-jwt/jwt/v5 v5.3.0
+	github.com/google/uuid v1.6.0
+	golang.org/x/crypto v0.43.0
+	gopkg.in/yaml.v3 v3.0.1
+	gorm.io/driver/mysql v1.5.2
+	gorm.io/gorm v1.25.5
+)
+
+require (
+	github.com/bytedance/sonic v1.9.1 // indirect
+	github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311 // indirect
+	github.com/gabriel-vasile/mimetype v1.4.2 // indirect
+	github.com/gin-contrib/sse v0.1.0 // indirect
+	github.com/go-playground/locales v0.14.1 // indirect
+	github.com/go-playground/universal-translator v0.18.1 // indirect
+	github.com/go-playground/validator/v10 v10.14.0 // indirect
+	github.com/go-sql-driver/mysql v1.7.1 // indirect
+	github.com/goccy/go-json v0.10.2 // indirect
+	github.com/jinzhu/inflection v1.0.0 // indirect
+	github.com/jinzhu/now v1.1.5 // indirect
+	github.com/json-iterator/go v1.1.12 // indirect
+	github.com/klauspost/cpuid/v2 v2.2.4 // indirect
+	github.com/leodido/go-urn v1.2.4 // indirect
+	github.com/mattn/go-isatty v0.0.19 // indirect
+	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
+	github.com/modern-go/reflect2 v1.0.2 // indirect
+	github.com/pelletier/go-toml/v2 v2.0.8 // indirect
+	github.com/stretchr/testify v1.11.1 // indirect
+	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
+	github.com/ugorji/go/codec v1.2.11 // indirect
+	golang.org/x/arch v0.3.0 // indirect
+	golang.org/x/net v0.46.0 // indirect
+	golang.org/x/sys v0.37.0 // indirect
+	golang.org/x/text v0.30.0 // indirect
+	google.golang.org/protobuf v1.30.0 // indirect
+)
--- a/go.sum
+++ b/go.sum
@@ -0,0 +1,103 @@
+github.com/bytedance/sonic v1.5.0/go.mod h1:ED5hyg4y6t3/9Ku1R6dU/4KyJ48DZ4jPhfY1O2AihPM=
+github.com/bytedance/sonic v1.9.1 h1:6iJ6NqdoxCDr6mbY8h18oSO+cShGSMRGCEo7F2h0x8s=
+github.com/bytedance/sonic v1.9.1/go.mod h1:i736AoUSYt75HyZLoJW9ERYxcy6eaN6h4BZXU064P/U=
+github.com/chenzhuoyu/base64x v0.0.0-20211019084208-fb5309c8db06/go.mod h1:DH46F32mSOjUmXrMHnKwZdA8wcEefY7UVqBKYGjpdQY=
+github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311 h1:qSGYFH7+jGhDF8vLC+iwCD4WpbV1EBDSzWkJODFLams=
+github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311/go.mod h1:b583jCggY9gE99b6G5LEC39OIiVsWj+R97kbl5odCEk=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/gabriel-vasile/mimetype v1.4.2 h1:w5qFW6JKBz9Y393Y4q372O9A7cUSequkh1Q7OhCmWKU=
+github.com/gabriel-vasile/mimetype v1.4.2/go.mod h1:zApsH/mKG4w07erKIaJPFiX0Tsq9BFQgN3qGY5GnNgA=
+github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE=
+github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI=
+github.com/gin-gonic/gin v1.9.1 h1:4idEAncQnU5cB7BeOkPtxjfCSye0AAm1R0RVIqJ+Jmg=
+github.com/gin-gonic/gin v1.9.1/go.mod h1:hPrL7YrpYKXt5YId3A/Tnip5kqbEAP+KLuI3SUcPTeU=
+github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s=
+github.com/go-playground/assert/v2 v2.2.0/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
+github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA=
+github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY=
+github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY=
+github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY=
+github.com/go-playground/validator/v10 v10.14.0 h1:vgvQWe3XCz3gIeFDm/HnTIbj6UGmg/+t63MyGU2n5js=
+github.com/go-playground/validator/v10 v10.14.0/go.mod h1:9iXMNT7sEkjXb0I+enO7QXmzG6QCsPWY4zveKFVRSyU=
+github.com/go-sql-driver/mysql v1.7.0/go.mod h1:OXbVy3sEdcQ2Doequ6Z5BW6fXNQTmx+9S1MCJN5yJMI=
+github.com/go-sql-driver/mysql v1.7.1 h1:lUIinVbN1DY0xBg0eMOzmmtGoHwWBbvnWubQUrtU8EI=
+github.com/go-sql-driver/mysql v1.7.1/go.mod h1:OXbVy3sEdcQ2Doequ6Z5BW6fXNQTmx+9S1MCJN5yJMI=
+github.com/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU=
+github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I=
+github.com/golang-jwt/jwt/v5 v5.3.0 h1:pv4AsKCKKZuqlgs5sUmn4x8UlGa0kEVt/puTpKx9vvo=
+github.com/golang-jwt/jwt/v5 v5.3.0/go.mod h1:fxCRLWMO43lRc8nhHWY6LGqRcf+1gQWArsqaEUEa5bE=
+github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
+github.com/google/go-cmp v0.5.5 h1:Khx7svrCpmxxtHBq5j2mp/xVjsi8hQMfNLvJFAlrGgU=
+github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD/E=
+github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc=
+github.com/jinzhu/now v1.1.5 h1:/o9tlHleP7gOFmsnYNz3RGnqzefHA47wQpKrrdTIwXQ=
+github.com/jinzhu/now v1.1.5/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8=
+github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
+github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
+github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
+github.com/klauspost/cpuid/v2 v2.2.4 h1:acbojRNwl3o09bUq+yDCtZFc1aiwaAAxtcn8YkZXnvk=
+github.com/klauspost/cpuid/v2 v2.2.4/go.mod h1:RVVoqg1df56z8g3pUjL/3lE5UfnlrJX8tyFgg4nqhuY=
+github.com/leodido/go-urn v1.2.4 h1:XlAE/cm/ms7TE/VMVoduSpNBoyc2dOxHs5MZSwAN63Q=
+github.com/leodido/go-urn v1.2.4/go.mod h1:7ZrI8mTSeBSHl/UaRyKQW1qZeMgak41ANeCNaVckg+4=
+github.com/mattn/go-isatty v0.0.19 h1:JITubQf0MOLdlGRuRq+jtsDlekdYPia9ZFsB8h/APPA=
+github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
+github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
+github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
+github.com/pelletier/go-toml/v2 v2.0.8 h1:0ctb6s9mE31h0/lhu+J6OPmVeDxJn+kYnJc2jZR9tGQ=
+github.com/pelletier/go-toml/v2 v2.0.8/go.mod h1:vuYfssBdrU2XDZ9bYydBu6t+6a6PYNcZljzZR9VXg+4=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
+github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
+github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
+github.com/stretchr/testify v1.8.3/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
+github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI=
+github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08=
+github.com/ugorji/go/codec v1.2.11 h1:BMaWp1Bb6fHwEtbplGBGJ498wD+LKlNSl25MjdZY4dU=
+github.com/ugorji/go/codec v1.2.11/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg=
+golang.org/x/arch v0.0.0-20210923205945-b76863e36670/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
+golang.org/x/arch v0.3.0 h1:02VY4/ZcO/gBOH6PUaoiptASxtXU10jazRCP865E97k=
+golang.org/x/arch v0.3.0/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
+golang.org/x/crypto v0.43.0 h1:dduJYIi3A3KOfdGOHX8AVZ/jGiyPa3IbBozJ5kNuE04=
+golang.org/x/crypto v0.43.0/go.mod h1:BFbav4mRNlXJL4wNeejLpWxB7wMbc79PdRGhWKncxR0=
+golang.org/x/net v0.46.0 h1:giFlY12I07fugqwPuWJi68oOnpfqFnJIJzaIIm2JVV4=
+golang.org/x/net v0.46.0/go.mod h1:Q9BGdFy1y4nkUwiLvT5qtyhAnEHgnQ/zd8PfU6nc210=
+golang.org/x/sys v0.0.0-20220704084225-05e143d24a9e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.37.0 h1:fdNQudmxPjkdUTPnLn5mdQv7Zwvbvpaxqs831goi9kQ=
+golang.org/x/sys v0.37.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+golang.org/x/text v0.30.0 h1:yznKA/E9zq54KzlzBEAWn1NXSQ8DIp/NYMy88xJjl4k=
+golang.org/x/text v0.30.0/go.mod h1:yDdHFIX9t+tORqspjENWgzaCVXgk0yYnYuSZ8UzzBVM=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
+google.golang.org/protobuf v1.30.0 h1:kPPoIgf3TsEvrm0PFe15JQ+570QVxYzEvvHqChK+cng=
+google.golang.org/protobuf v1.30.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gorm.io/driver/mysql v1.5.2 h1:QC2HRskSE75wBuOxe0+iCkyJZ+RqpudsQtqkp+IMuXs=
+gorm.io/driver/mysql v1.5.2/go.mod h1:pQLhh1Ut/WUAySdTHwBpBv6+JKcj+ua4ZFx1QQTBzb8=
+gorm.io/gorm v1.25.2-0.20230530020048-26663ab9bf55/go.mod h1:L4uxeKpfBml98NYqVqwAdmV1a2nBtAec/cf3fpucW/k=
+gorm.io/gorm v1.25.5 h1:zR9lOiiYf09VNh5Q1gphfyia1JpiClIWG9hQaxB/mls=
+gorm.io/gorm v1.25.5/go.mod h1:hbnx/Oo0ChWMn1BIhpy1oYozzpM15i4YPuHDmfYtwg8=
+rsc.io/pdf v0.1.1/go.mod h1:n8OzWcQ6Sp37PL01nO98y4iUCRdTGarVfzxY20ICaU4=
--- a/internal/config/config.go
+++ b/internal/config/config.go
@@ -0,0 +1,176 @@
+package config
+
+import (
+	"fmt"
+	"os"
+	"time"
+
+	"gopkg.in/yaml.v3"
+)
+
+type Config struct {
+	Server        ServerConfig        `yaml:"server"`
+	Database      DatabaseConfig      `yaml:"database"`
+	Auth          AuthConfig          `yaml:"auth"`
+	Pricing       PricingConfig       `yaml:"pricing"`
+	Export        ExportConfig        `yaml:"export"`
+	Alerts        AlertsConfig        `yaml:"alerts"`
+	Notifications NotificationsConfig `yaml:"notifications"`
+	Logging       LoggingConfig       `yaml:"logging"`
+}
+
+type ServerConfig struct {
+	Host         string        `yaml:"host"`
+	Port         int           `yaml:"port"`
+	Mode         string        `yaml:"mode"`
+	ReadTimeout  time.Duration `yaml:"read_timeout"`
+	WriteTimeout time.Duration `yaml:"write_timeout"`
+}
+
+type DatabaseConfig struct {
+	Host            string        `yaml:"host"`
+	Port            int           `yaml:"port"`
+	Name            string        `yaml:"name"`
+	User            string        `yaml:"user"`
+	Password        string        `yaml:"password"`
+	MaxOpenConns    int           `yaml:"max_open_conns"`
+	MaxIdleConns    int           `yaml:"max_idle_conns"`
+	ConnMaxLifetime time.Duration `yaml:"conn_max_lifetime"`
+}
+
+func (d *DatabaseConfig) DSN() string {
+	return fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?charset=utf8mb4&parseTime=True&loc=Local",
+		d.User, d.Password, d.Host, d.Port, d.Name)
+}
+
+type AuthConfig struct {
+	JWTSecret     string        `yaml:"jwt_secret"`
+	TokenExpiry   time.Duration `yaml:"token_expiry"`
+	RefreshExpiry time.Duration `yaml:"refresh_expiry"`
+}
+
+type PricingConfig struct {
+	DefaultMethod       string `yaml:"default_method"`
+	DefaultPeriodDays   int    `yaml:"default_period_days"`
+	FreshnessGreenDays  int    `yaml:"freshness_green_days"`
+	FreshnessYellowDays int    `yaml:"freshness_yellow_days"`
+	FreshnessRedDays    int    `yaml:"freshness_red_days"`
+	MinQuotesForMedian  int    `yaml:"min_quotes_for_median"`
+	PopularityDecayDays int    `yaml:"popularity_decay_days"`
+}
+
+type ExportConfig struct {
+	TempDir     string        `yaml:"temp_dir"`
+	MaxFileAge  time.Duration `yaml:"max_file_age"`
+	CompanyName string        `yaml:"company_name"`
+}
+
+type AlertsConfig struct {
+	Enabled                  bool          `yaml:"enabled"`
+	CheckInterval            time.Duration `yaml:"check_interval"`
+	HighDemandThreshold      int           `yaml:"high_demand_threshold"`
+	TrendingThresholdPercent int           `yaml:"trending_threshold_percent"`
+}
+
+type NotificationsConfig struct {
+	EmailEnabled bool   `yaml:"email_enabled"`
+	SMTPHost     string `yaml:"smtp_host"`
+	SMTPPort     int    `yaml:"smtp_port"`
+	SMTPUser     string `yaml:"smtp_user"`
+	SMTPPassword string `yaml:"smtp_password"`
+	FromAddress  string `yaml:"from_address"`
+}
+
+type LoggingConfig struct {
+	Level    string `yaml:"level"`
+	Format   string `yaml:"format"`
+	Output   string `yaml:"output"`
+	FilePath string `yaml:"file_path"`
+}
+
+func Load(path string) (*Config, error) {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		return nil, fmt.Errorf("reading config file: %w", err)
+	}
+
+	var cfg Config
+	if err := yaml.Unmarshal(data, &cfg); err != nil {
+		return nil, fmt.Errorf("parsing config file: %w", err)
+	}
+
+	cfg.setDefaults()
+
+	return &cfg, nil
+}
+
+func (c *Config) setDefaults() {
+	if c.Server.Host == "" {
+		c.Server.Host = "0.0.0.0"
+	}
+	if c.Server.Port == 0 {
+		c.Server.Port = 8080
+	}
+	if c.Server.Mode == "" {
+		c.Server.Mode = "release"
+	}
+	if c.Server.ReadTimeout == 0 {
+		c.Server.ReadTimeout = 30 * time.Second
+	}
+	if c.Server.WriteTimeout == 0 {
+		c.Server.WriteTimeout = 30 * time.Second
+	}
+
+	if c.Database.Port == 0 {
+		c.Database.Port = 3306
+	}
+	if c.Database.MaxOpenConns == 0 {
+		c.Database.MaxOpenConns = 25
+	}
+	if c.Database.MaxIdleConns == 0 {
+		c.Database.MaxIdleConns = 5
+	}
+	if c.Database.ConnMaxLifetime == 0 {
+		c.Database.ConnMaxLifetime = 5 * time.Minute
+	}
+
+	if c.Auth.TokenExpiry == 0 {
+		c.Auth.TokenExpiry = 24 * time.Hour
+	}
+	if c.Auth.RefreshExpiry == 0 {
+		c.Auth.RefreshExpiry = 7 * 24 * time.Hour
+	}
+
+	if c.Pricing.DefaultMethod == "" {
+		c.Pricing.DefaultMethod = "weighted_median"
+	}
+	if c.Pricing.DefaultPeriodDays == 0 {
+		c.Pricing.DefaultPeriodDays = 90
+	}
+	if c.Pricing.FreshnessGreenDays == 0 {
+		c.Pricing.FreshnessGreenDays = 30
+	}
+	if c.Pricing.FreshnessYellowDays == 0 {
+		c.Pricing.FreshnessYellowDays = 60
+	}
+	if c.Pricing.FreshnessRedDays == 0 {
+		c.Pricing.FreshnessRedDays = 90
+	}
+	if c.Pricing.MinQuotesForMedian == 0 {
+		c.Pricing.MinQuotesForMedian = 3
+	}
+
+	if c.Logging.Level == "" {
+		c.Logging.Level = "info"
+	}
+	if c.Logging.Format == "" {
+		c.Logging.Format = "json"
+	}
+	if c.Logging.Output == "" {
+		c.Logging.Output = "stdout"
+	}
+}
+
+func (c *Config) Address() string {
+	return fmt.Sprintf("%s:%d", c.Server.Host, c.Server.Port)
+}
--- a/internal/handlers/auth.go
+++ b/internal/handlers/auth.go
@@ -0,0 +1,113 @@
+package handlers
+
+import (
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+	"git.mchus.pro/mchus/quoteforge/internal/middleware"
+	"git.mchus.pro/mchus/quoteforge/internal/repository"
+	"git.mchus.pro/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"})
+}
--- a/internal/handlers/component.go
+++ b/internal/handlers/component.go
@@ -0,0 +1,60 @@
+package handlers
+
+import (
+	"net/http"
+	"strconv"
+
+	"github.com/gin-gonic/gin"
+	"git.mchus.pro/mchus/quoteforge/internal/repository"
+	"git.mchus.pro/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"),
+		Search:        c.Query("search"),
+		HasPrice:      c.Query("has_price") == "true",
+		ExcludeHidden: c.Query("include_hidden") != "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)
+}
--- a/internal/handlers/configuration.go
+++ b/internal/handlers/configuration.go
@@ -0,0 +1,221 @@
+package handlers
+
+import (
+
+	"net/http"
+	"strconv"
+
+	"github.com/gin-gonic/gin"
+	"git.mchus.pro/mchus/quoteforge/internal/middleware"
+	"git.mchus.pro/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"})
+}
+
+type RenameConfigRequest struct {
+	Name string `json:"name" binding:"required"`
+}
+
+func (h *ConfigurationHandler) Rename(c *gin.Context) {
+	userID := middleware.GetUserID(c)
+	uuid := c.Param("uuid")
+
+	var req RenameConfigRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	config, err := h.configService.Rename(uuid, userID, req.Name)
+	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)
+}
+
+type CloneConfigRequest struct {
+	Name string `json:"name" binding:"required"`
+}
+
+func (h *ConfigurationHandler) Clone(c *gin.Context) {
+	userID := middleware.GetUserID(c)
+	uuid := c.Param("uuid")
+
+	var req CloneConfigRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	config, err := h.configService.Clone(uuid, userID, req.Name)
+	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.StatusCreated, config)
+}
+
+// func (h *ConfigurationHandler) ExportJSON(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, err := h.configService.ExportJSON(uuid, userID)
+// 	if err != nil {
+// 		c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
+// 		return
+// 	}
+//
+// 	filename := fmt.Sprintf("%s %s SPEC.json", config.CreatedAt.Format("2006-01-02"), config.Name)
+// 	c.Header("Content-Disposition", fmt.Sprintf("attachment; filename=\"%s\"", filename))
+// 	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)
+// }
--- a/internal/handlers/export.go
+++ b/internal/handlers/export.go
@@ -0,0 +1,121 @@
+package handlers
+
+import (
+	"fmt"
+	"net/http"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"git.mchus.pro/mchus/quoteforge/internal/middleware"
+	"git.mchus.pro/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 SPEC.csv", time.Now().Format("2006-01-02"), req.Name)
+	c.Header("Content-Disposition", fmt.Sprintf("attachment; filename=\"%s\"", filename))
+	c.Data(http.StatusOK, "text/csv; charset=utf-8", csvData)
+}
+
+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)
+
+		// Получаем информацию о компоненте для заполнения категории и описания
+		componentView, err := h.componentService.GetByLotName(item.LotName)
+		if err != nil {
+			// Если не удалось получить информацию о компоненте, используем только основные данные
+			items[i] = services.ExportItem{
+				LotName:    item.LotName,
+				Quantity:   item.Quantity,
+				UnitPrice:  item.UnitPrice,
+				TotalPrice: itemTotal,
+			}
+		} else {
+			items[i] = services.ExportItem{
+				LotName:     item.LotName,
+				Description: componentView.Description,
+				Category:    componentView.Category,
+				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.exportService.ConfigToExportData(config, h.componentService)
+
+	csvData, err := h.exportService.ToCSV(data)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	filename := fmt.Sprintf("%s %s SPEC.csv", config.CreatedAt.Format("2006-01-02"), config.Name)
+	c.Header("Content-Disposition", fmt.Sprintf("attachment; filename=\"%s\"", filename))
+	c.Data(http.StatusOK, "text/csv; charset=utf-8", csvData)
+}
--- a/internal/handlers/pricing.go
+++ b/internal/handlers/pricing.go
@@ -0,0 +1,820 @@
+package handlers
+
+import (
+	"net/http"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"git.mchus.pro/mchus/quoteforge/internal/models"
+	"git.mchus.pro/mchus/quoteforge/internal/repository"
+	"git.mchus.pro/mchus/quoteforge/internal/services/alerts"
+	"git.mchus.pro/mchus/quoteforge/internal/services/pricing"
+	"gorm.io/gorm"
+)
+
+// calculateMedian returns the median of a sorted slice of prices
+func calculateMedian(prices []float64) float64 {
+	if len(prices) == 0 {
+		return 0
+	}
+	sort.Float64s(prices)
+	n := len(prices)
+	if n%2 == 0 {
+		return (prices[n/2-1] + prices[n/2]) / 2
+	}
+	return prices[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))
+}
+
+type PricingHandler struct {
+	db             *gorm.DB
+	pricingService *pricing.Service
+	alertService   *alerts.Service
+	componentRepo  *repository.ComponentRepository
+	priceRepo      *repository.PriceRepository
+	statsRepo      *repository.StatsRepository
+}
+
+func NewPricingHandler(
+	db *gorm.DB,
+	pricingService *pricing.Service,
+	alertService *alerts.Service,
+	componentRepo *repository.ComponentRepository,
+	priceRepo *repository.PriceRepository,
+	statsRepo *repository.StatsRepository,
+) *PricingHandler {
+	return &PricingHandler{
+		db:             db,
+		pricingService: pricingService,
+		alertService:   alertService,
+		componentRepo:  componentRepo,
+		priceRepo:      priceRepo,
+		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,
+	})
+}
+
+type ComponentWithCount struct {
+	models.LotMetadata
+	QuoteCount int64    `json:"quote_count"`
+	UsedInMeta []string `json:"used_in_meta,omitempty"` // List of meta-articles that use this component
+}
+
+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"),
+		Search:    c.Query("search"),
+		SortField: c.Query("sort"),
+		SortDir:   c.Query("dir"),
+	}
+
+	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
+	}
+
+	// Get quote counts
+	lotNames := make([]string, len(components))
+	for i, comp := range components {
+		lotNames[i] = comp.LotName
+	}
+
+	counts, _ := h.priceRepo.GetQuoteCounts(lotNames)
+
+	// Get meta usage information
+	metaUsage := h.getMetaUsageMap(lotNames)
+
+	// Combine components with counts
+	result := make([]ComponentWithCount, len(components))
+	for i, comp := range components {
+		result[i] = ComponentWithCount{
+			LotMetadata: comp,
+			QuoteCount:  counts[comp.LotName],
+			UsedInMeta:  metaUsage[comp.LotName],
+		}
+	}
+
+	c.JSON(http.StatusOK, gin.H{
+		"components": result,
+		"total":      total,
+		"page":       page,
+		"per_page":   perPage,
+	})
+}
+
+// getMetaUsageMap returns a map of lot_name -> list of meta-articles that use this component
+func (h *PricingHandler) getMetaUsageMap(lotNames []string) map[string][]string {
+	result := make(map[string][]string)
+
+	// Get all components with meta_prices
+	var metaComponents []models.LotMetadata
+	h.db.Where("meta_prices IS NOT NULL AND meta_prices != ''").Find(&metaComponents)
+
+	// Build reverse lookup: which components are used in which meta-articles
+	for _, meta := range metaComponents {
+		sources := strings.Split(meta.MetaPrices, ",")
+		for _, source := range sources {
+			source = strings.TrimSpace(source)
+			if source == "" {
+				continue
+			}
+
+			// Handle wildcard patterns
+			if strings.HasSuffix(source, "*") {
+				prefix := strings.TrimSuffix(source, "*")
+				for _, lotName := range lotNames {
+					if strings.HasPrefix(lotName, prefix) && lotName != meta.LotName {
+						result[lotName] = append(result[lotName], meta.LotName)
+					}
+				}
+			} else {
+				// Direct match
+				for _, lotName := range lotNames {
+					if lotName == source && lotName != meta.LotName {
+						result[lotName] = append(result[lotName], meta.LotName)
+					}
+				}
+			}
+		}
+	}
+
+	return result
+}
+
+// expandMetaPrices expands meta_prices string to list of actual lot names
+func (h *PricingHandler) expandMetaPrices(metaPrices, excludeLot string) []string {
+	sources := strings.Split(metaPrices, ",")
+	var result []string
+	seen := make(map[string]bool)
+
+	for _, source := range sources {
+		source = strings.TrimSpace(source)
+		if source == "" {
+			continue
+		}
+
+		if strings.HasSuffix(source, "*") {
+			// Wildcard pattern - find matching lots
+			prefix := strings.TrimSuffix(source, "*")
+			var matchingLots []string
+			h.db.Model(&models.LotMetadata{}).
+				Where("lot_name LIKE ? AND lot_name != ?", prefix+"%", excludeLot).
+				Pluck("lot_name", &matchingLots)
+			for _, lot := range matchingLots {
+				if !seen[lot] {
+					result = append(result, lot)
+					seen[lot] = true
+				}
+			}
+		} else if source != excludeLot && !seen[source] {
+			result = append(result, source)
+			seen[source] = true
+		}
+	}
+
+	return result
+}
+
+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"`
+	Coefficient float64            `json:"coefficient"`
+	ManualPrice *float64           `json:"manual_price"`
+	ClearManual bool               `json:"clear_manual"`
+	MetaEnabled bool               `json:"meta_enabled"`
+	MetaPrices  string             `json:"meta_prices"`
+	MetaMethod  string             `json:"meta_method"`
+	MetaPeriod  int                `json:"meta_period"`
+	IsHidden    bool               `json:"is_hidden"`
+}
+
+func (h *PricingHandler) UpdatePrice(c *gin.Context) {
+	var req UpdatePriceRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	updates := map[string]interface{}{}
+
+	// Update method if specified
+	if req.Method != "" {
+		updates["price_method"] = req.Method
+	}
+
+	// Update period days
+	if req.PeriodDays >= 0 {
+		updates["price_period_days"] = req.PeriodDays
+	}
+
+	// Update coefficient
+	updates["price_coefficient"] = req.Coefficient
+
+	// Handle meta prices
+	if req.MetaEnabled && req.MetaPrices != "" {
+		updates["meta_prices"] = req.MetaPrices
+	} else {
+		updates["meta_prices"] = ""
+	}
+
+	// Handle hidden flag
+	updates["is_hidden"] = req.IsHidden
+
+	// Handle manual price
+	if req.ClearManual {
+		updates["manual_price"] = nil
+	} else if req.ManualPrice != nil {
+		updates["manual_price"] = *req.ManualPrice
+		// Also update current price immediately when setting manual
+		updates["current_price"] = *req.ManualPrice
+		updates["price_updated_at"] = time.Now()
+	}
+
+	err := h.db.Model(&models.LotMetadata{}).
+		Where("lot_name = ?", req.LotName).
+		Updates(updates).Error
+
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	// Recalculate price if not using manual price
+	if req.ManualPrice == nil {
+		h.recalculateSinglePrice(req.LotName)
+	}
+
+	// Get updated component to return new price
+	var comp models.LotMetadata
+	h.db.Where("lot_name = ?", req.LotName).First(&comp)
+
+	c.JSON(http.StatusOK, gin.H{
+		"message":       "price updated",
+		"current_price": comp.CurrentPrice,
+	})
+}
+
+func (h *PricingHandler) recalculateSinglePrice(lotName string) {
+	var comp models.LotMetadata
+	if err := h.db.Where("lot_name = ?", lotName).First(&comp).Error; err != nil {
+		return
+	}
+
+	// Skip if manual price is set
+	if comp.ManualPrice != nil && *comp.ManualPrice > 0 {
+		return
+	}
+
+	periodDays := comp.PricePeriodDays
+	method := comp.PriceMethod
+	if method == "" {
+		method = models.PriceMethodMedian
+	}
+
+	// Determine which lot names to use for price calculation
+	lotNames := []string{lotName}
+	if comp.MetaPrices != "" {
+		lotNames = h.expandMetaPrices(comp.MetaPrices, lotName)
+	}
+
+	// Get prices based on period from all relevant lots
+	var prices []float64
+	for _, ln := range lotNames {
+		var lotPrices []float64
+		if strings.HasSuffix(ln, "*") {
+			pattern := strings.TrimSuffix(ln, "*") + "%"
+			if periodDays > 0 {
+				h.db.Raw(`SELECT price FROM lot_log WHERE lot LIKE ? AND date >= DATE_SUB(NOW(), INTERVAL ? DAY) ORDER BY price`,
+					pattern, periodDays).Pluck("price", &lotPrices)
+			} else {
+				h.db.Raw(`SELECT price FROM lot_log WHERE lot LIKE ? ORDER BY price`, pattern).Pluck("price", &lotPrices)
+			}
+		} else {
+			if periodDays > 0 {
+				h.db.Raw(`SELECT price FROM lot_log WHERE lot = ? AND date >= DATE_SUB(NOW(), INTERVAL ? DAY) ORDER BY price`,
+					ln, periodDays).Pluck("price", &lotPrices)
+			} else {
+				h.db.Raw(`SELECT price FROM lot_log WHERE lot = ? ORDER BY price`, ln).Pluck("price", &lotPrices)
+			}
+		}
+		prices = append(prices, lotPrices...)
+	}
+
+	// If no prices in period, try all time
+	if len(prices) == 0 && periodDays > 0 {
+		for _, ln := range lotNames {
+			var lotPrices []float64
+			if strings.HasSuffix(ln, "*") {
+				pattern := strings.TrimSuffix(ln, "*") + "%"
+				h.db.Raw(`SELECT price FROM lot_log WHERE lot LIKE ? ORDER BY price`, pattern).Pluck("price", &lotPrices)
+			} else {
+				h.db.Raw(`SELECT price FROM lot_log WHERE lot = ? ORDER BY price`, ln).Pluck("price", &lotPrices)
+			}
+			prices = append(prices, lotPrices...)
+		}
+	}
+
+	if len(prices) == 0 {
+		return
+	}
+
+	// Calculate price based on method
+	sortFloat64s(prices)
+	var finalPrice float64
+	switch method {
+	case models.PriceMethodMedian:
+		finalPrice = calculateMedian(prices)
+	case models.PriceMethodAverage:
+		finalPrice = calculateAverage(prices)
+	default:
+		finalPrice = calculateMedian(prices)
+	}
+
+	if finalPrice <= 0 {
+		return
+	}
+
+	// Apply coefficient
+	if comp.PriceCoefficient != 0 {
+		finalPrice = finalPrice * (1 + comp.PriceCoefficient/100)
+	}
+
+	now := time.Now()
+	// Only update price, preserve all user settings
+	h.db.Model(&models.LotMetadata{}).
+		Where("lot_name = ?", lotName).
+		Updates(map[string]interface{}{
+			"current_price":    finalPrice,
+			"price_updated_at": now,
+		})
+}
+
+func (h *PricingHandler) RecalculateAll(c *gin.Context) {
+	// Set headers for SSE
+	c.Header("Content-Type", "text/event-stream")
+	c.Header("Cache-Control", "no-cache")
+	c.Header("Connection", "keep-alive")
+
+	// Get all components with their settings
+	var components []models.LotMetadata
+	h.db.Find(&components)
+	total := int64(len(components))
+
+	// Pre-load all lot names for efficient wildcard matching
+	var allLotNames []string
+	h.db.Model(&models.LotMetadata{}).Pluck("lot_name", &allLotNames)
+	lotNameSet := make(map[string]bool, len(allLotNames))
+	for _, ln := range allLotNames {
+		lotNameSet[ln] = true
+	}
+
+	// Pre-load latest quote dates for all lots (for checking updates)
+	type LotDate struct {
+		Lot  string
+		Date time.Time
+	}
+	var latestDates []LotDate
+	h.db.Raw(`SELECT lot, MAX(date) as date FROM lot_log GROUP BY lot`).Scan(&latestDates)
+	lotLatestDate := make(map[string]time.Time, len(latestDates))
+	for _, ld := range latestDates {
+		lotLatestDate[ld.Lot] = ld.Date
+	}
+
+	// Send initial progress
+	c.SSEvent("progress", gin.H{"current": 0, "total": total, "status": "starting"})
+	c.Writer.Flush()
+
+	// Process components individually to respect their settings
+	var updated, skipped, manual, unchanged, errors int
+	now := time.Now()
+	progressCounter := 0
+
+	for _, comp := range components {
+		progressCounter++
+
+		// If manual price is set, skip recalculation
+		if comp.ManualPrice != nil && *comp.ManualPrice > 0 {
+			manual++
+			goto sendProgress
+		}
+
+		// Calculate price based on component's individual settings
+		{
+			periodDays := comp.PricePeriodDays
+			method := comp.PriceMethod
+			if method == "" {
+				method = models.PriceMethodMedian
+			}
+
+			// Determine source lots for price calculation (using cached lot names)
+			var sourceLots []string
+			if comp.MetaPrices != "" {
+				sourceLots = expandMetaPricesWithCache(comp.MetaPrices, comp.LotName, allLotNames)
+			} else {
+				sourceLots = []string{comp.LotName}
+			}
+
+			if len(sourceLots) == 0 {
+				skipped++
+				goto sendProgress
+			}
+
+			// Check if there are new quotes since last update (using cached dates)
+			if comp.PriceUpdatedAt != nil {
+				hasNewData := false
+				for _, lot := range sourceLots {
+					if latestDate, ok := lotLatestDate[lot]; ok {
+						if latestDate.After(*comp.PriceUpdatedAt) {
+							hasNewData = true
+							break
+						}
+					}
+				}
+				if !hasNewData {
+					unchanged++
+					goto sendProgress
+				}
+			}
+
+			// Get prices from source lots
+			var prices []float64
+			if periodDays > 0 {
+				h.db.Raw(`SELECT price FROM lot_log WHERE lot IN ? AND date >= DATE_SUB(NOW(), INTERVAL ? DAY) ORDER BY price`,
+					sourceLots, periodDays).Pluck("price", &prices)
+			} else {
+				h.db.Raw(`SELECT price FROM lot_log WHERE lot IN ? ORDER BY price`,
+					sourceLots).Pluck("price", &prices)
+			}
+
+			// If no prices in period, try all time
+			if len(prices) == 0 && periodDays > 0 {
+				h.db.Raw(`SELECT price FROM lot_log WHERE lot IN ? ORDER BY price`, sourceLots).Pluck("price", &prices)
+			}
+
+			if len(prices) == 0 {
+				skipped++
+				goto sendProgress
+			}
+
+			// Calculate price based on method
+			var basePrice float64
+			switch method {
+			case models.PriceMethodMedian:
+				basePrice = calculateMedian(prices)
+			case models.PriceMethodAverage:
+				basePrice = calculateAverage(prices)
+			default:
+				basePrice = calculateMedian(prices)
+			}
+
+			if basePrice <= 0 {
+				skipped++
+				goto sendProgress
+			}
+
+			finalPrice := basePrice
+
+			// Apply coefficient
+			if comp.PriceCoefficient != 0 {
+				finalPrice = finalPrice * (1 + comp.PriceCoefficient/100)
+			}
+
+			// Update only price fields
+			err := h.db.Model(&models.LotMetadata{}).
+				Where("lot_name = ?", comp.LotName).
+				Updates(map[string]interface{}{
+					"current_price":    finalPrice,
+					"price_updated_at": now,
+				}).Error
+			if err != nil {
+				errors++
+			} else {
+				updated++
+			}
+		}
+
+	sendProgress:
+		// Send progress update every 10 components to reduce overhead
+		if progressCounter%10 == 0 || progressCounter == int(total) {
+			c.SSEvent("progress", gin.H{
+				"current":   updated + skipped + manual + unchanged + errors,
+				"total":     total,
+				"updated":   updated,
+				"skipped":   skipped,
+				"manual":    manual,
+				"unchanged": unchanged,
+				"errors":    errors,
+				"status":    "processing",
+				"lot_name":  comp.LotName,
+			})
+			c.Writer.Flush()
+		}
+	}
+
+	// Update popularity scores
+	h.statsRepo.UpdatePopularityScores()
+
+	// Send completion
+	c.SSEvent("progress", gin.H{
+		"current":   updated + skipped + manual + unchanged + errors,
+		"total":     total,
+		"updated":   updated,
+		"skipped":   skipped,
+		"manual":    manual,
+		"unchanged": unchanged,
+		"errors":    errors,
+		"status":    "completed",
+	})
+	c.Writer.Flush()
+}
+
+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"})
+}
+
+type PreviewPriceRequest struct {
+	LotName     string  `json:"lot_name" binding:"required"`
+	Method      string  `json:"method"`
+	PeriodDays  int     `json:"period_days"`
+	Coefficient float64 `json:"coefficient"`
+	MetaEnabled bool    `json:"meta_enabled"`
+	MetaPrices  string  `json:"meta_prices"`
+}
+
+func (h *PricingHandler) PreviewPrice(c *gin.Context) {
+	var req PreviewPriceRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	// Get component
+	var comp models.LotMetadata
+	if err := h.db.Where("lot_name = ?", req.LotName).First(&comp).Error; err != nil {
+		c.JSON(http.StatusNotFound, gin.H{"error": "component not found"})
+		return
+	}
+
+	// Determine which lot names to use for price calculation
+	lotNames := []string{req.LotName}
+	if req.MetaEnabled && req.MetaPrices != "" {
+		lotNames = h.expandMetaPrices(req.MetaPrices, req.LotName)
+	}
+
+	// Get all prices for calculations (from all relevant lots)
+	var allPrices []float64
+	for _, lotName := range lotNames {
+		var lotPrices []float64
+		if strings.HasSuffix(lotName, "*") {
+			// Wildcard pattern
+			pattern := strings.TrimSuffix(lotName, "*") + "%"
+			h.db.Raw(`SELECT price FROM lot_log WHERE lot LIKE ? ORDER BY price`, pattern).Pluck("price", &lotPrices)
+		} else {
+			h.db.Raw(`SELECT price FROM lot_log WHERE lot = ? ORDER BY price`, lotName).Pluck("price", &lotPrices)
+		}
+		allPrices = append(allPrices, lotPrices...)
+	}
+
+	// Calculate median for all time
+	var medianAllTime *float64
+	if len(allPrices) > 0 {
+		sortFloat64s(allPrices)
+		median := calculateMedian(allPrices)
+		medianAllTime = &median
+	}
+
+	// Get quote count (from all relevant lots)
+	var quoteCount int64
+	for _, lotName := range lotNames {
+		var count int64
+		if strings.HasSuffix(lotName, "*") {
+			pattern := strings.TrimSuffix(lotName, "*") + "%"
+			h.db.Model(&models.LotLog{}).Where("lot LIKE ?", pattern).Count(&count)
+		} else {
+			h.db.Model(&models.LotLog{}).Where("lot = ?", lotName).Count(&count)
+		}
+		quoteCount += count
+	}
+
+	// Get last received price (from the main lot only)
+	var lastPrice struct {
+		Price *float64
+		Date  *time.Time
+	}
+	h.db.Raw(`SELECT price, date FROM lot_log WHERE lot = ? ORDER BY date DESC, lot_log_id DESC LIMIT 1`, req.LotName).Scan(&lastPrice)
+
+	// Calculate new price based on parameters (method, period, coefficient)
+	method := req.Method
+	if method == "" {
+		method = "median"
+	}
+
+	var prices []float64
+	if req.PeriodDays > 0 {
+		for _, lotName := range lotNames {
+			var lotPrices []float64
+			if strings.HasSuffix(lotName, "*") {
+				pattern := strings.TrimSuffix(lotName, "*") + "%"
+				h.db.Raw(`SELECT price FROM lot_log WHERE lot LIKE ? AND date >= DATE_SUB(NOW(), INTERVAL ? DAY) ORDER BY price`,
+					pattern, req.PeriodDays).Pluck("price", &lotPrices)
+			} else {
+				h.db.Raw(`SELECT price FROM lot_log WHERE lot = ? AND date >= DATE_SUB(NOW(), INTERVAL ? DAY) ORDER BY price`,
+					lotName, req.PeriodDays).Pluck("price", &lotPrices)
+			}
+			prices = append(prices, lotPrices...)
+		}
+		// Fall back to all time if no prices in period
+		if len(prices) == 0 {
+			prices = allPrices
+		}
+	} else {
+		prices = allPrices
+	}
+
+	var newPrice *float64
+	if len(prices) > 0 {
+		sortFloat64s(prices)
+		var basePrice float64
+		if method == "average" {
+			basePrice = calculateAverage(prices)
+		} else {
+			basePrice = calculateMedian(prices)
+		}
+
+		if req.Coefficient != 0 {
+			basePrice = basePrice * (1 + req.Coefficient/100)
+		}
+		newPrice = &basePrice
+	}
+
+	c.JSON(http.StatusOK, gin.H{
+		"lot_name":        req.LotName,
+		"current_price":   comp.CurrentPrice,
+		"median_all_time": medianAllTime,
+		"new_price":       newPrice,
+		"quote_count":     quoteCount,
+		"manual_price":    comp.ManualPrice,
+		"last_price":      lastPrice.Price,
+		"last_price_date": lastPrice.Date,
+	})
+}
+
+// sortFloat64s sorts a slice of float64 in ascending order
+func sortFloat64s(data []float64) {
+	sort.Float64s(data)
+}
+
+// expandMetaPricesWithCache expands meta_prices using pre-loaded lot names (no DB queries)
+func expandMetaPricesWithCache(metaPrices, excludeLot string, allLotNames []string) []string {
+	sources := strings.Split(metaPrices, ",")
+	var result []string
+	seen := make(map[string]bool)
+
+	for _, source := range sources {
+		source = strings.TrimSpace(source)
+		if source == "" || source == excludeLot {
+			continue
+		}
+
+		if strings.HasSuffix(source, "*") {
+			// Wildcard pattern - find matching lots from cache
+			prefix := strings.TrimSuffix(source, "*")
+			for _, lot := range allLotNames {
+				if strings.HasPrefix(lot, prefix) && lot != excludeLot && !seen[lot] {
+					result = append(result, lot)
+					seen[lot] = true
+				}
+			}
+		} else if !seen[source] {
+			result = append(result, source)
+			seen[source] = true
+		}
+	}
+
+	return result
+}
--- a/internal/handlers/quote.go
+++ b/internal/handlers/quote.go
@@ -0,0 +1,51 @@
+package handlers
+
+import (
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+	"git.mchus.pro/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,
+	})
+}
--- a/internal/handlers/web.go
+++ b/internal/handlers/web.go
@@ -0,0 +1,186 @@
+package handlers
+
+import (
+	"html/template"
+	"path/filepath"
+	"strconv"
+
+	"github.com/gin-gonic/gin"
+	"git.mchus.pro/mchus/quoteforge/internal/repository"
+	"git.mchus.pro/mchus/quoteforge/internal/services"
+)
+
+type WebHandler struct {
+	templates        map[string]*template.Template
+	componentService *services.ComponentService
+}
+
+func NewWebHandler(templatesPath string, componentService *services.ComponentService) (*WebHandler, error) {
+	funcMap := template.FuncMap{
+		"sub": func(a, b int) int { return a - b },
+		"add": func(a, b int) int { return a + b },
+		"mul": func(a, b int) int { return a * b },
+		"div": func(a, b int) int {
+			if b == 0 {
+				return 0
+			}
+			return (a + b - 1) / b
+		},
+		"deref": func(f *float64) float64 {
+			if f == nil {
+				return 0
+			}
+			return *f
+		},
+		"jsesc": func(s string) string {
+			// Escape string for safe use in JavaScript
+			result := ""
+			for _, r := range s {
+				switch r {
+				case '\\':
+					result += "\\\\"
+				case '\'':
+					result += "\\'"
+				case '"':
+					result += "\\\""
+				case '\n':
+					result += "\\n"
+				case '\r':
+					result += "\\r"
+				case '\t':
+					result += "\\t"
+				default:
+					result += string(r)
+				}
+			}
+			return result
+		},
+	}
+
+	templates := make(map[string]*template.Template)
+	basePath := filepath.Join(templatesPath, "base.html")
+
+	// Load each page template with base
+	simplePages := []string{"login.html", "configs.html", "admin_pricing.html"}
+	for _, page := range simplePages {
+		pagePath := filepath.Join(templatesPath, page)
+		tmpl, err := template.New("").Funcs(funcMap).ParseFiles(basePath, pagePath)
+		if err != nil {
+			return nil, err
+		}
+		templates[page] = tmpl
+	}
+
+	// Index page needs components_list.html as well
+	indexPath := filepath.Join(templatesPath, "index.html")
+	componentsListPath := filepath.Join(templatesPath, "components_list.html")
+	indexTmpl, err := template.New("").Funcs(funcMap).ParseFiles(basePath, indexPath, componentsListPath)
+	if err != nil {
+		return nil, err
+	}
+	templates["index.html"] = indexTmpl
+
+	// Load partial templates (no base needed)
+	partials := []string{"components_list.html"}
+	for _, partial := range partials {
+		partialPath := filepath.Join(templatesPath, partial)
+		tmpl, err := template.New("").Funcs(funcMap).ParseFiles(partialPath)
+		if err != nil {
+			return nil, err
+		}
+		templates[partial] = tmpl
+	}
+
+	return &WebHandler{
+		templates:        templates,
+		componentService: componentService,
+	}, nil
+}
+
+func (h *WebHandler) render(c *gin.Context, name string, data gin.H) {
+	c.Header("Content-Type", "text/html; charset=utf-8")
+	tmpl, ok := h.templates[name]
+	if !ok {
+		c.String(500, "Template not found: %s", name)
+		return
+	}
+	// Execute the page template which will use base
+	if err := tmpl.ExecuteTemplate(c.Writer, name, data); err != nil {
+		c.String(500, "Template error: %v", err)
+	}
+}
+
+func (h *WebHandler) Index(c *gin.Context) {
+	// Redirect to configs page - configurator is accessed via /configurator?uuid=...
+	c.Redirect(302, "/configs")
+}
+
+func (h *WebHandler) Configurator(c *gin.Context) {
+	categories, _ := h.componentService.GetCategories()
+	uuid := c.Query("uuid")
+
+	filter := repository.ComponentFilter{}
+	result, err := h.componentService.List(filter, 1, 20)
+
+	data := gin.H{
+		"ActivePage": "configurator",
+		"Categories": categories,
+		"Components": []interface{}{},
+		"Total":      int64(0),
+		"Page":       1,
+		"PerPage":    20,
+		"ConfigUUID": uuid,
+	}
+
+	if err == nil && result != nil {
+		data["Components"] = result.Components
+		data["Total"] = result.Total
+		data["Page"] = result.Page
+		data["PerPage"] = result.PerPage
+	}
+
+	h.render(c, "index.html", data)
+}
+
+func (h *WebHandler) Login(c *gin.Context) {
+	h.render(c, "login.html", nil)
+}
+
+func (h *WebHandler) Configs(c *gin.Context) {
+	h.render(c, "configs.html", gin.H{"ActivePage": "configs"})
+}
+
+func (h *WebHandler) AdminPricing(c *gin.Context) {
+	h.render(c, "admin_pricing.html", gin.H{"ActivePage": "admin"})
+}
+
+// Partials for htmx
+
+func (h *WebHandler) ComponentsPartial(c *gin.Context) {
+	page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
+
+	filter := repository.ComponentFilter{
+		Category: c.Query("category"),
+		Search:   c.Query("search"),
+	}
+
+	data := gin.H{
+		"Components": []interface{}{},
+		"Total":      int64(0),
+		"Page":       page,
+		"PerPage":    20,
+	}
+
+	result, err := h.componentService.List(filter, page, 20)
+	if err == nil && result != nil {
+		data["Components"] = result.Components
+		data["Total"] = result.Total
+		data["Page"] = result.Page
+		data["PerPage"] = result.PerPage
+	}
+
+	c.Header("Content-Type", "text/html; charset=utf-8")
+	if tmpl, ok := h.templates["components_list.html"]; ok {
+		tmpl.ExecuteTemplate(c.Writer, "components_list.html", data)
+	}
+}
--- a/internal/middleware/auth.go
+++ b/internal/middleware/auth.go
@@ -0,0 +1,101 @@
+package middleware
+
+import (
+	"net/http"
+	"strings"
+
+	"github.com/gin-gonic/gin"
+	"git.mchus.pro/mchus/quoteforge/internal/models"
+	"git.mchus.pro/mchus/quoteforge/internal/services"
+)
+
+const (
+	AuthUserKey   = "auth_user"
+	AuthClaimsKey = "auth_claims"
+)
+
+func Auth(authService *services.AuthService) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		authHeader := c.GetHeader("Authorization")
+		if authHeader == "" {
+			c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{
+				"error": "authorization header required",
+			})
+			return
+		}
+
+		parts := strings.SplitN(authHeader, " ", 2)
+		if len(parts) != 2 || parts[0] != "Bearer" {
+			c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{
+				"error": "invalid authorization header format",
+			})
+			return
+		}
+
+		claims, err := authService.ValidateToken(parts[1])
+		if err != nil {
+			c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{
+				"error": err.Error(),
+			})
+			return
+		}
+
+		c.Set(AuthClaimsKey, claims)
+		c.Next()
+	}
+}
+
+func RequireRole(roles ...models.UserRole) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		claims, exists := c.Get(AuthClaimsKey)
+		if !exists {
+			c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{
+				"error": "authentication required",
+			})
+			return
+		}
+
+		authClaims := claims.(*services.Claims)
+
+		for _, role := range roles {
+			if authClaims.Role == role {
+				c.Next()
+				return
+			}
+		}
+
+		c.AbortWithStatusJSON(http.StatusForbidden, gin.H{
+			"error": "insufficient permissions",
+		})
+	}
+}
+
+func RequireEditor() gin.HandlerFunc {
+	return RequireRole(models.RoleEditor, models.RolePricingAdmin, models.RoleAdmin)
+}
+
+func RequirePricingAdmin() gin.HandlerFunc {
+	return RequireRole(models.RolePricingAdmin, models.RoleAdmin)
+}
+
+func RequireAdmin() gin.HandlerFunc {
+	return RequireRole(models.RoleAdmin)
+}
+
+// GetClaims extracts auth claims from context
+func GetClaims(c *gin.Context) *services.Claims {
+	claims, exists := c.Get(AuthClaimsKey)
+	if !exists {
+		return nil
+	}
+	return claims.(*services.Claims)
+}
+
+// GetUserID extracts user ID from context
+func GetUserID(c *gin.Context) uint {
+	claims := GetClaims(c)
+	if claims == nil {
+		return 0
+	}
+	return claims.UserID
+}
--- a/internal/middleware/cors.go
+++ b/internal/middleware/cors.go
@@ -0,0 +1,22 @@
+package middleware
+
+import (
+	"github.com/gin-gonic/gin"
+)
+
+func CORS() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		c.Header("Access-Control-Allow-Origin", "*")
+		c.Header("Access-Control-Allow-Methods", "GET, POST, PUT, PATCH, DELETE, OPTIONS")
+		c.Header("Access-Control-Allow-Headers", "Origin, Content-Type, Accept, Authorization")
+		c.Header("Access-Control-Expose-Headers", "Content-Length, Content-Disposition")
+		c.Header("Access-Control-Max-Age", "86400")
+
+		if c.Request.Method == "OPTIONS" {
+			c.AbortWithStatus(204)
+			return
+		}
+
+		c.Next()
+	}
+}
--- a/internal/models/alert.go
+++ b/internal/models/alert.go
@@ -0,0 +1,93 @@
+package models
+
+import (
+	"database/sql/driver"
+	"encoding/json"
+	"errors"
+	"time"
+)
+
+type AlertType string
+
+const (
+	AlertHighDemandStalePrice AlertType = "high_demand_stale_price"
+	AlertPriceSpike           AlertType = "price_spike"
+	AlertPriceDrop            AlertType = "price_drop"
+	AlertNoRecentQuotes       AlertType = "no_recent_quotes"
+	AlertTrendingNoPrice      AlertType = "trending_no_price"
+)
+
+type AlertSeverity string
+
+const (
+	SeverityLow      AlertSeverity = "low"
+	SeverityMedium   AlertSeverity = "medium"
+	SeverityHigh     AlertSeverity = "high"
+	SeverityCritical AlertSeverity = "critical"
+)
+
+type AlertStatus string
+
+const (
+	AlertStatusNew          AlertStatus = "new"
+	AlertStatusAcknowledged AlertStatus = "acknowledged"
+	AlertStatusResolved     AlertStatus = "resolved"
+	AlertStatusIgnored      AlertStatus = "ignored"
+)
+
+type AlertDetails map[string]interface{}
+
+func (d AlertDetails) Value() (driver.Value, error) {
+	return json.Marshal(d)
+}
+
+func (d *AlertDetails) Scan(value interface{}) error {
+	if value == nil {
+		*d = make(AlertDetails)
+		return nil
+	}
+	bytes, ok := value.([]byte)
+	if !ok {
+		return errors.New("type assertion to []byte failed")
+	}
+	return json.Unmarshal(bytes, d)
+}
+
+type PricingAlert struct {
+	ID        uint          `gorm:"primaryKey;autoIncrement" json:"id"`
+	LotName   string        `gorm:"size:255;not null" json:"lot_name"`
+	AlertType AlertType     `gorm:"type:enum('high_demand_stale_price','price_spike','price_drop','no_recent_quotes','trending_no_price');not null" json:"alert_type"`
+	Severity  AlertSeverity `gorm:"type:enum('low','medium','high','critical');default:'medium'" json:"severity"`
+	Message   string        `gorm:"type:text;not null" json:"message"`
+	Details   AlertDetails  `gorm:"type:json" json:"details"`
+	Status    AlertStatus   `gorm:"type:enum('new','acknowledged','resolved','ignored');default:'new'" json:"status"`
+	CreatedAt time.Time     `gorm:"autoCreateTime" json:"created_at"`
+}
+
+func (PricingAlert) TableName() string {
+	return "qt_pricing_alerts"
+}
+
+type TrendDirection string
+
+const (
+	TrendUp     TrendDirection = "up"
+	TrendStable TrendDirection = "stable"
+	TrendDown   TrendDirection = "down"
+)
+
+type ComponentUsageStats struct {
+	LotName        string         `gorm:"column:lot_name;primaryKey;size:255" json:"lot_name"`
+	QuotesTotal    int            `gorm:"default:0" json:"quotes_total"`
+	QuotesLast30d  int            `gorm:"default:0" json:"quotes_last_30d"`
+	QuotesLast7d   int            `gorm:"default:0" json:"quotes_last_7d"`
+	TotalQuantity  int            `gorm:"default:0" json:"total_quantity"`
+	TotalRevenue   float64        `gorm:"type:decimal(14,2);default:0" json:"total_revenue"`
+	TrendDirection TrendDirection `gorm:"type:enum('up','stable','down');default:'stable'" json:"trend_direction"`
+	TrendPercent   float64        `gorm:"type:decimal(5,2);default:0" json:"trend_percent"`
+	LastUsedAt     *time.Time     `json:"last_used_at"`
+}
+
+func (ComponentUsageStats) TableName() string {
+	return "qt_component_usage_stats"
+}
--- a/internal/models/category.go
+++ b/internal/models/category.go
@@ -0,0 +1,44 @@
+package models
+
+type Category struct {
+	ID           uint   `gorm:"primaryKey;autoIncrement" json:"id"`
+	Code         string `gorm:"size:20;uniqueIndex;not null" json:"code"`
+	Name         string `gorm:"size:100;not null" json:"name"`
+	NameRu       string `gorm:"size:100" json:"name_ru"`
+	DisplayOrder int    `gorm:"default:0" json:"display_order"`
+	IsRequired   bool   `gorm:"default:false" json:"is_required"`
+}
+
+func (Category) TableName() string {
+	return "qt_categories"
+}
+
+// DefaultCategories defines the standard categories with display order
+// Order: BB, CPU, MEM, GPU, SSD, RAID, HBA, NIC, PSU, RISERS, ACC, and others
+var DefaultCategories = []Category{
+	{Code: "BB", Name: "Barebone", NameRu: "Шасси", DisplayOrder: 1, IsRequired: true},
+	{Code: "CPU", Name: "Processor", NameRu: "Процессор", DisplayOrder: 2, IsRequired: true},
+	{Code: "MEM", Name: "Memory", NameRu: "Оперативная память", DisplayOrder: 3, IsRequired: true},
+	{Code: "GPU", Name: "Graphics Card", NameRu: "Видеокарта", DisplayOrder: 4},
+	{Code: "SSD", Name: "SSD Storage", NameRu: "SSD накопитель", DisplayOrder: 5},
+	{Code: "RAID", Name: "RAID Controller", NameRu: "RAID контроллер", DisplayOrder: 6},
+	{Code: "HBA", Name: "HBA Adapter", NameRu: "HBA адаптер", DisplayOrder: 7},
+	{Code: "NIC", Name: "Network Card", NameRu: "Сетевая карта", DisplayOrder: 8},
+	{Code: "PSU", Name: "Power Supply", NameRu: "Блок питания", DisplayOrder: 9},
+	{Code: "RISERS", Name: "Risers", NameRu: "Райзеры", DisplayOrder: 10},
+	{Code: "ACC", Name: "Accessories", NameRu: "Аксессуары", DisplayOrder: 11},
+	// Additional categories
+	{Code: "MB", Name: "Motherboard", NameRu: "Материнская плата", DisplayOrder: 12},
+	{Code: "HDD", Name: "HDD Storage", NameRu: "HDD накопитель", DisplayOrder: 13},
+	{Code: "HCA", Name: "HCA Adapter", NameRu: "HCA адаптер", DisplayOrder: 14},
+	{Code: "DPU", Name: "DPU", NameRu: "DPU", DisplayOrder: 15},
+	{Code: "M2", Name: "M.2 Storage", NameRu: "M.2 накопитель", DisplayOrder: 16},
+	{Code: "EDSFF", Name: "EDSFF Storage", NameRu: "EDSFF накопитель", DisplayOrder: 17},
+	{Code: "HHHL", Name: "HHHL Storage", NameRu: "HHHL накопитель", DisplayOrder: 18},
+	{Code: "PS", Name: "Power Supply (Legacy)", NameRu: "Блок питания", DisplayOrder: 19},
+	{Code: "CARD", Name: "Cards", NameRu: "Карты", DisplayOrder: 20},
+}
+
+// MaxKnownDisplayOrder is the highest display order for known categories
+// New categories will get display order starting from this + 1
+const MaxKnownDisplayOrder = 100
--- a/internal/models/configuration.go
+++ b/internal/models/configuration.go
@@ -0,0 +1,76 @@
+package models
+
+import (
+	"database/sql/driver"
+	"encoding/json"
+	"errors"
+	"time"
+)
+
+type ConfigItem struct {
+	LotName   string  `json:"lot_name"`
+	Quantity  int     `json:"quantity"`
+	UnitPrice float64 `json:"unit_price"`
+}
+
+type ConfigItems []ConfigItem
+
+func (c ConfigItems) Value() (driver.Value, error) {
+	return json.Marshal(c)
+}
+
+func (c *ConfigItems) Scan(value interface{}) error {
+	if value == nil {
+		*c = make(ConfigItems, 0)
+		return nil
+	}
+	bytes, ok := value.([]byte)
+	if !ok {
+		return errors.New("type assertion to []byte failed")
+	}
+	return json.Unmarshal(bytes, c)
+}
+
+func (c ConfigItems) Total() float64 {
+	var total float64
+	for _, item := range c {
+		total += item.UnitPrice * float64(item.Quantity)
+	}
+	return total
+}
+
+type Configuration struct {
+	ID            uint        `gorm:"primaryKey;autoIncrement" json:"id"`
+	UUID          string      `gorm:"size:36;uniqueIndex;not null" json:"uuid"`
+	UserID        uint        `gorm:"not null" json:"user_id"`
+	Name          string      `gorm:"size:200;not null" json:"name"`
+	Items         ConfigItems `gorm:"type:json;not null" json:"items"`
+	TotalPrice    *float64    `gorm:"type:decimal(12,2)" json:"total_price"`
+	CustomPrice   *float64    `gorm:"type:decimal(12,2)" json:"custom_price"`
+	Notes         string      `gorm:"type:text" json:"notes"`
+	IsTemplate    bool        `gorm:"default:false" json:"is_template"`
+	ServerCount   int         `gorm:"default:1" json:"server_count"`
+	CreatedAt     time.Time   `gorm:"autoCreateTime" json:"created_at"`
+
+	User *User `gorm:"foreignKey:UserID" json:"user,omitempty"`
+}
+
+func (Configuration) TableName() string {
+	return "qt_configurations"
+}
+
+type PriceOverride struct {
+	ID         uint       `gorm:"primaryKey;autoIncrement" json:"id"`
+	LotName    string     `gorm:"size:255;not null" json:"lot_name"`
+	Price      float64    `gorm:"type:decimal(12,2);not null" json:"price"`
+	ValidFrom  time.Time  `gorm:"type:date;not null" json:"valid_from"`
+	ValidUntil *time.Time `gorm:"type:date" json:"valid_until"`
+	Reason     string     `gorm:"type:text" json:"reason"`
+	CreatedBy  uint       `gorm:"not null" json:"created_by"`
+
+	Creator *User `gorm:"foreignKey:CreatedBy" json:"creator,omitempty"`
+}
+
+func (PriceOverride) TableName() string {
+	return "qt_price_overrides"
+}
--- a/internal/models/lot.go
+++ b/internal/models/lot.go
@@ -0,0 +1,39 @@
+package models
+
+import "time"
+
+// Lot represents existing lot table
+type Lot struct {
+	LotName        string  `gorm:"column:lot_name;primaryKey;size:255" json:"lot_name"`
+	LotDescription string  `gorm:"column:lot_description;size:10000" json:"lot_description"`
+	LotCategory    *string `gorm:"column:lot_category;size:50" json:"lot_category"`
+}
+
+func (Lot) TableName() string {
+	return "lot"
+}
+
+// LotLog represents existing lot_log table (READ-ONLY)
+type LotLog struct {
+	LotLogID uint      `gorm:"column:lot_log_id;primaryKey;autoIncrement"`
+	Lot      string    `gorm:"column:lot;size:255;not null"`
+	Supplier string    `gorm:"column:supplier;size:255;not null"`
+	Date     time.Time `gorm:"column:date;type:date;not null"`
+	Price    float64   `gorm:"column:price;not null"`
+	Quality  string    `gorm:"column:quality;size:255"`
+	Comments string    `gorm:"column:comments;size:15000"`
+}
+
+func (LotLog) TableName() string {
+	return "lot_log"
+}
+
+// Supplier represents existing supplier table (READ-ONLY)
+type Supplier struct {
+	SupplierName    string `gorm:"column:supplier_name;primaryKey;size:255"`
+	SupplierComment string `gorm:"column:supplier_comment;size:10000"`
+}
+
+func (Supplier) TableName() string {
+	return "supplier"
+}
--- a/internal/models/metadata.go
+++ b/internal/models/metadata.go
@@ -0,0 +1,92 @@
+package models
+
+import (
+	"database/sql/driver"
+	"encoding/json"
+	"errors"
+	"time"
+)
+
+type PriceMethod string
+
+const (
+	PriceMethodManual         PriceMethod = "manual"
+	PriceMethodMedian         PriceMethod = "median"
+	PriceMethodAverage        PriceMethod = "average"
+	PriceMethodWeightedMedian PriceMethod = "weighted_median"
+)
+
+type Specs map[string]interface{}
+
+func (s Specs) Value() (driver.Value, error) {
+	return json.Marshal(s)
+}
+
+func (s *Specs) Scan(value interface{}) error {
+	if value == nil {
+		*s = make(Specs)
+		return nil
+	}
+	bytes, ok := value.([]byte)
+	if !ok {
+		return errors.New("type assertion to []byte failed")
+	}
+	return json.Unmarshal(bytes, s)
+}
+
+type LotMetadata struct {
+	LotName          string       `gorm:"column:lot_name;primaryKey;size:255" json:"lot_name"`
+	CategoryID       *uint        `gorm:"column:category_id" json:"category_id"`
+	Model            string       `gorm:"size:100" json:"model"`
+	Specs            Specs        `gorm:"type:json" json:"specs"`
+	CurrentPrice     *float64     `gorm:"type:decimal(12,2)" json:"current_price"`
+	PriceMethod      PriceMethod  `gorm:"type:enum('manual','median','average','weighted_median');default:'median'" json:"price_method"`
+	PricePeriodDays  int          `gorm:"default:90" json:"price_period_days"`
+	PriceCoefficient float64      `gorm:"type:decimal(5,2);default:0" json:"price_coefficient"`
+	ManualPrice      *float64     `gorm:"type:decimal(12,2)" json:"manual_price"`
+	PriceUpdatedAt   *time.Time   `json:"price_updated_at"`
+	RequestCount     int          `gorm:"default:0" json:"request_count"`
+	LastRequestDate  *time.Time   `gorm:"type:date" json:"last_request_date"`
+	PopularityScore  float64      `gorm:"type:decimal(10,4);default:0" json:"popularity_score"`
+	MetaPrices       string       `gorm:"size:1000" json:"meta_prices"`
+	MetaMethod       string       `gorm:"size:20" json:"meta_method"`
+	MetaPeriodDays   int          `gorm:"default:90" json:"meta_period_days"`
+	IsHidden         bool         `gorm:"default:false" json:"is_hidden"`
+
+	// Relations
+	Lot      *Lot      `gorm:"foreignKey:LotName;references:LotName" json:"lot,omitempty"`
+	Category *Category `gorm:"foreignKey:CategoryID" json:"category,omitempty"`
+}
+
+func (LotMetadata) TableName() string {
+	return "qt_lot_metadata"
+}
+
+type PriceFreshness string
+
+const (
+	FreshnessFresh    PriceFreshness = "fresh"
+	FreshnessNormal   PriceFreshness = "normal"
+	FreshnessStale    PriceFreshness = "stale"
+	FreshnessCritical PriceFreshness = "critical"
+)
+
+func (m *LotMetadata) GetPriceFreshness(greenDays, yellowDays, redDays, minQuotes int) PriceFreshness {
+	if m.CurrentPrice == nil || *m.CurrentPrice == 0 {
+		return FreshnessCritical
+	}
+	if m.PriceUpdatedAt == nil {
+		return FreshnessCritical
+	}
+
+	daysSince := int(time.Since(*m.PriceUpdatedAt).Hours() / 24)
+
+	if daysSince < greenDays && m.RequestCount >= minQuotes {
+		return FreshnessFresh
+	} else if daysSince < yellowDays {
+		return FreshnessNormal
+	} else if daysSince < redDays {
+		return FreshnessStale
+	}
+	return FreshnessCritical
+}
--- a/internal/models/models.go
+++ b/internal/models/models.go
@@ -0,0 +1,51 @@
+package models
+
+import "gorm.io/gorm"
+
+// AllModels returns all models for auto-migration
+func AllModels() []interface{} {
+	return []interface{}{
+		&User{},
+		&Category{},
+		&LotMetadata{},
+		&Configuration{},
+		&PriceOverride{},
+		&PricingAlert{},
+		&ComponentUsageStats{},
+	}
+}
+
+// Migrate runs auto-migration for all QuoteForge tables
+func Migrate(db *gorm.DB) error {
+	return db.AutoMigrate(AllModels()...)
+}
+
+// SeedCategories inserts default categories if not exist
+func SeedCategories(db *gorm.DB) error {
+	for _, cat := range DefaultCategories {
+		result := db.Where("code = ?", cat.Code).FirstOrCreate(&cat)
+		if result.Error != nil {
+			return result.Error
+		}
+	}
+	return nil
+}
+
+// SeedAdminUser creates default admin user if not exists
+// Default credentials: admin / admin123
+func SeedAdminUser(db *gorm.DB, passwordHash string) error {
+	var count int64
+	db.Model(&User{}).Where("username = ?", "admin").Count(&count)
+	if count > 0 {
+		return nil
+	}
+
+	admin := &User{
+		Username:     "admin",
+		Email:        "admin@example.com",
+		PasswordHash: passwordHash,
+		Role:         RoleAdmin,
+		IsActive:     true,
+	}
+	return db.Create(admin).Error
+}
--- a/internal/models/user.go
+++ b/internal/models/user.go
@@ -0,0 +1,39 @@
+package models
+
+import "time"
+
+type UserRole string
+
+const (
+	RoleViewer       UserRole = "viewer"
+	RoleEditor       UserRole = "editor"
+	RolePricingAdmin UserRole = "pricing_admin"
+	RoleAdmin        UserRole = "admin"
+)
+
+type User struct {
+	ID           uint      `gorm:"primaryKey;autoIncrement" json:"id"`
+	Username     string    `gorm:"size:100;uniqueIndex;not null" json:"username"`
+	Email        string    `gorm:"size:255;uniqueIndex;not null" json:"email"`
+	PasswordHash string    `gorm:"size:255;not null" json:"-"`
+	Role         UserRole  `gorm:"type:enum('viewer','editor','pricing_admin','admin');default:'viewer'" json:"role"`
+	IsActive     bool      `gorm:"default:true" json:"is_active"`
+	CreatedAt    time.Time `gorm:"autoCreateTime" json:"created_at"`
+	UpdatedAt    time.Time `gorm:"autoUpdateTime" json:"updated_at"`
+}
+
+func (User) TableName() string {
+	return "qt_users"
+}
+
+func (u *User) CanEdit() bool {
+	return u.Role == RoleEditor || u.Role == RolePricingAdmin || u.Role == RoleAdmin
+}
+
+func (u *User) CanManagePricing() bool {
+	return u.Role == RolePricingAdmin || u.Role == RoleAdmin
+}
+
+func (u *User) CanManageUsers() bool {
+	return u.Role == RoleAdmin
+}
--- a/internal/repository/alert.go
+++ b/internal/repository/alert.go
@@ -0,0 +1,91 @@
+package repository
+
+import (
+	"git.mchus.pro/mchus/quoteforge/internal/models"
+	"gorm.io/gorm"
+)
+
+type AlertRepository struct {
+	db *gorm.DB
+}
+
+func NewAlertRepository(db *gorm.DB) *AlertRepository {
+	return &AlertRepository{db: db}
+}
+
+func (r *AlertRepository) Create(alert *models.PricingAlert) error {
+	return r.db.Create(alert).Error
+}
+
+func (r *AlertRepository) GetByID(id uint) (*models.PricingAlert, error) {
+	var alert models.PricingAlert
+	err := r.db.First(&alert, id).Error
+	if err != nil {
+		return nil, err
+	}
+	return &alert, nil
+}
+
+func (r *AlertRepository) Update(alert *models.PricingAlert) error {
+	return r.db.Save(alert).Error
+}
+
+type AlertFilter struct {
+	Status   models.AlertStatus
+	Severity models.AlertSeverity
+	Type     models.AlertType
+	LotName  string
+}
+
+func (r *AlertRepository) List(filter AlertFilter, offset, limit int) ([]models.PricingAlert, int64, error) {
+	var alerts []models.PricingAlert
+	var total int64
+
+	query := r.db.Model(&models.PricingAlert{})
+
+	if filter.Status != "" {
+		query = query.Where("status = ?", filter.Status)
+	}
+	if filter.Severity != "" {
+		query = query.Where("severity = ?", filter.Severity)
+	}
+	if filter.Type != "" {
+		query = query.Where("alert_type = ?", filter.Type)
+	}
+	if filter.LotName != "" {
+		query = query.Where("lot_name = ?", filter.LotName)
+	}
+
+	query.Count(&total)
+
+	err := query.
+		Order("FIELD(severity, 'critical', 'high', 'medium', 'low')").
+		Order("created_at DESC").
+		Offset(offset).
+		Limit(limit).
+		Find(&alerts).Error
+
+	return alerts, total, err
+}
+
+func (r *AlertRepository) CountByStatus(status models.AlertStatus) (int64, error) {
+	var count int64
+	err := r.db.Model(&models.PricingAlert{}).
+		Where("status = ?", status).
+		Count(&count).Error
+	return count, err
+}
+
+func (r *AlertRepository) UpdateStatus(id uint, status models.AlertStatus) error {
+	return r.db.Model(&models.PricingAlert{}).
+		Where("id = ?", id).
+		Update("status", status).Error
+}
+
+func (r *AlertRepository) ExistsByLotAndType(lotName string, alertType models.AlertType) (bool, error) {
+	var count int64
+	err := r.db.Model(&models.PricingAlert{}).
+		Where("lot_name = ? AND alert_type = ? AND status IN ('new', 'acknowledged')", lotName, alertType).
+		Count(&count).Error
+	return count > 0, err
+}
--- a/internal/repository/category.go
+++ b/internal/repository/category.go
@@ -0,0 +1,76 @@
+package repository
+
+import (
+	"git.mchus.pro/mchus/quoteforge/internal/models"
+	"gorm.io/gorm"
+)
+
+type CategoryRepository struct {
+	db *gorm.DB
+}
+
+func NewCategoryRepository(db *gorm.DB) *CategoryRepository {
+	return &CategoryRepository{db: db}
+}
+
+func (r *CategoryRepository) GetAll() ([]models.Category, error) {
+	var categories []models.Category
+	err := r.db.Order("display_order ASC").Find(&categories).Error
+	return categories, err
+}
+
+func (r *CategoryRepository) GetByCode(code string) (*models.Category, error) {
+	var category models.Category
+	err := r.db.Where("code = ?", code).First(&category).Error
+	if err != nil {
+		return nil, err
+	}
+	return &category, nil
+}
+
+func (r *CategoryRepository) GetByID(id uint) (*models.Category, error) {
+	var category models.Category
+	err := r.db.First(&category, id).Error
+	if err != nil {
+		return nil, err
+	}
+	return &category, nil
+}
+
+// CreateIfNotExists creates a new category if it doesn't exist, returns existing one if it does
+func (r *CategoryRepository) CreateIfNotExists(code string) (*models.Category, error) {
+	// Try to find existing
+	existing, err := r.GetByCode(code)
+	if err == nil {
+		return existing, nil
+	}
+
+	// Get max display order to put new category at the end
+	var maxOrder int
+	r.db.Model(&models.Category{}).Select("COALESCE(MAX(display_order), 0)").Scan(&maxOrder)
+
+	// Create new category
+	newCat := &models.Category{
+		Code:         code,
+		Name:         code, // Use code as name initially
+		NameRu:       code,
+		DisplayOrder: maxOrder + 1,
+		IsRequired:   false,
+	}
+
+	if err := r.db.Create(newCat).Error; err != nil {
+		return nil, err
+	}
+
+	return newCat, nil
+}
+
+// Create creates a new category
+func (r *CategoryRepository) Create(category *models.Category) error {
+	return r.db.Create(category).Error
+}
+
+// Update updates an existing category
+func (r *CategoryRepository) Update(category *models.Category) error {
+	return r.db.Save(category).Error
+}
--- a/internal/repository/component.go
+++ b/internal/repository/component.go
@@ -0,0 +1,141 @@
+package repository
+
+import (
+	"time"
+
+	"git.mchus.pro/mchus/quoteforge/internal/models"
+	"gorm.io/gorm"
+)
+
+type ComponentRepository struct {
+	db *gorm.DB
+}
+
+func NewComponentRepository(db *gorm.DB) *ComponentRepository {
+	return &ComponentRepository{db: db}
+}
+
+type ComponentFilter struct {
+	Category     string
+	Search       string
+	HasPrice     bool
+	ExcludeHidden bool
+	SortField    string
+	SortDir      string
+}
+
+func (r *ComponentRepository) List(filter ComponentFilter, offset, limit int) ([]models.LotMetadata, int64, error) {
+	var components []models.LotMetadata
+	var total int64
+
+	query := r.db.Model(&models.LotMetadata{}).
+		Preload("Lot").
+		Preload("Category")
+
+	if filter.Category != "" {
+		query = query.Joins("JOIN qt_categories ON qt_lot_metadata.category_id = qt_categories.id").
+			Where("qt_categories.code = ?", filter.Category)
+	}
+	if filter.Search != "" {
+		search := "%" + filter.Search + "%"
+		query = query.Where("lot_name LIKE ? OR model LIKE ?", search, search)
+	}
+	if filter.HasPrice {
+		query = query.Where("current_price IS NOT NULL AND current_price > 0")
+	}
+	if filter.ExcludeHidden {
+		query = query.Where("is_hidden = ? OR is_hidden IS NULL", false)
+	}
+
+	query.Count(&total)
+
+	// Apply sorting
+	sortDir := "ASC"
+	if filter.SortDir == "desc" {
+		sortDir = "DESC"
+	}
+
+	switch filter.SortField {
+	case "popularity_score":
+		query = query.Order("popularity_score " + sortDir)
+	case "current_price":
+		query = query.Order("CASE WHEN current_price IS NULL OR current_price = 0 THEN 1 ELSE 0 END").
+			Order("current_price " + sortDir)
+	case "lot_name":
+		query = query.Order("lot_name " + sortDir)
+	case "quote_count":
+		// Sort by quote count from lot_log table
+		query = query.
+			Select("qt_lot_metadata.*, (SELECT COUNT(*) FROM lot_log WHERE lot_log.lot = qt_lot_metadata.lot_name) as quote_count_sort").
+			Order("quote_count_sort " + sortDir)
+	default:
+		// Default: sort by popularity, no price goes last
+		query = query.
+			Order("CASE WHEN current_price IS NULL OR current_price = 0 THEN 1 ELSE 0 END").
+			Order("popularity_score DESC")
+	}
+
+	err := query.
+		Offset(offset).
+		Limit(limit).
+		Find(&components).Error
+
+	return components, total, err
+}
+
+func (r *ComponentRepository) GetByLotName(lotName string) (*models.LotMetadata, error) {
+	var component models.LotMetadata
+	err := r.db.
+		Preload("Lot").
+		Preload("Category").
+		Where("lot_name = ?", lotName).
+		First(&component).Error
+	if err != nil {
+		return nil, err
+	}
+	return &component, nil
+}
+
+func (r *ComponentRepository) GetMultiple(lotNames []string) ([]models.LotMetadata, error) {
+	var components []models.LotMetadata
+	err := r.db.
+		Preload("Lot").
+		Preload("Category").
+		Where("lot_name IN ?", lotNames).
+		Find(&components).Error
+	return components, err
+}
+
+func (r *ComponentRepository) Update(component *models.LotMetadata) error {
+	return r.db.Save(component).Error
+}
+
+func (r *ComponentRepository) Create(component *models.LotMetadata) error {
+	return r.db.Create(component).Error
+}
+
+func (r *ComponentRepository) IncrementRequestCount(lotName string) error {
+	now := time.Now()
+	return r.db.Model(&models.LotMetadata{}).
+		Where("lot_name = ?", lotName).
+		Updates(map[string]interface{}{
+			"request_count":     gorm.Expr("request_count + 1"),
+			"last_request_date": now,
+		}).Error
+}
+
+// GetAllLots returns all lots from the existing lot table
+func (r *ComponentRepository) GetAllLots() ([]models.Lot, error) {
+	var lots []models.Lot
+	err := r.db.Find(&lots).Error
+	return lots, err
+}
+
+// GetLotsWithoutMetadata returns lots that don't have qt_lot_metadata entries
+func (r *ComponentRepository) GetLotsWithoutMetadata() ([]models.Lot, error) {
+	var lots []models.Lot
+	err := r.db.
+		Where("lot_name NOT IN (SELECT lot_name FROM qt_lot_metadata)").
+		Find(&lots).Error
+	return lots, err
+}
--- a/internal/repository/configuration.go
+++ b/internal/repository/configuration.go
@@ -0,0 +1,75 @@
+package repository
+
+import (
+	"git.mchus.pro/mchus/quoteforge/internal/models"
+	"gorm.io/gorm"
+)
+
+type ConfigurationRepository struct {
+	db *gorm.DB
+}
+
+func NewConfigurationRepository(db *gorm.DB) *ConfigurationRepository {
+	return &ConfigurationRepository{db: db}
+}
+
+func (r *ConfigurationRepository) Create(config *models.Configuration) error {
+	return r.db.Create(config).Error
+}
+
+func (r *ConfigurationRepository) GetByID(id uint) (*models.Configuration, error) {
+	var config models.Configuration
+	err := r.db.Preload("User").First(&config, id).Error
+	if err != nil {
+		return nil, err
+	}
+	return &config, nil
+}
+
+func (r *ConfigurationRepository) GetByUUID(uuid string) (*models.Configuration, error) {
+	var config models.Configuration
+	err := r.db.Preload("User").Where("uuid = ?", uuid).First(&config).Error
+	if err != nil {
+		return nil, err
+	}
+	return &config, nil
+}
+
+func (r *ConfigurationRepository) Update(config *models.Configuration) error {
+	return r.db.Save(config).Error
+}
+
+func (r *ConfigurationRepository) Delete(id uint) error {
+	return r.db.Delete(&models.Configuration{}, id).Error
+}
+
+func (r *ConfigurationRepository) ListByUser(userID uint, offset, limit int) ([]models.Configuration, int64, error) {
+	var configs []models.Configuration
+	var total int64
+
+	r.db.Model(&models.Configuration{}).Where("user_id = ?", userID).Count(&total)
+	err := r.db.
+		Where("user_id = ?", userID).
+		Order("created_at DESC").
+		Offset(offset).
+		Limit(limit).
+		Find(&configs).Error
+
+	return configs, total, err
+}
+
+func (r *ConfigurationRepository) ListTemplates(offset, limit int) ([]models.Configuration, int64, error) {
+	var configs []models.Configuration
+	var total int64
+
+	r.db.Model(&models.Configuration{}).Where("is_template = ?", true).Count(&total)
+	err := r.db.
+		Preload("User").
+		Where("is_template = ?", true).
+		Order("created_at DESC").
+		Offset(offset).
+		Limit(limit).
+		Find(&configs).Error
+
+	return configs, total, err
+}
--- a/internal/repository/price.go
+++ b/internal/repository/price.go
@@ -0,0 +1,124 @@
+package repository
+
+import (
+	"time"
+
+	"git.mchus.pro/mchus/quoteforge/internal/models"
+	"gorm.io/gorm"
+)
+
+type PriceRepository struct {
+	db *gorm.DB
+}
+
+func NewPriceRepository(db *gorm.DB) *PriceRepository {
+	return &PriceRepository{db: db}
+}
+
+type PricePoint struct {
+	Price float64
+	Date  time.Time
+}
+
+// GetPriceHistory returns price history from lot_log for a component
+func (r *PriceRepository) GetPriceHistory(lotName string, periodDays int) ([]PricePoint, error) {
+	var points []PricePoint
+	since := time.Now().AddDate(0, 0, -periodDays)
+
+	err := r.db.Model(&models.LotLog{}).
+		Select("price, date").
+		Where("lot = ? AND date >= ?", lotName, since).
+		Order("date DESC").
+		Scan(&points).Error
+
+	return points, err
+}
+
+// GetLatestPrice returns the most recent price for a component
+func (r *PriceRepository) GetLatestPrice(lotName string) (*PricePoint, error) {
+	var point PricePoint
+	err := r.db.Model(&models.LotLog{}).
+		Select("price, date").
+		Where("lot = ?", lotName).
+		Order("date DESC").
+		First(&point).Error
+	if err != nil {
+		return nil, err
+	}
+	return &point, nil
+}
+
+// GetPriceOverride returns active override for a component
+func (r *PriceRepository) GetPriceOverride(lotName string) (*models.PriceOverride, error) {
+	var override models.PriceOverride
+	today := time.Now().Truncate(24 * time.Hour)
+
+	err := r.db.
+		Where("lot_name = ?", lotName).
+		Where("valid_from <= ?", today).
+		Where("valid_until IS NULL OR valid_until >= ?", today).
+		Order("valid_from DESC").
+		First(&override).Error
+
+	if err != nil {
+		return nil, err
+	}
+	return &override, nil
+}
+
+// CreatePriceOverride creates a new price override
+func (r *PriceRepository) CreatePriceOverride(override *models.PriceOverride) error {
+	return r.db.Create(override).Error
+}
+
+// GetPriceOverrides returns all overrides for a component
+func (r *PriceRepository) GetPriceOverrides(lotName string) ([]models.PriceOverride, error) {
+	var overrides []models.PriceOverride
+	err := r.db.
+		Where("lot_name = ?", lotName).
+		Order("valid_from DESC").
+		Find(&overrides).Error
+	return overrides, err
+}
+
+// DeletePriceOverride deletes an override
+func (r *PriceRepository) DeletePriceOverride(id uint) error {
+	return r.db.Delete(&models.PriceOverride{}, id).Error
+}
+
+// GetQuoteCount returns the number of quotes in lot_log for a period
+func (r *PriceRepository) GetQuoteCount(lotName string, periodDays int) (int64, error) {
+	var count int64
+	since := time.Now().AddDate(0, 0, -periodDays)
+
+	err := r.db.Model(&models.LotLog{}).
+		Where("lot = ? AND date >= ?", lotName, since).
+		Count(&count).Error
+
+	return count, err
+}
+
+// GetQuoteCounts returns quote counts for multiple lot names
+func (r *PriceRepository) GetQuoteCounts(lotNames []string) (map[string]int64, error) {
+	type Result struct {
+		Lot   string
+		Count int64
+	}
+	var results []Result
+
+	err := r.db.Model(&models.LotLog{}).
+		Select("lot, COUNT(*) as count").
+		Where("lot IN ?", lotNames).
+		Group("lot").
+		Scan(&results).Error
+
+	if err != nil {
+		return nil, err
+	}
+
+	counts := make(map[string]int64)
+	for _, r := range results {
+		counts[r.Lot] = r.Count
+	}
+	return counts, nil
+}
--- a/internal/repository/stats.go
+++ b/internal/repository/stats.go
@@ -0,0 +1,115 @@
+package repository
+
+import (
+	"time"
+
+	"git.mchus.pro/mchus/quoteforge/internal/models"
+	"gorm.io/gorm"
+)
+
+type StatsRepository struct {
+	db *gorm.DB
+}
+
+func NewStatsRepository(db *gorm.DB) *StatsRepository {
+	return &StatsRepository{db: db}
+}
+
+func (r *StatsRepository) GetByLotName(lotName string) (*models.ComponentUsageStats, error) {
+	var stats models.ComponentUsageStats
+	err := r.db.Where("lot_name = ?", lotName).First(&stats).Error
+	if err != nil {
+		return nil, err
+	}
+	return &stats, nil
+}
+
+func (r *StatsRepository) Upsert(stats *models.ComponentUsageStats) error {
+	return r.db.Save(stats).Error
+}
+
+func (r *StatsRepository) IncrementUsage(lotName string, quantity int, revenue float64) error {
+	now := time.Now()
+
+	result := r.db.Model(&models.ComponentUsageStats{}).
+		Where("lot_name = ?", lotName).
+		Updates(map[string]interface{}{
+			"quotes_total":    gorm.Expr("quotes_total + 1"),
+			"quotes_last_30d": gorm.Expr("quotes_last_30d + 1"),
+			"quotes_last_7d":  gorm.Expr("quotes_last_7d + 1"),
+			"total_quantity":  gorm.Expr("total_quantity + ?", quantity),
+			"total_revenue":   gorm.Expr("total_revenue + ?", revenue),
+			"last_used_at":    now,
+		})
+
+	if result.RowsAffected == 0 {
+		stats := &models.ComponentUsageStats{
+			LotName:       lotName,
+			QuotesTotal:   1,
+			QuotesLast30d: 1,
+			QuotesLast7d:  1,
+			TotalQuantity: quantity,
+			TotalRevenue:  revenue,
+			LastUsedAt:    &now,
+		}
+		return r.db.Create(stats).Error
+	}
+
+	return result.Error
+}
+
+func (r *StatsRepository) GetTopComponents(limit int) ([]models.ComponentUsageStats, error) {
+	var stats []models.ComponentUsageStats
+	err := r.db.
+		Order("quotes_last_30d DESC").
+		Limit(limit).
+		Find(&stats).Error
+	return stats, err
+}
+
+func (r *StatsRepository) GetTrendingComponents(limit int) ([]models.ComponentUsageStats, error) {
+	var stats []models.ComponentUsageStats
+	err := r.db.
+		Where("trend_direction = ? AND trend_percent > ?", models.TrendUp, 20).
+		Order("trend_percent DESC").
+		Limit(limit).
+		Find(&stats).Error
+	return stats, err
+}
+
+// ResetWeeklyCounters resets quotes_last_7d (run weekly via cron)
+func (r *StatsRepository) ResetWeeklyCounters() error {
+	return r.db.Model(&models.ComponentUsageStats{}).
+		Where("1 = 1").
+		Update("quotes_last_7d", 0).Error
+}
+
+// ResetMonthlyCounters resets quotes_last_30d (run monthly via cron)
+func (r *StatsRepository) ResetMonthlyCounters() error {
+	return r.db.Model(&models.ComponentUsageStats{}).
+		Where("1 = 1").
+		Update("quotes_last_30d", 0).Error
+}
+
+// UpdatePopularityScores recalculates popularity_score in qt_lot_metadata
+// based on supplier quotes from lot_log table
+func (r *StatsRepository) UpdatePopularityScores() error {
+	// Formula: popularity_score = quotes_last_30d * 3 + quotes_last_90d * 1 + quotes_total * 0.1
+	// This gives more weight to recent supplier activity
+	return r.db.Exec(`
+		UPDATE qt_lot_metadata m
+		LEFT JOIN (
+			SELECT
+				lot,
+				COUNT(*) as quotes_total,
+				SUM(CASE WHEN date >= DATE_SUB(NOW(), INTERVAL 30 DAY) THEN 1 ELSE 0 END) as quotes_last_30d,
+				SUM(CASE WHEN date >= DATE_SUB(NOW(), INTERVAL 90 DAY) THEN 1 ELSE 0 END) as quotes_last_90d
+			FROM lot_log
+			GROUP BY lot
+		) s ON m.lot_name = s.lot
+		SET m.popularity_score = COALESCE(
+			s.quotes_last_30d * 3 + s.quotes_last_90d * 1 + s.quotes_total * 0.1,
+			0
+		)
+	`).Error
+}
--- a/internal/repository/user.go
+++ b/internal/repository/user.go
@@ -0,0 +1,62 @@
+package repository
+
+import (
+	"git.mchus.pro/mchus/quoteforge/internal/models"
+	"gorm.io/gorm"
+)
+
+type UserRepository struct {
+	db *gorm.DB
+}
+
+func NewUserRepository(db *gorm.DB) *UserRepository {
+	return &UserRepository{db: db}
+}
+
+func (r *UserRepository) Create(user *models.User) error {
+	return r.db.Create(user).Error
+}
+
+func (r *UserRepository) GetByID(id uint) (*models.User, error) {
+	var user models.User
+	err := r.db.First(&user, id).Error
+	if err != nil {
+		return nil, err
+	}
+	return &user, nil
+}
+
+func (r *UserRepository) GetByUsername(username string) (*models.User, error) {
+	var user models.User
+	err := r.db.Where("username = ?", username).First(&user).Error
+	if err != nil {
+		return nil, err
+	}
+	return &user, nil
+}
+
+func (r *UserRepository) GetByEmail(email string) (*models.User, error) {
+	var user models.User
+	err := r.db.Where("email = ?", email).First(&user).Error
+	if err != nil {
+		return nil, err
+	}
+	return &user, nil
+}
+
+func (r *UserRepository) Update(user *models.User) error {
+	return r.db.Save(user).Error
+}
+
+func (r *UserRepository) Delete(id uint) error {
+	return r.db.Delete(&models.User{}, id).Error
+}
+
+func (r *UserRepository) List(offset, limit int) ([]models.User, int64, error) {
+	var users []models.User
+	var total int64
+
+	r.db.Model(&models.User{}).Count(&total)
+	err := r.db.Offset(offset).Limit(limit).Find(&users).Error
+	return users, total, err
+}
--- a/internal/services/alerts/service.go
+++ b/internal/services/alerts/service.go
@@ -0,0 +1,199 @@
+package alerts
+
+import (
+	"fmt"
+	"time"
+
+	"git.mchus.pro/mchus/quoteforge/internal/config"
+	"git.mchus.pro/mchus/quoteforge/internal/models"
+	"git.mchus.pro/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)
+}
--- a/internal/services/auth.go
+++ b/internal/services/auth.go
@@ -0,0 +1,180 @@
+package services
+
+import (
+	"errors"
+	"time"
+
+	"github.com/golang-jwt/jwt/v5"
+	"git.mchus.pro/mchus/quoteforge/internal/config"
+	"git.mchus.pro/mchus/quoteforge/internal/models"
+	"git.mchus.pro/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
+}
--- a/internal/services/component.go
+++ b/internal/services/component.go
@@ -0,0 +1,194 @@
+package services
+
+import (
+	"strings"
+
+	"git.mchus.pro/mchus/quoteforge/internal/models"
+	"git.mchus.pro/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 and model from lot_name
+// "CPU_AMD_9654" → category="CPU", model="AMD_9654"
+// "MB_INTEL_4.Sapphire_2S_32xDDR5" → category="MB", model="INTEL_4.Sapphire_2S_32xDDR5"
+func ParsePartNumber(lotName string) (category, model string) {
+	parts := strings.SplitN(lotName, "_", 2)
+	if len(parts) >= 1 {
+		category = parts[0]
+	}
+	if len(parts) >= 2 {
+		model = parts[1]
+	}
+	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"`
+	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 = 20
+	}
+	if perPage > 5000 {
+		perPage = 5000
+	}
+	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,
+			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,
+		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()
+}
+
+// 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[strings.ToUpper(cat.Code)] = cat.ID
+	}
+
+	imported := 0
+	for _, lot := range lots {
+		// Use lot_category from database if available, otherwise parse from lot_name
+		var category string
+		if lot.LotCategory != nil && *lot.LotCategory != "" {
+			category = strings.ToUpper(*lot.LotCategory)
+		} else {
+			category, _ = ParsePartNumber(lot.LotName)
+			category = strings.ToUpper(category)
+		}
+
+		_, model := ParsePartNumber(lot.LotName)
+
+		metadata := &models.LotMetadata{
+			LotName: lot.LotName,
+			Model:   model,
+			Specs:   make(models.Specs),
+		}
+
+		if catID, ok := categoryMap[category]; ok {
+			metadata.CategoryID = &catID
+		} else {
+			// Create new category if it doesn't exist
+			newCat, err := s.categoryRepo.CreateIfNotExists(category)
+			if err == nil && newCat != nil {
+				metadata.CategoryID = &newCat.ID
+			}
+		}
+
+		if err := s.componentRepo.Create(metadata); err != nil {
+			continue
+		}
+		imported++
+	}
+
+	return imported, nil
+}
--- a/internal/services/configuration.go
+++ b/internal/services/configuration.go
@@ -0,0 +1,243 @@
+package services
+
+import (
+	"errors"
+
+	"github.com/google/uuid"
+	"git.mchus.pro/mchus/quoteforge/internal/models"
+	"git.mchus.pro/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"`
+	CustomPrice *float64            `json:"custom_price"`
+	Notes       string              `json:"notes"`
+	IsTemplate  bool                `json:"is_template"`
+	ServerCount int                 `json:"server_count"`
+}
+
+func (s *ConfigurationService) Create(userID uint, req *CreateConfigRequest) (*models.Configuration, error) {
+	total := req.Items.Total()
+
+	// If server count is greater than 1, multiply the total by server count
+	if req.ServerCount > 1 {
+		total *= float64(req.ServerCount)
+	}
+
+	config := &models.Configuration{
+		UUID:        uuid.New().String(),
+		UserID:      userID,
+		Name:        req.Name,
+		Items:       req.Items,
+		TotalPrice:  &total,
+		CustomPrice: req.CustomPrice,
+		Notes:       req.Notes,
+		IsTemplate:  req.IsTemplate,
+		ServerCount: req.ServerCount,
+	}
+
+	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()
+
+	// If server count is greater than 1, multiply the total by server count
+	if req.ServerCount > 1 {
+		total *= float64(req.ServerCount)
+	}
+
+	config.Name = req.Name
+	config.Items = req.Items
+	config.TotalPrice = &total
+	config.CustomPrice = req.CustomPrice
+	config.Notes = req.Notes
+	config.IsTemplate = req.IsTemplate
+	config.ServerCount = req.ServerCount
+
+	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) Rename(uuid string, userID uint, newName string) (*models.Configuration, error) {
+	config, err := s.configRepo.GetByUUID(uuid)
+	if err != nil {
+		return nil, ErrConfigNotFound
+	}
+
+	if config.UserID != userID {
+		return nil, ErrConfigForbidden
+	}
+
+	config.Name = newName
+
+	if err := s.configRepo.Update(config); err != nil {
+		return nil, err
+	}
+
+	return config, nil
+}
+
+func (s *ConfigurationService) Clone(configUUID string, userID uint, newName string) (*models.Configuration, error) {
+	original, err := s.GetByUUID(configUUID, userID)
+	if err != nil {
+		return nil, err
+	}
+
+	// Create copy with new UUID and name
+	total := original.Items.Total()
+
+	// If server count is greater than 1, multiply the total by server count
+	if original.ServerCount > 1 {
+		total *= float64(original.ServerCount)
+	}
+
+	clone := &models.Configuration{
+		UUID:        uuid.New().String(),
+		UserID:      userID,
+		Name:        newName,
+		Items:       original.Items,
+		TotalPrice:  &total,
+		CustomPrice: original.CustomPrice,
+		Notes:       original.Notes,
+		IsTemplate:  false, // Clone is never a template
+		ServerCount: original.ServerCount,
+	}
+
+	if err := s.configRepo.Create(clone); err != nil {
+		return nil, err
+	}
+
+	return clone, nil
+}
+
+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)
+// }
--- a/internal/services/export.go
+++ b/internal/services/export.go
@@ -0,0 +1,147 @@
+package services
+
+import (
+	"bytes"
+	"encoding/csv"
+	"fmt"
+	"time"
+
+	"git.mchus.pro/mchus/quoteforge/internal/config"
+	"git.mchus.pro/mchus/quoteforge/internal/models"
+	"git.mchus.pro/mchus/quoteforge/internal/repository"
+)
+
+type ExportService struct {
+	config     config.ExportConfig
+	categoryRepo *repository.CategoryRepository
+}
+
+func NewExportService(cfg config.ExportConfig, categoryRepo *repository.CategoryRepository) *ExportService {
+	return &ExportService{
+		config:       cfg,
+		categoryRepo: categoryRepo,
+	}
+}
+
+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
+	}
+
+	// Get category hierarchy for sorting
+	categoryOrder := make(map[string]int)
+	if s.categoryRepo != nil {
+		categories, err := s.categoryRepo.GetAll()
+		if err == nil {
+			for _, cat := range categories {
+				categoryOrder[cat.Code] = cat.DisplayOrder
+			}
+		}
+	}
+
+	// Sort items by category display order
+	sortedItems := make([]ExportItem, len(data.Items))
+	copy(sortedItems, data.Items)
+
+	// Sort using category display order (items without category go to the end)
+	for i := 0; i < len(sortedItems)-1; i++ {
+		for j := i + 1; j < len(sortedItems); j++ {
+			orderI, hasI := categoryOrder[sortedItems[i].Category]
+			orderJ, hasJ := categoryOrder[sortedItems[j].Category]
+
+			// Items without category go to the end
+			if !hasI && hasJ {
+				sortedItems[i], sortedItems[j] = sortedItems[j], sortedItems[i]
+			} else if hasI && hasJ {
+				// Both have categories, sort by display order
+				if orderI > orderJ {
+					sortedItems[i], sortedItems[j] = sortedItems[j], sortedItems[i]
+				}
+			}
+		}
+	}
+
+	// Items
+	for _, item := range sortedItems {
+		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) ConfigToExportData(config *models.Configuration, componentService *ComponentService) *ExportData {
+	items := make([]ExportItem, len(config.Items))
+	var total float64
+
+	for i, item := range config.Items {
+		itemTotal := item.UnitPrice * float64(item.Quantity)
+
+		// Получаем информацию о компоненте для заполнения категории
+		componentView, err := componentService.GetByLotName(item.LotName)
+		if err != nil {
+			// Если не удалось получить информацию о компоненте, используем только основные данные
+			items[i] = ExportItem{
+				LotName:    item.LotName,
+				Quantity:   item.Quantity,
+				UnitPrice:  item.UnitPrice,
+				TotalPrice: itemTotal,
+			}
+		} else {
+			items[i] = ExportItem{
+				LotName:     item.LotName,
+				Description: componentView.Description,
+				Category:    componentView.Category,
+				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,
+	}
+}
--- a/internal/services/pricing/calculator.go
+++ b/internal/services/pricing/calculator.go
@@ -0,0 +1,121 @@
+package pricing
+
+import (
+	"math"
+	"sort"
+	"time"
+
+	"git.mchus.pro/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))
+}
--- a/internal/services/pricing/service.go
+++ b/internal/services/pricing/service.go
@@ -0,0 +1,205 @@
+package pricing
+
+import (
+	"time"
+
+	"git.mchus.pro/mchus/quoteforge/internal/config"
+	"git.mchus.pro/mchus/quoteforge/internal/models"
+	"git.mchus.pro/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"`
+}
+
+// RecalculateAllPrices recalculates prices for all components
+func (s *Service) RecalculateAllPrices() (updated int, errors int) {
+	// Get all components
+	filter := repository.ComponentFilter{}
+	offset := 0
+	limit := 100
+
+	for {
+		components, _, err := s.componentRepo.List(filter, offset, limit)
+		if err != nil || len(components) == 0 {
+			break
+		}
+
+		for _, comp := range components {
+			if err := s.UpdateComponentPrice(comp.LotName); err != nil {
+				errors++
+			} else {
+				updated++
+			}
+		}
+
+		offset += limit
+	}
+
+	return updated, errors
+}
--- a/internal/services/quote.go
+++ b/internal/services/quote.go
@@ -0,0 +1,139 @@
+package services
+
+import (
+	"errors"
+
+	"git.mchus.pro/mchus/quoteforge/internal/models"
+	"git.mchus.pro/mchus/quoteforge/internal/repository"
+	"git.mchus.pro/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
+}
--- a/migrations/001_add_lot_category.sql
+++ b/migrations/001_add_lot_category.sql
@@ -0,0 +1,11 @@
+-- Migration: Add lot_category column to lot table
+-- Run this migration manually on the database
+
+-- Add lot_category column to lot table
+ALTER TABLE lot ADD COLUMN lot_category VARCHAR(50) DEFAULT NULL;
+
+-- Create index for faster lookups
+CREATE INDEX idx_lot_category ON lot(lot_category);
+
+-- Update existing lots: extract category from lot_name (first part before underscore)
+UPDATE lot SET lot_category = SUBSTRING_INDEX(lot_name, '_', 1) WHERE lot_category IS NULL;
--- a/migrations/002_add_custom_price.sql
+++ b/migrations/002_add_custom_price.sql
@@ -0,0 +1,2 @@
+-- Add custom_price column to qt_configurations table
+ALTER TABLE qt_configurations ADD COLUMN custom_price DECIMAL(12,2) NULL COMMENT 'User-defined custom total price';
--- a/migrations/003_add_is_hidden.sql
+++ b/migrations/003_add_is_hidden.sql
@@ -0,0 +1,2 @@
+-- Add is_hidden column to qt_lot_metadata table
+ALTER TABLE qt_lot_metadata ADD COLUMN is_hidden BOOLEAN DEFAULT FALSE COMMENT 'Hide component from configurator';
--- a/web/static/app.css
+++ b/web/static/app.css
@@ -0,0 +1,9 @@
+/* QuoteForge custom styles */
+/* Tailwind is loaded via CDN, this file is for any custom overrides */
+
+.line-clamp-2 {
+    display: -webkit-box;
+    -webkit-line-clamp: 2;
+    -webkit-box-orient: vertical;
+    overflow: hidden;
+}
--- a/web/templates/admin_pricing.html
+++ b/web/templates/admin_pricing.html
@@ -0,0 +1,856 @@
+{{define "title"}}Цены - QuoteForge{{end}}
+
+{{define "content"}}
+<div class="space-y-4">
+    <h1 class="text-2xl font-bold">Управление ценами</h1>
+
+    <div class="bg-white rounded-lg shadow p-4">
+        <div class="flex justify-between items-center border-b pb-4 mb-4">
+            <div class="flex gap-4">
+                <button onclick="loadTab('alerts')" id="btn-alerts" class="text-blue-600 font-medium">Алерты</button>
+                <button onclick="loadTab('components')" id="btn-components" class="text-gray-600">Компоненты</button>
+                <button onclick="loadTab('all-configs')" id="btn-all-configs" class="text-gray-600 hidden">Все конфигурации</button>
+            </div>
+            <button onclick="recalculateAll()" id="btn-recalc" class="px-3 py-1 bg-green-600 text-white text-sm rounded hover:bg-green-700">
+                Пересчитать цены
+            </button>
+        </div>
+
+        <!-- Progress bar -->
+        <div id="progress-container" class="mb-4 p-4 bg-blue-50 rounded-lg border border-blue-200" style="display:none;">
+            <div class="flex justify-between text-sm text-gray-700 mb-2">
+                <span id="progress-text" class="font-medium">Пересчёт цен...</span>
+                <span id="progress-percent" class="font-bold">0%</span>
+            </div>
+            <div class="w-full bg-gray-200 rounded-full h-4">
+                <div id="progress-bar" class="bg-blue-600 h-4 rounded-full transition-all duration-300" style="width: 0%"></div>
+            </div>
+            <div class="text-sm text-gray-600 mt-2">
+                <span id="progress-stats"></span>
+            </div>
+        </div>
+
+        <!-- Search and sort (only for components) -->
+        <div id="search-bar" class="mb-4 hidden">
+            <div class="flex gap-4 items-center">
+                <input type="text" id="search-input" placeholder="Поиск по артикулу..."
+                       class="flex-1 px-3 py-2 border rounded"
+                       onkeyup="debounceSearch()">
+                <div class="flex items-center gap-2">
+                    <span class="text-sm text-gray-500">Сортировка:</span>
+                    <select id="sort-field" class="px-2 py-1 border rounded text-sm" onchange="changeSort()">
+                        <option value="lot_name">Артикул</option>
+                        <option value="popularity_score" selected>Популярность</option>
+                        <option value="quote_count">Кол-во котировок</option>
+                        <option value="current_price">Цена</option>
+                    </select>
+                    <button onclick="toggleSortDir()" id="sort-dir-btn" class="px-2 py-1 border rounded text-sm">↓</button>
+                </div>
+            </div>
+        </div>
+
+        <div id="tab-content">
+            <div class="text-center py-8 text-gray-500">Загрузка...</div>
+        </div>
+
+        <!-- Pagination -->
+        <div id="pagination" class="flex justify-between items-center mt-4 pt-4 border-t hidden">
+            <span id="page-info" class="text-sm text-gray-600"></span>
+            <div class="flex gap-2">
+                <button onclick="prevPage()" id="btn-prev" class="px-3 py-1 border rounded text-sm disabled:opacity-50">Назад</button>
+                <button onclick="nextPage()" id="btn-next" class="px-3 py-1 border rounded text-sm disabled:opacity-50">Вперед</button>
+            </div>
+        </div>
+    </div>
+</div>
+
+<!-- Price Settings Modal -->
+<div id="price-modal" class="fixed inset-0 bg-black bg-opacity-50 hidden items-center justify-center z-50">
+    <div class="bg-white rounded-lg shadow-xl w-full max-w-md mx-4">
+        <div class="flex justify-between items-center p-4 border-b">
+            <h3 class="text-lg font-semibold">Настройка цены</h3>
+            <button onclick="closeModal()" class="text-gray-500 hover:text-gray-700">&times;</button>
+        </div>
+        <div class="p-4 space-y-4">
+            <div>
+                <label class="block text-sm font-medium text-gray-700 mb-1">Артикул</label>
+                <input type="text" id="modal-lot-name" readonly class="w-full px-3 py-2 border rounded bg-gray-100">
+            </div>
+
+            <div class="flex items-center mb-2">
+                <input type="checkbox" id="modal-meta-enabled" class="mr-2" onchange="toggleMetaPrice()">
+                <span class="text-sm font-medium text-gray-700">Мета артикул</span>
+            </div>
+            <div id="meta-price-fields" class="hidden mt-2">
+                <label class="block text-sm font-medium text-gray-700 mb-1">Источники цен</label>
+                <input type="text" id="modal-meta-prices" class="w-full px-3 py-2 border rounded" placeholder="Артикулы через запятую (например: CPU_AMD_9654, MB_INTEL_4.Sapphire_2S)">
+                <p class="text-xs text-gray-500 mt-1">Артикулы, чьи цены будут использоваться в расчете. Для автоматического подбора используйте * в конце (например: CPU_AMD_9654*)</p>
+            </div>
+
+            <div>
+                <label class="block text-sm font-medium text-gray-700 mb-1">Метод расчёта</label>
+                <select id="modal-method" class="w-full px-3 py-2 border rounded" onchange="onMethodChange()">
+                    <option value="median">Медиана</option>
+                    <option value="average">Среднее</option>
+                    <option value="manual">Установить цену вручную</option>
+                </select>
+            </div>
+            <div id="manual-price-field" class="hidden">
+                <label class="block text-sm font-medium text-gray-700 mb-1">Ручная цена (USD)</label>
+                <input type="number" id="modal-manual-price" step="0.01" class="w-full px-3 py-2 border rounded" placeholder="Цена USD">
+                <p class="text-xs text-gray-500 mt-1">Ручная цена сохраняется при пересчёте</p>
+            </div>
+
+            <div>
+                <label class="block text-sm font-medium text-gray-700 mb-1">Период расчёта</label>
+                <select id="modal-period" class="w-full px-3 py-2 border rounded">
+                    <option value="7">1 неделя</option>
+                    <option value="30">1 месяц</option>
+                    <option value="90">1 квартал</option>
+                    <option value="365">1 год</option>
+                    <option value="0">Всё время</option>
+                </select>
+            </div>
+
+            <div>
+                <label class="block text-sm font-medium text-gray-700 mb-1">Коэффициент корректировки (%)</label>
+                <input type="number" id="modal-coefficient" step="1" class="w-full px-3 py-2 border rounded" placeholder="0">
+                <p class="text-xs text-gray-500 mt-1">Например: 30 для +30%, -10 для -10%</p>
+            </div>
+
+            <div class="flex items-center pt-2 border-t">
+                <input type="checkbox" id="modal-hidden" class="mr-2">
+                <span class="text-sm font-medium text-gray-700">Скрыть из конфигуратора</span>
+            </div>
+
+            <div class="bg-gray-50 p-3 rounded space-y-2">
+                <div class="text-sm font-medium text-gray-700 mb-2">Расчёт цены</div>
+                <div class="grid grid-cols-2 gap-2 text-sm">
+                    <div class="text-gray-600">Последняя цена:</div>
+                    <div id="modal-last-price" class="font-medium text-right">—</div>
+                    <div class="text-gray-600">Медиана (всё время):</div>
+                    <div id="modal-median-all" class="font-medium text-right">—</div>
+                    <div class="text-gray-600">Текущая цена:</div>
+                    <div id="modal-current-price" class="font-medium text-right">—</div>
+                    <div class="text-gray-600 font-medium text-blue-600">Новая цена:</div>
+                    <div id="modal-new-price" class="font-bold text-right text-blue-600">—</div>
+                </div>
+                <div class="text-xs text-gray-500 pt-2 border-t">
+                    Кол-во котировок: <span id="modal-quote-count">—</span>
+                </div>
+            </div>
+        </div>
+        <div class="flex justify-end gap-2 p-4 border-t">
+            <button onclick="closeModal()" class="px-4 py-2 border rounded hover:bg-gray-50">Отмена</button>
+            <button onclick="savePrice()" class="px-4 py-2 bg-blue-600 text-white rounded hover:bg-blue-700">Сохранить</button>
+        </div>
+    </div>
+</div>
+
+<script>
+let currentTab = 'alerts';
+let currentPage = 1;
+let totalPages = 1;
+let perPage = 50;
+let searchTimeout = null;
+let currentSearch = '';
+let componentsCache = [];
+let sortField = 'popularity_score';
+let sortDir = 'desc';
+
+async function loadTab(tab) {
+    currentTab = tab;
+    currentPage = 1;
+    currentSearch = '';
+    document.getElementById('search-input').value = '';
+
+    document.getElementById('btn-alerts').className = tab === 'alerts' ? 'text-blue-600 font-medium' : 'text-gray-600';
+    document.getElementById('btn-components').className = tab === 'components' ? 'text-blue-600 font-medium' : 'text-gray-600';
+    document.getElementById('btn-all-configs').className = tab === 'all-configs' ? 'text-blue-600 font-medium' : 'text-gray-600 hidden';
+
+    // Show/hide elements based on tab
+    if (tab === 'components') {
+        document.getElementById('search-bar').className = 'mb-4';
+        document.getElementById('pagination').className = 'flex justify-between items-center mt-4 pt-4 border-t';
+        document.getElementById('btn-all-configs').className = 'text-gray-600 hidden'; // Hide this tab for components
+    } else if (tab === 'all-configs') {
+        document.getElementById('search-bar').className = 'mb-4 hidden'; // Hide search for all configs
+        document.getElementById('pagination').className = 'flex justify-between items-center mt-4 pt-4 border-t'; // Show pagination
+        document.getElementById('btn-all-configs').className = 'text-blue-600 font-medium'; // Show this tab for all configs
+    } else {
+        document.getElementById('search-bar').className = 'mb-4 hidden';
+        document.getElementById('pagination').className = 'hidden';
+        document.getElementById('btn-all-configs').className = 'text-gray-600 hidden';
+    }
+
+    await loadData();
+}
+
+async function loadData() {
+    const token = localStorage.getItem('token');
+    if (!token) {
+        window.location.href = '/login';
+        return;
+    }
+
+    document.getElementById('tab-content').innerHTML = '<div class="text-center py-8 text-gray-500">Загрузка...</div>';
+
+    try {
+        if (currentTab === 'alerts') {
+            const resp = await fetch('/admin/pricing/alerts?per_page=100', {
+                headers: {'Authorization': 'Bearer ' + token}
+            });
+            if (resp.status === 401) { logout(); return; }
+            if (resp.status === 403) { window.location.href = '/'; return; }
+            const data = await resp.json();
+            renderAlerts(data.alerts || []);
+        } else if (currentTab === 'all-configs') {
+            // Load all configurations for all users
+            let url = '/api/configs?page=' + currentPage + '&per_page=' + perPage;
+            if (currentSearch) {
+                url += '&search=' + encodeURIComponent(currentSearch);
+            }
+            const resp = await fetch(url, {
+                headers: {'Authorization': 'Bearer ' + token}
+            });
+            if (resp.status === 401) { logout(); return; }
+            if (resp.status === 403) { window.location.href = '/'; return; }
+            const data = await resp.json();
+            totalPages = Math.ceil(data.total / perPage);
+            renderAllConfigs(data.configurations || []);
+            updatePagination(data.total);
+        } else {
+            let url = '/admin/pricing/components?page=' + currentPage + '&per_page=' + perPage;
+            if (currentSearch) {
+                url += '&search=' + encodeURIComponent(currentSearch);
+            }
+            if (sortField) {
+                url += '&sort=' + encodeURIComponent(sortField);
+            }
+            if (sortDir) {
+                url += '&dir=' + encodeURIComponent(sortDir);
+            }
+            const resp = await fetch(url, {
+                headers: {'Authorization': 'Bearer ' + token}
+            });
+            if (resp.status === 401) { logout(); return; }
+            const data = await resp.json();
+            totalPages = Math.ceil(data.total / perPage);
+            componentsCache = data.components || [];
+            renderComponents(componentsCache, data.total);
+            updatePagination(data.total);
+        }
+    } catch(e) {
+        document.getElementById('tab-content').innerHTML = '<div class="text-center py-8 text-red-600">Ошибка загрузки</div>';
+    }
+}
+
+function debounceSearch() {
+    clearTimeout(searchTimeout);
+    searchTimeout = setTimeout(() => {
+        currentSearch = document.getElementById('search-input').value;
+        currentPage = 1;
+        loadData();
+    }, 300);
+}
+
+function prevPage() {
+    if (currentPage > 1) {
+        currentPage--;
+        loadData();
+    }
+}
+
+function nextPage() {
+    if (currentPage < totalPages) {
+        currentPage++;
+        loadData();
+    }
+}
+
+function updatePagination(total) {
+    document.getElementById('page-info').textContent =
+        'Страница ' + currentPage + ' из ' + totalPages + ' (всего: ' + total + ')';
+    document.getElementById('btn-prev').disabled = currentPage <= 1;
+    document.getElementById('btn-next').disabled = currentPage >= totalPages;
+}
+
+function renderAlerts(alerts) {
+    if (alerts.length === 0) {
+        document.getElementById('tab-content').innerHTML = '<div class="text-center py-8 text-green-600">Нет активных алертов</div>';
+        return;
+    }
+
+    let html = '<div class="space-y-2">';
+    alerts.forEach(a => {
+        const colors = {critical: 'bg-red-100', high: 'bg-orange-100', medium: 'bg-yellow-100', low: 'bg-blue-100'};
+        html += '<div class="' + (colors[a.severity] || 'bg-gray-100') + ' p-3 rounded">';
+        html += '<div class="flex justify-between"><span class="font-medium">' + escapeHtml(a.lot_name) + '</span>';
+        html += '<span class="text-xs uppercase">' + a.severity + '</span></div>';
+        html += '<p class="text-sm text-gray-600">' + escapeHtml(a.message) + '</p></div>';
+    });
+    html += '</div>';
+    document.getElementById('tab-content').innerHTML = html;
+}
+
+function renderComponents(components, total) {
+    if (components.length === 0) {
+        document.getElementById('tab-content').innerHTML = '<div class="text-center py-8 text-gray-500">Нет данных</div>';
+        return;
+    }
+
+    let html = '<div class="overflow-x-auto"><table class="w-full"><thead class="bg-gray-50"><tr>';
+    html += '<th class="px-3 py-2 text-left text-xs font-medium text-gray-500 uppercase">Артикул</th>';
+    html += '<th class="px-3 py-2 text-left text-xs font-medium text-gray-500 uppercase">Категория</th>';
+    html += '<th class="px-3 py-2 text-left text-xs font-medium text-gray-500 uppercase">Описание</th>';
+    html += '<th class="px-3 py-2 text-right text-xs font-medium text-gray-500 uppercase">Популярность</th>';
+    html += '<th class="px-3 py-2 text-right text-xs font-medium text-gray-500 uppercase">Кол-во котировок</th>';
+    html += '<th class="px-3 py-2 text-right text-xs font-medium text-gray-500 uppercase">Цена</th>';
+    html += '<th class="px-3 py-2 text-left text-xs font-medium text-gray-500 uppercase">Настройки</th>';
+    html += '</tr></thead><tbody class="divide-y">';
+
+    components.forEach((c, idx) => {
+        const price = c.current_price ? '$' + parseFloat(c.current_price).toLocaleString('en-US', {minimumFractionDigits: 2}) : '—';
+        const category = c.category ? c.category.code : '—';
+        const desc = c.lot && c.lot.lot_description ? c.lot.lot_description : '—';
+        const quoteCount = c.quote_count || 0;
+        const popularity = c.popularity_score ? c.popularity_score.toFixed(2) : '0.00';
+        const isHidden = c.is_hidden || quoteCount === 0;
+        const usedInMeta = c.used_in_meta && c.used_in_meta.length > 0;
+
+        // Determine status indicator (colored dot)
+        let dotColor, dotTitle;
+        if (usedInMeta) {
+            // Used as source for meta-articles - cyan
+            dotColor = 'bg-cyan-500';
+            dotTitle = 'Используется в мета: ' + c.used_in_meta.join(', ');
+        } else if (!isHidden) {
+            // Available in configurator - green
+            dotColor = 'bg-green-500';
+            dotTitle = 'Доступен в конфигураторе';
+        } else {
+            // Hidden and not used - gray
+            dotColor = 'bg-gray-400';
+            dotTitle = 'Скрыт из конфигуратора';
+        }
+
+        // Build settings summary
+        let settingsHtml = '';
+
+        if (isHidden) {
+            settingsHtml = '<span class="text-red-600 font-medium">СКРЫТ</span>';
+        } else {
+            let settings = [];
+            const method = c.price_method || 'median';
+            const hasManualPrice = c.manual_price && c.manual_price > 0;
+            const hasMeta = c.meta_prices && c.meta_prices.trim() !== '';
+
+            // Method indicator
+            if (hasManualPrice) {
+                settings.push('<span class="text-orange-600 font-medium">РУЧН</span>');
+            } else if (method === 'average') {
+                settings.push('Сред');
+            } else {
+                settings.push('Мед');
+            }
+
+            // Period (only if not manual price)
+            if (!hasManualPrice) {
+                const period = c.price_period_days !== undefined && c.price_period_days !== null ? c.price_period_days : 90;
+                if (period === 7) settings.push('1н');
+                else if (period === 30) settings.push('1м');
+                else if (period === 90) settings.push('3м');
+                else if (period === 365) settings.push('1г');
+                else if (period === 0) settings.push('все');
+                else settings.push(period + 'д');
+            }
+
+            // Coefficient
+            if (c.price_coefficient && c.price_coefficient !== 0) {
+                settings.push((c.price_coefficient > 0 ? '+' : '') + c.price_coefficient + '%');
+            }
+
+            // Meta article indicator
+            if (hasMeta) {
+                settings.push('<span class="text-purple-600 font-medium">МЕТА</span>');
+            }
+
+            settingsHtml = settings.join(' | ');
+        }
+
+        html += '<tr class="hover:bg-gray-50 cursor-pointer" onclick="openModal(' + idx + ')">';
+        html += '<td class="px-3 py-2 text-sm font-mono"><span class="inline-flex items-center gap-2"><span class="w-2.5 h-2.5 rounded-full ' + dotColor + ' flex-shrink-0" title="' + escapeHtml(dotTitle) + '"></span>' + escapeHtml(c.lot_name) + '</span></td>';
+        html += '<td class="px-3 py-2 text-sm">' + escapeHtml(category) + '</td>';
+        html += '<td class="px-3 py-2 text-sm text-gray-500 max-w-xs truncate">' + escapeHtml(desc) + '</td>';
+        html += '<td class="px-3 py-2 text-sm text-right">' + popularity + '</td>';
+        html += '<td class="px-3 py-2 text-sm text-right">' + quoteCount + '</td>';
+        html += '<td class="px-3 py-2 text-sm text-right font-medium">' + price + '</td>';
+        html += '<td class="px-3 py-2 text-sm"><span class="text-xs bg-gray-100 px-2 py-1 rounded">' + settingsHtml + '</span></td>';
+        html += '</tr>';
+    });
+
+    html += '</tbody></table></div>';
+    document.getElementById('tab-content').innerHTML = html;
+}
+
+function escapeHtml(text) {
+    if (!text) return '';
+    const div = document.createElement('div');
+    div.textContent = text;
+    return div.innerHTML;
+}
+
+// Modal functions
+function openModal(idx) {
+    const c = componentsCache[idx];
+    if (!c) return;
+
+    document.getElementById('modal-lot-name').value = c.lot_name;
+    document.getElementById('modal-coefficient').value = c.price_coefficient || 0;
+
+    const hasManual = c.manual_price && c.manual_price > 0;
+    if (hasManual) {
+        document.getElementById('modal-method').value = 'manual';
+        document.getElementById('modal-manual-price').value = c.manual_price;
+        document.getElementById('manual-price-field').classList.remove('hidden');
+    } else {
+        document.getElementById('modal-method').value = c.price_method || 'median';
+        document.getElementById('modal-manual-price').value = '';
+        document.getElementById('manual-price-field').classList.add('hidden');
+    }
+    document.getElementById('modal-period').value = String(c.price_period_days !== undefined && c.price_period_days !== null ? c.price_period_days : 90);
+
+    // Load meta prices settings
+    const hasMeta = c.meta_prices && c.meta_prices.trim() !== '';
+    document.getElementById('modal-meta-enabled').checked = hasMeta;
+    document.getElementById('modal-meta-prices').value = c.meta_prices || '';
+    if (hasMeta) {
+        document.getElementById('meta-price-fields').classList.remove('hidden');
+    } else {
+        document.getElementById('meta-price-fields').classList.add('hidden');
+    }
+
+    // Load hidden flag
+    const quoteCount = c.quote_count || 0;
+    const hiddenCheckbox = document.getElementById('modal-hidden');
+    if (quoteCount === 0) {
+        // Если нет котировок - чекбокс установлен и заблокирован
+        hiddenCheckbox.checked = true;
+        hiddenCheckbox.disabled = true;
+    } else {
+        hiddenCheckbox.checked = c.is_hidden || false;
+        hiddenCheckbox.disabled = false;
+    }
+
+    // Reset price displays while loading
+    document.getElementById('modal-last-price').textContent = '...';
+    document.getElementById('modal-median-all').textContent = '...';
+    document.getElementById('modal-current-price').textContent = '...';
+    document.getElementById('modal-new-price').textContent = '...';
+    document.getElementById('modal-quote-count').textContent = '...';
+
+    document.getElementById('price-modal').classList.remove('hidden');
+    document.getElementById('price-modal').classList.add('flex');
+
+    // Fetch price preview
+    fetchPreview();
+}
+
+function onMethodChange() {
+    const method = document.getElementById('modal-method').value;
+    const manualField = document.getElementById('manual-price-field');
+    if (method === 'manual') {
+        manualField.classList.remove('hidden');
+        // При выборе "Установить цену вручную" снимаем галочку "Мета артикул"
+        document.getElementById('modal-meta-enabled').checked = false;
+        document.getElementById('meta-price-fields').classList.add('hidden');
+    } else {
+        manualField.classList.add('hidden');
+    }
+    fetchPreview();
+}
+
+async function fetchPreview() {
+    const token = localStorage.getItem('token');
+    if (!token) return;
+
+    const lotName = document.getElementById('modal-lot-name').value;
+    const method = document.getElementById('modal-method').value;
+    const periodDays = parseInt(document.getElementById('modal-period').value) || 0;
+    const coefficient = parseFloat(document.getElementById('modal-coefficient').value) || 0;
+    const metaEnabled = document.getElementById('modal-meta-enabled').checked;
+    let metaPrices = '';
+    let metaMethod = '';
+    let metaPeriod = 0;
+
+    if (metaEnabled) {
+        metaPrices = document.getElementById('modal-meta-prices').value.trim();
+        metaMethod = method;
+        metaPeriod = periodDays;
+    }
+
+    try {
+        const resp = await fetch('/admin/pricing/preview', {
+            method: 'POST',
+            headers: {
+                'Authorization': 'Bearer ' + token,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                lot_name: lotName,
+                method: method,
+                period_days: periodDays,
+                coefficient: coefficient,
+                meta_enabled: metaEnabled,
+                meta_prices: metaPrices,
+                meta_method: metaMethod,
+                meta_period: metaPeriod
+            })
+        });
+
+        if (resp.status === 401) { logout(); return; }
+
+        if (resp.ok) {
+            const data = await resp.json();
+
+            // Update last price with date
+            if (data.last_price) {
+                let lastPriceText = '$' + parseFloat(data.last_price).toFixed(2);
+                if (data.last_price_date) {
+                    const date = new Date(data.last_price_date);
+                    lastPriceText += ' (' + date.toLocaleDateString('ru-RU') + ')';
+                }
+                document.getElementById('modal-last-price').textContent = lastPriceText;
+            } else {
+                document.getElementById('modal-last-price').textContent = '—';
+            }
+
+            // Update median all time
+            document.getElementById('modal-median-all').textContent =
+                data.median_all_time ? '$' + parseFloat(data.median_all_time).toFixed(2) : '—';
+
+            // Update current price
+            document.getElementById('modal-current-price').textContent =
+                data.current_price ? '$' + parseFloat(data.current_price).toFixed(2) : '—';
+
+            // Update new calculated price
+            document.getElementById('modal-new-price').textContent =
+                data.new_price ? '$' + parseFloat(data.new_price).toFixed(2) : '—';
+
+            // Update quote count
+            document.getElementById('modal-quote-count').textContent = data.quote_count || 0;
+        }
+    } catch(e) {
+        console.error('Preview fetch error:', e);
+        document.getElementById('modal-last-price').textContent = '—';
+        document.getElementById('modal-median-all').textContent = '—';
+        document.getElementById('modal-current-price').textContent = '—';
+        document.getElementById('modal-new-price').textContent = '—';
+    }
+}
+
+function closeModal() {
+    document.getElementById('price-modal').classList.add('hidden');
+    document.getElementById('price-modal').classList.remove('flex');
+}
+
+function toggleMetaPrice() {
+    const enabled = document.getElementById('modal-meta-enabled').checked;
+    const fields = document.getElementById('meta-price-fields');
+    fields.classList.toggle('hidden', !enabled);
+
+    if (enabled) {
+        // When enabling meta price, reset method to median if it was manual
+        const method = document.getElementById('modal-method').value;
+        if (method === 'manual') {
+            document.getElementById('modal-method').value = 'median';
+            document.getElementById('manual-price-field').classList.add('hidden');
+            document.getElementById('modal-manual-price').value = '';
+        }
+        // Auto-fill with wildcard pattern
+        const lotName = document.getElementById('modal-lot-name').value;
+        if (lotName) {
+            autoFillMetaPrices(lotName);
+        }
+    }
+    fetchPreview();
+}
+
+// Debounce helper for preview updates
+let previewTimeout = null;
+function debounceFetchPreview() {
+    clearTimeout(previewTimeout);
+    previewTimeout = setTimeout(fetchPreview, 300);
+}
+
+async function savePrice() {
+    const token = localStorage.getItem('token');
+    if (!token) {
+        window.location.href = '/login';
+        return;
+    }
+
+    const lotName = document.getElementById('modal-lot-name').value;
+    const method = document.getElementById('modal-method').value;
+    const periodDaysStr = document.getElementById('modal-period').value;
+    const periodDays = periodDaysStr !== '' ? parseInt(periodDaysStr) : 90;
+    const coefficient = parseFloat(document.getElementById('modal-coefficient').value) || 0;
+    const manualEnabled = method === 'manual';
+    const manualPrice = manualEnabled ? parseFloat(document.getElementById('modal-manual-price').value) : null;
+    const metaEnabled = document.getElementById('modal-meta-enabled').checked;
+    const hiddenCheckbox = document.getElementById('modal-hidden');
+    // Если чекбокс заблокирован (нет котировок), всегда true
+    const isHidden = hiddenCheckbox.disabled ? true : hiddenCheckbox.checked;
+
+    let metaPrices = '';
+    let metaMethod = '';
+    let metaPeriod = 0;
+
+    if (metaEnabled) {
+        metaPrices = document.getElementById('modal-meta-prices').value.trim();
+        metaMethod = manualEnabled ? 'median' : method;
+        metaPeriod = periodDays;
+    }
+
+    const body = {
+        lot_name: lotName,
+        method: manualEnabled ? 'median' : method,
+        period_days: periodDays,
+        coefficient: coefficient,
+        clear_manual: !manualEnabled,
+        meta_enabled: metaEnabled,
+        meta_prices: metaPrices,
+        meta_method: metaMethod,
+        meta_period: metaPeriod,
+        is_hidden: isHidden
+    };
+
+    if (manualEnabled && manualPrice > 0) {
+        body.manual_price = manualPrice;
+    }
+
+    try {
+        const resp = await fetch('/admin/pricing/update', {
+            method: 'POST',
+            headers: {
+                'Authorization': 'Bearer ' + token,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify(body)
+        });
+
+        if (resp.status === 401) { logout(); return; }
+
+        if (resp.ok) {
+            closeModal();
+            loadData();
+        } else {
+            const data = await resp.json();
+            alert('Ошибка: ' + (data.error || 'Неизвестная ошибка'));
+        }
+    } catch(e) {
+        alert('Ошибка соединения');
+    }
+}
+
+// Function to process meta prices and handle regex patterns
+function processMetaPrices(metaPrices, originalLotName) {
+    if (!metaPrices) return [];
+
+    // Split by comma and clean up
+    let lots = metaPrices.split(',').map(lot => lot.trim()).filter(lot => lot.length > 0);
+
+    // Handle wildcard patterns (ending with *)
+    const processedLots = [];
+    const originalPrefix = originalLotName.split('_')[0] + '_'; // Get first part like "CPU_" from "CPU_AMD_9654"
+
+    lots.forEach(lot => {
+        if (lot.endsWith('*')) {
+            // Wildcard pattern - find all components that start with the prefix
+            const prefix = lot.slice(0, -1); // Remove the *
+            // In real implementation, this would be handled by backend
+            // For now, we'll just add the prefix as is to indicate it's a pattern
+            processedLots.push(prefix + '*');
+        } else {
+            // Regular component name
+            processedLots.push(lot);
+        }
+    });
+
+    // Remove duplicates and original lot name
+    const uniqueLots = [...new Set(processedLots)];
+    return uniqueLots.filter(lot => lot !== originalLotName);
+}
+
+function recalculateAll() {
+    const token = localStorage.getItem('token');
+    if (!token) {
+        window.location.href = '/login';
+        return;
+    }
+
+    const btn = document.getElementById('btn-recalc');
+    const progressContainer = document.getElementById('progress-container');
+    const progressBar = document.getElementById('progress-bar');
+    const progressText = document.getElementById('progress-text');
+    const progressPercent = document.getElementById('progress-percent');
+    const progressStats = document.getElementById('progress-stats');
+
+    // Show progress bar IMMEDIATELY
+    btn.disabled = true;
+    btn.textContent = 'Пересчёт...';
+    progressContainer.style.display = 'block';
+    progressBar.style.width = '0%';
+    progressBar.className = 'bg-blue-600 h-4 rounded-full transition-all duration-300';
+    progressText.textContent = 'Запуск пересчёта...';
+    progressPercent.textContent = '0%';
+    progressStats.textContent = 'Подготовка...';
+
+    // Use fetch with streaming for SSE
+    fetch('/admin/pricing/recalculate-all', {
+        method: 'POST',
+        headers: {'Authorization': 'Bearer ' + token}
+    }).then(response => {
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+
+        function read() {
+            reader.read().then(({done, value}) => {
+                if (done) {
+                    btn.disabled = false;
+                    btn.textContent = 'Пересчитать цены';
+                    progressText.textContent = 'Готово!';
+                    progressBar.className = 'bg-green-600 h-4 rounded-full';
+                    setTimeout(() => {
+                        progressContainer.style.display = 'none';
+                        if (currentTab === 'components') {
+                            loadData();
+                        }
+                    }, 2000);
+                    return;
+                }
+
+                const text = decoder.decode(value);
+                const lines = text.split('\n');
+
+                lines.forEach(line => {
+                    if (line.startsWith('data:')) {
+                        try {
+                            const data = JSON.parse(line.substring(5).trim());
+                            const percent = data.total > 0 ? Math.round((data.current / data.total) * 100) : 0;
+
+                            progressBar.style.width = percent + '%';
+                            progressPercent.textContent = percent + '%';
+
+                            if (data.status === 'completed') {
+                                progressText.textContent = 'Пересчёт завершён!';
+                                progressBar.className = 'bg-green-600 h-4 rounded-full';
+                            } else {
+                                progressText.textContent = data.lot_name ? 'Обработка: ' + data.lot_name : 'Обработка компонентов...';
+                            }
+
+                            progressStats.textContent = 'Обновлено: ' + (data.updated || 0) + ' | Без изменений: ' + (data.unchanged || 0) + ' | Ручные: ' + (data.manual || 0) + ' | Нет данных: ' + (data.skipped || 0) + ' | Ошибок: ' + (data.errors || 0);
+                        } catch(e) {
+                            console.log('Parse error:', e, line);
+                        }
+                    }
+                });
+
+                read();
+            });
+        }
+
+        read();
+    }).catch(e => {
+        console.error('Fetch error:', e);
+        alert('Ошибка соединения');
+        btn.disabled = false;
+        btn.textContent = 'Пересчитать цены';
+        progressContainer.style.display = 'none';
+    });
+}
+
+// Close modal on click outside
+document.getElementById('price-modal').addEventListener('click', function(e) {
+    if (e.target === this) {
+        closeModal();
+    }
+});
+
+function changeSort() {
+    sortField = document.getElementById('sort-field').value;
+    currentPage = 1;
+    loadData();
+}
+
+function toggleSortDir() {
+    sortDir = sortDir === 'asc' ? 'desc' : 'asc';
+    document.getElementById('sort-dir-btn').textContent = sortDir === 'asc' ? '↑' : '↓';
+    currentPage = 1;
+    loadData();
+}
+
+// Render all configurations for admin view
+function renderAllConfigs(configs) {
+    if (configs.length === 0) {
+        document.getElementById('tab-content').innerHTML = '<div class="text-center py-8 text-gray-500">Нет конфигураций</div>';
+        return;
+    }
+
+    let html = '<div class="overflow-x-auto"><table class="w-full"><thead class="bg-gray-50"><tr>';
+    html += '<th class="px-3 py-2 text-left text-xs font-medium text-gray-500 uppercase">Дата</th>';
+    html += '<th class="px-3 py-2 text-left text-xs font-medium text-gray-500 uppercase">Название</th>';
+    html += '<th class="px-3 py-2 text-left text-xs font-medium text-gray-500 uppercase">Пользователь</th>';
+    html += '<th class="px-3 py-2 text-left text-xs font-medium text-gray-500 uppercase">Серверы</th>';
+    html += '<th class="px-3 py-2 text-right text-xs font-medium text-gray-500 uppercase">Сумма</th>';
+    html += '<th class="px-3 py-2 text-right text-xs font-medium text-gray-500 uppercase">Действия</th>';
+    html += '</tr></thead><tbody class="divide-y">';
+
+    configs.forEach(c => {
+        const date = new Date(c.created_at).toLocaleDateString('ru-RU');
+        const total = c.total_price ? '$' + c.total_price.toLocaleString('en-US', {minimumFractionDigits: 2}) : '—';
+        const serverCount = c.server_count ? c.server_count : 1;
+        const username = c.user ? c.user.username : '—';
+
+        html += '<tr class="hover:bg-gray-50">';
+        html += '<td class="px-3 py-2 text-sm text-gray-500">' + date + '</td>';
+        html += '<td class="px-3 py-2 text-sm font-medium">' + escapeHtml(c.name) + '</td>';
+        html += '<td class="px-3 py-2 text-sm text-gray-500">' + username + '</td>';
+        html += '<td class="px-3 py-2 text-sm text-gray-500">' + serverCount + '</td>';
+        html += '<td class="px-3 py-2 text-sm text-right">' + total + '</td>';
+        html += '<td class="px-3 py-2 text-sm text-right space-x-2">';
+        html += '<button onclick="openCloneModal(\'' + c.uuid + '\', \'' + escapeHtml(c.name).replace(/'/g, "\\'") + '\')" class="text-green-600 hover:text-green-800" title="Копировать">';
+        html += '<svg class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">';
+        html += '<path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M8 16H6a2 2 0 01-2-2V6a2 2 0 012-2h8a2 2 0 012 2v2m-6 12h8a2 2 0 002-2v-8a2 2 0 00-2-2h-8a2 2 0 00-2 2v8a2 2 0 002 2z"></path>';
+        html += '</svg>';
+        html += '</button>';
+        html += '<button onclick="openRenameModal(\'' + c.uuid + '\', \'' + escapeHtml(c.name).replace(/'/g, "\\'") + '\')" class="text-blue-600 hover:text-blue-800" title="Переименовать">';
+        html += '<svg class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">';
+        html += '<path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M11 5H6a2 2 0 00-2 2v11a2 2 0 002 2h11a2 2 0 002-2v-5m-1.414-9.414a2 2 0 112.828 2.828L11.828 15H9v-2.828l8.586-8.586z"></path>';
+        html += '</svg>';
+        html += '</button>';
+        html += '<button onclick="deleteConfig(\'' + c.uuid + '\')" class="text-red-600 hover:text-red-800" title="Удалить">';
+        html += '<svg class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">';
+        html += '<path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M19 7l-.867 12.142A2 2 0 0116.138 21H7.862a2 2 0 01-1.995-1.858L5 7m5 4v6m4-6v6m1-10V4a1 1 0 00-1-1h-4a1 1 0 00-1 1v3M4 7h16"></path>';
+        html += '</svg>';
+        html += '</button>';
+        html += '</td></tr>';
+    });
+
+    html += '</tbody></table></div>';
+    document.getElementById('tab-content').innerHTML = html;
+}
+
+document.addEventListener('DOMContentLoaded', () => {
+    loadTab('alerts');
+
+    // Add event listeners for preview updates
+    document.getElementById('modal-period').addEventListener('change', fetchPreview);
+    document.getElementById('modal-coefficient').addEventListener('input', debounceFetchPreview);
+    document.getElementById('modal-manual-price').addEventListener('input', debounceFetchPreview);
+    document.getElementById('modal-meta-prices').addEventListener('input', debounceFetchPreview);
+});
+</script>
+{{end}}
+
+{{template "base" .}}
--- a/web/templates/base.html
+++ b/web/templates/base.html
@@ -0,0 +1,113 @@
+{{define "base"}}
+<!DOCTYPE html>
+<html lang="ru">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>{{template "title" .}}</title>
+    <script src="https://cdn.tailwindcss.com"></script>
+    <script src="https://unpkg.com/htmx.org@1.9.10"></script>
+    <style>
+        .htmx-request { opacity: 0.5; }
+        .line-clamp-2 { display: -webkit-box; -webkit-line-clamp: 2; -webkit-box-orient: vertical; overflow: hidden; }
+    </style>
+</head>
+<body class="bg-gray-100 min-h-screen">
+    <nav class="bg-white shadow-sm sticky top-0 z-40">
+        <div class="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8">
+            <div class="flex justify-between h-14">
+                <div class="flex items-center space-x-8">
+                    <a href="/" class="text-xl font-bold text-blue-600">QuoteForge</a>
+                    <div class="hidden md:flex space-x-4">
+                        <a href="/configs" class="text-gray-600 hover:text-gray-900 px-3 py-2 text-sm" id="nav-configs" style="display:none;">Мои конфигурации</a>
+                        <a href="/admin/pricing" class="text-gray-600 hover:text-gray-900 px-3 py-2 text-sm" id="nav-admin" style="display:none;">Цены</a>
+                    </div>
+                </div>
+                <div class="flex items-center">
+                    <div id="user-logged-out">
+                        <a href="/login" class="text-blue-600 hover:text-blue-800 text-sm">Войти</a>
+                    </div>
+                    <div id="user-logged-in" class="hidden">
+                        <span id="user-name" class="text-sm text-gray-700 mr-3"></span>
+                        <button onclick="logout()" class="text-red-600 hover:text-red-800 text-sm">Выйти</button>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </nav>
+
+    <main class="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8 py-6 pb-12">
+        {{template "content" .}}
+    </main>
+
+    <div id="toast" class="fixed bottom-4 right-4 z-50"></div>
+
+    <footer class="fixed bottom-0 left-0 right-0 bg-gray-800 text-gray-300 text-xs py-1 px-4">
+        <div class="max-w-7xl mx-auto flex justify-between">
+            <span id="db-status">БД: проверка...</span>
+            <span id="db-counts"></span>
+        </div>
+    </footer>
+
+    <script>
+        function initAuth() {
+            const token = localStorage.getItem('token');
+            const user = localStorage.getItem('user');
+
+            if (token && user) {
+                try {
+                    const userData = JSON.parse(user);
+                    document.getElementById('user-logged-out').classList.add('hidden');
+                    document.getElementById('user-logged-in').classList.remove('hidden');
+                    document.getElementById('user-name').textContent = userData.username;
+                    document.getElementById('nav-configs').style.display = 'block';
+                    if (userData.role === 'admin' || userData.role === 'pricing_admin') {
+                        document.getElementById('nav-admin').style.display = 'block';
+                    }
+                } catch(e) {
+                    logout();
+                }
+            }
+        }
+
+        function logout() {
+            localStorage.removeItem('token');
+            localStorage.removeItem('refresh_token');
+            localStorage.removeItem('user');
+            window.location.href = '/';
+        }
+
+        function showToast(msg, type) {
+            const colors = { success: 'bg-green-500', error: 'bg-red-500', info: 'bg-blue-500' };
+            const el = document.getElementById('toast');
+            el.innerHTML = '<div class="' + (colors[type] || colors.info) + ' text-white px-4 py-2 rounded shadow">' + msg + '</div>';
+            setTimeout(() => el.innerHTML = '', 3000);
+        }
+
+        async function checkDbStatus() {
+            try {
+                const resp = await fetch('/api/db-status');
+                const data = await resp.json();
+                const statusEl = document.getElementById('db-status');
+                const countsEl = document.getElementById('db-counts');
+
+                if (data.connected) {
+                    statusEl.innerHTML = '<span class="text-green-400">БД: подключено</span>';
+                } else {
+                    statusEl.innerHTML = '<span class="text-red-400">БД: ошибка - ' + data.error + '</span>';
+                }
+
+                countsEl.textContent = 'lot: ' + data.lot_count + ' | lot_log: ' + data.lot_log_count + ' | metadata: ' + data.metadata_count;
+            } catch(e) {
+                document.getElementById('db-status').innerHTML = '<span class="text-red-400">БД: нет связи</span>';
+            }
+        }
+
+        document.addEventListener('DOMContentLoaded', function() {
+            initAuth();
+            checkDbStatus();
+        });
+    </script>
+</body>
+</html>
+{{end}}
--- a/web/templates/components_list.html
+++ b/web/templates/components_list.html
@@ -0,0 +1,52 @@
+{{define "components_list.html"}}
+{{if .Components}}
+<div class="bg-white rounded-lg shadow overflow-hidden">
+    <table class="w-full">
+        <thead class="bg-gray-50">
+            <tr>
+                <th class="px-4 py-3 text-left text-xs font-medium text-gray-500 uppercase">Артикул</th>
+                <th class="px-4 py-3 text-left text-xs font-medium text-gray-500 uppercase">Категория</th>
+                <th class="px-4 py-3 text-left text-xs font-medium text-gray-500 uppercase">Описание</th>
+                <th class="px-4 py-3 text-right text-xs font-medium text-gray-500 uppercase">Цена</th>
+                <th class="px-4 py-3 text-center text-xs font-medium text-gray-500 uppercase w-24"></th>
+            </tr>
+        </thead>
+        <tbody class="divide-y">
+            {{range .Components}}
+            <tr class="hover:bg-gray-50">
+                <td class="px-4 py-3 text-sm font-medium font-mono">{{.LotName}}</td>
+                <td class="px-4 py-3 text-sm">
+                    <span class="px-2 py-1 text-xs rounded bg-gray-100">{{.Category}}</span>
+                </td>
+                <td class="px-4 py-3 text-sm text-gray-500 max-w-md truncate">{{.Description}}</td>
+                <td class="px-4 py-3 text-sm text-right font-medium">
+                    {{if .CurrentPrice}}
+                        ${{printf "%.2f" (deref .CurrentPrice)}}
+                    {{else}}
+                        <span class="text-gray-400">—</span>
+                    {{end}}
+                </td>
+                <td class="px-4 py-3 text-center">
+                    {{if .CurrentPrice}}
+                    <button onclick="addToCart('{{jsesc .LotName}}', {{deref .CurrentPrice}}, '{{jsesc .Description}}')"
+                            class="px-3 py-1 bg-blue-600 text-white text-xs rounded hover:bg-blue-700">
+                        + Добавить
+                    </button>
+                    {{else}}
+                    <span class="text-gray-400 text-xs">Нет цены</span>
+                    {{end}}
+                </td>
+            </tr>
+            {{end}}
+        </tbody>
+    </table>
+</div>
+
+<p class="text-center text-sm text-gray-500 mt-4">Найдено: {{.Total}}</p>
+
+{{else}}
+<div class="bg-white rounded-lg shadow p-8 text-center text-gray-500">
+    Компоненты не найдены
+</div>
+{{end}}
+{{end}}
--- a/web/templates/configs.html
+++ b/web/templates/configs.html
@@ -0,0 +1,491 @@
+{{define "title"}}Мои конфигурации - QuoteForge{{end}}
+
+{{define "content"}}
+<div class="space-y-4">
+    <h1 class="text-2xl font-bold">Мои конфигурации</h1>
+
+    <div class="mt-4">
+        <button onclick="openCreateModal()" class="w-full py-3 bg-blue-600 text-white rounded-lg hover:bg-blue-700 font-medium">
+            + Создать новую конфигурацию
+        </button>
+    </div>
+
+    <div id="configs-list">
+        <div class="text-center py-8 text-gray-500">Загрузка...</div>
+    </div>
+
+    <!-- Pagination -->
+    <div id="pagination" class="flex justify-between items-center mt-4 pt-4 border-t hidden">
+        <span id="page-info" class="text-sm text-gray-600"></span>
+        <div class="flex gap-2">
+            <button onclick="prevPage()" id="btn-prev" class="px-3 py-1 border rounded text-sm disabled:opacity-50">Назад</button>
+            <button onclick="nextPage()" id="btn-next" class="px-3 py-1 border rounded text-sm disabled:opacity-50">Вперед</button>
+        </div>
+    </div>
+</div>
+
+<!-- Modal for creating new configuration -->
+<div id="create-modal" class="fixed inset-0 bg-black bg-opacity-50 hidden items-center justify-center z-50">
+    <div class="bg-white rounded-lg shadow-xl w-full max-w-md mx-4 p-6">
+        <h2 class="text-xl font-semibold mb-4">Новая конфигурация</h2>
+
+        <div class="space-y-4">
+            <div>
+                <label class="block text-sm font-medium text-gray-700 mb-1">Номер Opportunity</label>
+                <input type="text" id="opportunity-number" placeholder="Например: OPP-2024-001"
+                       class="w-full px-3 py-2 border rounded focus:ring-2 focus:ring-blue-500 focus:border-blue-500">
+            </div>
+        </div>
+
+        <div class="flex justify-end space-x-3 mt-6">
+            <button onclick="closeCreateModal()" class="px-4 py-2 text-gray-600 hover:text-gray-800">
+                Отмена
+            </button>
+            <button onclick="createConfig()" class="px-4 py-2 bg-blue-600 text-white rounded hover:bg-blue-700">
+                Создать
+            </button>
+        </div>
+    </div>
+</div>
+
+<!-- Modal for renaming configuration -->
+<div id="rename-modal" class="fixed inset-0 bg-black bg-opacity-50 hidden items-center justify-center z-50">
+    <div class="bg-white rounded-lg shadow-xl w-full max-w-md mx-4 p-6">
+        <h2 class="text-xl font-semibold mb-4">Переименовать конфигурацию</h2>
+
+        <div class="space-y-4">
+            <div>
+                <label class="block text-sm font-medium text-gray-700 mb-1">Новое название</label>
+                <input type="text" id="rename-input" placeholder="Введите новое название"
+                       class="w-full px-3 py-2 border rounded focus:ring-2 focus:ring-blue-500 focus:border-blue-500">
+                <input type="hidden" id="rename-uuid">
+            </div>
+        </div>
+
+        <div class="flex justify-end space-x-3 mt-6">
+            <button onclick="closeRenameModal()" class="px-4 py-2 text-gray-600 hover:text-gray-800">
+                Отмена
+            </button>
+            <button onclick="renameConfig()" class="px-4 py-2 bg-blue-600 text-white rounded hover:bg-blue-700">
+                Сохранить
+            </button>
+        </div>
+    </div>
+</div>
+
+<!-- Modal for cloning configuration -->
+<div id="clone-modal" class="fixed inset-0 bg-black bg-opacity-50 hidden items-center justify-center z-50">
+    <div class="bg-white rounded-lg shadow-xl w-full max-w-md mx-4 p-6">
+        <h2 class="text-xl font-semibold mb-4">Копировать конфигурацию</h2>
+
+        <div class="space-y-4">
+            <div>
+                <label class="block text-sm font-medium text-gray-700 mb-1">Название копии</label>
+                <input type="text" id="clone-input" placeholder="Введите название"
+                       class="w-full px-3 py-2 border rounded focus:ring-2 focus:ring-blue-500 focus:border-blue-500">
+                <input type="hidden" id="clone-uuid">
+            </div>
+        </div>
+
+        <div class="flex justify-end space-x-3 mt-6">
+            <button onclick="closeCloneModal()" class="px-4 py-2 text-gray-600 hover:text-gray-800">
+                Отмена
+            </button>
+            <button onclick="cloneConfig()" class="px-4 py-2 bg-green-600 text-white rounded hover:bg-green-700">
+                Копировать
+            </button>
+        </div>
+    </div>
+</div>
+
+<script>
+async function loadConfigs() {
+    const token = localStorage.getItem('token');
+
+    if (!token) {
+        document.getElementById('configs-list').innerHTML =
+            '<div class="bg-white rounded-lg shadow p-8 text-center"><a href="/login" class="text-blue-600">Войдите для просмотра</a></div>';
+        return;
+    }
+
+    try {
+        const resp = await fetch('/api/configs', {
+            headers: {'Authorization': 'Bearer ' + token}
+        });
+
+        if (resp.status === 401) {
+            logout();
+            return;
+        }
+
+        if (resp.status === 403) {
+            document.getElementById('configs-list').innerHTML =
+                '<div class="bg-white rounded-lg shadow p-8 text-center text-red-600">Нет доступа</div>';
+            return;
+        }
+
+        const data = await resp.json();
+        renderConfigs(data.configurations || []);
+    } catch(e) {
+        document.getElementById('configs-list').innerHTML =
+            '<div class="bg-white rounded-lg shadow p-8 text-center text-red-600">Ошибка загрузки</div>';
+    }
+}
+
+function renderConfigs(configs) {
+    if (configs.length === 0) {
+        document.getElementById('configs-list').innerHTML =
+            '<div class="bg-white rounded-lg shadow p-8 text-center text-gray-500">Нет сохраненных конфигураций</div>';
+        return;
+    }
+
+    let html = '<div class="bg-white rounded-lg shadow overflow-hidden"><table class="w-full">';
+    html += '<thead class="bg-gray-50"><tr>';
+    html += '<th class="px-4 py-3 text-left text-xs font-medium text-gray-500 uppercase">Дата</th>';
+    html += '<th class="px-4 py-3 text-left text-xs font-medium text-gray-500 uppercase">Название</th>';
+    html += '<th class="px-4 py-3 text-left text-xs font-medium text-gray-500 uppercase">Цена (за 1 шт)</th>';
+    html += '<th class="px-4 py-3 text-left text-xs font-medium text-gray-500 uppercase">Кол-во</th>';
+    html += '<th class="px-4 py-3 text-right text-xs font-medium text-gray-500 uppercase">Сумма</th>';
+    html += '<th class="px-4 py-3 text-right text-xs font-medium text-gray-500 uppercase">Действия</th>';
+    html += '</tr></thead><tbody class="divide-y">';
+
+    configs.forEach(c => {
+        const date = new Date(c.created_at).toLocaleDateString('ru-RU');
+        const total = c.total_price ? '$' + c.total_price.toLocaleString('en-US', {minimumFractionDigits: 2}) : '—';
+        const serverCount = c.server_count ? c.server_count : 1;
+
+        // Calculate price per unit (total / server count)
+        let pricePerUnit = '—';
+        if (c.total_price && serverCount > 0) {
+            const unitPrice = c.total_price / serverCount;
+            pricePerUnit = '$' + unitPrice.toLocaleString('en-US', {minimumFractionDigits: 2});
+        }
+
+        html += '<tr class="hover:bg-gray-50">';
+        html += '<td class="px-4 py-3 text-sm text-gray-500">' + date + '</td>';
+        html += '<td class="px-4 py-3 text-sm font-medium"><a href="/configurator?uuid=' + c.uuid + '" class="text-blue-600 hover:text-blue-800 hover:underline">' + escapeHtml(c.name) + '</a></td>';
+        html += '<td class="px-4 py-3 text-sm text-gray-500">' + pricePerUnit + '</td>';
+        html += '<td class="px-4 py-3 text-sm text-gray-500">' + serverCount + '</td>';
+        html += '<td class="px-4 py-3 text-sm text-right">' + total + '</td>';
+        html += '<td class="px-4 py-3 text-sm text-right space-x-2">';
+        html += '<button onclick="openCloneModal(\'' + c.uuid + '\', \'' + escapeHtml(c.name).replace(/'/g, "\\'") + '\')" class="text-green-600 hover:text-green-800" title="Копировать">';
+        html += '<svg class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">';
+        html += '<path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M8 16H6a2 2 0 01-2-2V6a2 2 0 012-2h8a2 2 0 012 2v2m-6 12h8a2 2 0 002-2v-8a2 2 0 00-2-2h-8a2 2 0 00-2 2v8a2 2 0 002 2z"></path>';
+        html += '</svg>';
+        html += '</button>';
+        html += '<button onclick="openRenameModal(\'' + c.uuid + '\', \'' + escapeHtml(c.name).replace(/'/g, "\\'") + '\')" class="text-blue-600 hover:text-blue-800" title="Переименовать">';
+        html += '<svg class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">';
+        html += '<path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M11 5H6a2 2 0 00-2 2v11a2 2 0 002 2h11a2 2 0 002-2v-5m-1.414-9.414a2 2 0 112.828 2.828L11.828 15H9v-2.828l8.586-8.586z"></path>';
+        html += '</svg>';
+        html += '</button>';
+        html += '<button onclick="deleteConfig(\'' + c.uuid + '\')" class="text-red-600 hover:text-red-800" title="Удалить">';
+        html += '<svg class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">';
+        html += '<path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M19 7l-.867 12.142A2 2 0 0116.138 21H7.862a2 2 0 01-1.995-1.858L5 7m5 4v6m4-6v6m1-10V4a1 1 0 00-1-1h-4a1 1 0 00-1 1v3M4 7h16"></path>';
+        html += '</svg>';
+        html += '</button>';
+        html += '</td></tr>';
+    });
+
+    html += '</tbody></table></div>';
+    document.getElementById('configs-list').innerHTML = html;
+}
+
+function escapeHtml(text) {
+    const div = document.createElement('div');
+    div.textContent = text;
+    return div.innerHTML;
+}
+
+async function deleteConfig(uuid) {
+    if (!confirm('Удалить?')) return;
+    const token = localStorage.getItem('token');
+    await fetch('/api/configs/' + uuid, {
+        method: 'DELETE',
+        headers: {'Authorization': 'Bearer ' + token}
+    });
+    loadConfigs();
+}
+
+function openRenameModal(uuid, currentName) {
+    const token = localStorage.getItem('token');
+    if (!token) {
+        window.location.href = '/login';
+        return;
+    }
+    document.getElementById('rename-uuid').value = uuid;
+    document.getElementById('rename-input').value = currentName;
+    document.getElementById('rename-modal').classList.remove('hidden');
+    document.getElementById('rename-modal').classList.add('flex');
+    document.getElementById('rename-input').focus();
+    document.getElementById('rename-input').select();
+}
+
+function closeRenameModal() {
+    document.getElementById('rename-modal').classList.add('hidden');
+    document.getElementById('rename-modal').classList.remove('flex');
+}
+
+async function renameConfig() {
+    const token = localStorage.getItem('token');
+    const uuid = document.getElementById('rename-uuid').value;
+    const name = document.getElementById('rename-input').value.trim();
+
+    if (!name) {
+        alert('Введите название');
+        return;
+    }
+
+    try {
+        const resp = await fetch('/api/configs/' + uuid + '/rename', {
+            method: 'PATCH',
+            headers: {
+                'Authorization': 'Bearer ' + token,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({ name: name })
+        });
+
+        if (resp.status === 401) {
+            logout();
+            return;
+        }
+
+        if (!resp.ok) {
+            const err = await resp.json();
+            alert('Ошибка: ' + (err.error || 'Не удалось переименовать'));
+            return;
+        }
+
+        closeRenameModal();
+        loadConfigs();
+    } catch(e) {
+        alert('Ошибка переименования');
+    }
+}
+
+function openCloneModal(uuid, currentName) {
+    const token = localStorage.getItem('token');
+    if (!token) {
+        window.location.href = '/login';
+        return;
+    }
+    document.getElementById('clone-uuid').value = uuid;
+    document.getElementById('clone-input').value = currentName + ' (копия)';
+    document.getElementById('clone-modal').classList.remove('hidden');
+    document.getElementById('clone-modal').classList.add('flex');
+    document.getElementById('clone-input').focus();
+    document.getElementById('clone-input').select();
+}
+
+function closeCloneModal() {
+    document.getElementById('clone-modal').classList.add('hidden');
+    document.getElementById('clone-modal').classList.remove('flex');
+}
+
+async function cloneConfig() {
+    const token = localStorage.getItem('token');
+    const uuid = document.getElementById('clone-uuid').value;
+    const name = document.getElementById('clone-input').value.trim();
+
+    if (!name) {
+        alert('Введите название');
+        return;
+    }
+
+    try {
+        const resp = await fetch('/api/configs/' + uuid + '/clone', {
+            method: 'POST',
+            headers: {
+                'Authorization': 'Bearer ' + token,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({ name: name })
+        });
+
+        if (resp.status === 401) {
+            logout();
+            return;
+        }
+
+        if (!resp.ok) {
+            const err = await resp.json();
+            alert('Ошибка: ' + (err.error || 'Не удалось скопировать'));
+            return;
+        }
+
+        closeCloneModal();
+        loadConfigs();
+    } catch(e) {
+        alert('Ошибка копирования');
+    }
+}
+
+function openCreateModal() {
+    const token = localStorage.getItem('token');
+    if (!token) {
+        window.location.href = '/login';
+        return;
+    }
+    document.getElementById('opportunity-number').value = '';
+    document.getElementById('create-modal').classList.remove('hidden');
+    document.getElementById('create-modal').classList.add('flex');
+    document.getElementById('opportunity-number').focus();
+}
+
+function closeCreateModal() {
+    document.getElementById('create-modal').classList.add('hidden');
+    document.getElementById('create-modal').classList.remove('flex');
+}
+
+async function createConfig() {
+    const token = localStorage.getItem('token');
+    const name = document.getElementById('opportunity-number').value.trim();
+
+    if (!name) {
+        alert('Введите номер Opportunity');
+        return;
+    }
+
+    try {
+        const resp = await fetch('/api/configs', {
+            method: 'POST',
+            headers: {
+                'Authorization': 'Bearer ' + token,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                name: name,
+                items: [],
+                notes: '',
+                server_count: 1
+            })
+        });
+
+        if (resp.status === 401) {
+            logout();
+            return;
+        }
+
+        if (!resp.ok) {
+            const err = await resp.json();
+            alert('Ошибка: ' + (err.error || 'Не удалось создать'));
+            return;
+        }
+
+        const config = await resp.json();
+        window.location.href = '/configurator?uuid=' + config.uuid;
+    } catch(e) {
+        alert('Ошибка создания конфигурации');
+    }
+}
+
+// Close modal on outside click
+document.getElementById('create-modal').addEventListener('click', function(e) {
+    if (e.target === this) {
+        closeCreateModal();
+    }
+});
+
+document.getElementById('rename-modal').addEventListener('click', function(e) {
+    if (e.target === this) {
+        closeRenameModal();
+    }
+});
+
+document.getElementById('clone-modal').addEventListener('click', function(e) {
+    if (e.target === this) {
+        closeCloneModal();
+    }
+});
+
+// Close modal on Escape key
+document.addEventListener('keydown', function(e) {
+    if (e.key === 'Escape') {
+        closeCreateModal();
+        closeRenameModal();
+        closeCloneModal();
+    }
+});
+
+// Submit rename on Enter key
+document.getElementById('rename-input').addEventListener('keydown', function(e) {
+    if (e.key === 'Enter') {
+        renameConfig();
+    }
+});
+
+// Submit clone on Enter key
+document.getElementById('clone-input').addEventListener('keydown', function(e) {
+    if (e.key === 'Enter') {
+        cloneConfig();
+    }
+});
+
+// Pagination functions
+let currentPage = 1;
+let totalPages = 1;
+let perPage = 20;
+
+function prevPage() {
+    if (currentPage > 1) {
+        currentPage--;
+        loadConfigs();
+    }
+}
+
+function nextPage() {
+    if (currentPage < totalPages) {
+        currentPage++;
+        loadConfigs();
+    }
+}
+
+function updatePagination(total) {
+    totalPages = Math.ceil(total / perPage);
+    document.getElementById('page-info').textContent =
+        'Страница ' + currentPage + ' из ' + totalPages + ' (всего: ' + total + ')';
+    document.getElementById('btn-prev').disabled = currentPage <= 1;
+    document.getElementById('btn-next').disabled = currentPage >= totalPages;
+    document.getElementById('pagination').classList.remove('hidden');
+}
+
+// Load configs with pagination
+async function loadConfigs() {
+    const token = localStorage.getItem('token');
+
+    if (!token) {
+        document.getElementById('configs-list').innerHTML =
+            '<div class="bg-white rounded-lg shadow p-8 text-center"><a href="/login" class="text-blue-600">Войдите для просмотра</a></div>';
+        return;
+    }
+
+    try {
+        const resp = await fetch('/api/configs?page=' + currentPage + '&per_page=' + perPage, {
+            headers: {'Authorization': 'Bearer ' + token}
+        });
+
+        if (resp.status === 401) {
+            logout();
+            return;
+        }
+
+        if (resp.status === 403) {
+            document.getElementById('configs-list').innerHTML =
+                '<div class="bg-white rounded-lg shadow p-8 text-center text-red-600">Нет доступа</div>';
+            return;
+        }
+
+        const data = await resp.json();
+        renderConfigs(data.configurations || []);
+        updatePagination(data.total);
+    } catch(e) {
+        document.getElementById('configs-list').innerHTML =
+            '<div class="bg-white rounded-lg shadow p-8 text-center text-red-600">Ошибка загрузки</div>';
+    }
+}
+
+document.addEventListener('DOMContentLoaded', loadConfigs);
+</script>
+{{end}}
+
+{{template "base" .}}
--- a/web/templates/index.html
+++ b/web/templates/index.html
--- a/web/templates/login.html
+++ b/web/templates/login.html
@@ -0,0 +1,82 @@
+{{define "title"}}Вход - QuoteForge{{end}}
+
+{{define "content"}}
+<div class="max-w-sm mx-auto mt-16">
+    <div class="bg-white rounded-lg shadow p-6">
+        <h1 class="text-xl font-bold text-center mb-6">Вход в систему</h1>
+
+        <form id="login-form">
+            <div class="mb-4">
+                <label class="block text-sm font-medium text-gray-700 mb-1">Логин</label>
+                <input type="text" name="username" id="username" required
+                       class="w-full px-3 py-2 border rounded focus:outline-none focus:ring-2 focus:ring-blue-500"
+                       value="admin">
+            </div>
+            <div class="mb-4">
+                <label class="block text-sm font-medium text-gray-700 mb-1">Пароль</label>
+                <input type="password" name="password" id="password" required
+                       class="w-full px-3 py-2 border rounded focus:outline-none focus:ring-2 focus:ring-blue-500"
+                       value="admin123">
+            </div>
+            <div id="error" class="text-red-600 text-sm mb-4 hidden"></div>
+            <button type="submit" id="submit-btn"
+                    class="w-full bg-blue-600 text-white py-2 rounded hover:bg-blue-700">
+                Войти
+            </button>
+        </form>
+
+        <p class="text-center text-sm text-gray-500 mt-4">
+            <a href="/" class="text-blue-600">← На главную</a>
+        </p>
+    </div>
+</div>
+
+<script>
+document.addEventListener('DOMContentLoaded', function() {
+    const form = document.getElementById('login-form');
+    if (!form) return;
+
+    form.addEventListener('submit', async function(e) {
+        e.preventDefault();
+
+        const username = document.getElementById('username').value;
+        const password = document.getElementById('password').value;
+        const errorEl = document.getElementById('error');
+        const btn = document.getElementById('submit-btn');
+
+        errorEl.classList.add('hidden');
+        btn.disabled = true;
+        btn.textContent = 'Вход...';
+
+        try {
+            const resp = await fetch('/api/auth/login', {
+                method: 'POST',
+                headers: {'Content-Type': 'application/json'},
+                body: JSON.stringify({username, password})
+            });
+
+            const data = await resp.json();
+
+            if (resp.ok && data.access_token) {
+                localStorage.setItem('token', data.access_token);
+                localStorage.setItem('refresh_token', data.refresh_token);
+                localStorage.setItem('user', JSON.stringify(data.user));
+                window.location.href = '/configs';
+            } else {
+                errorEl.textContent = data.error || 'Неверный логин или пароль';
+                errorEl.classList.remove('hidden');
+                btn.disabled = false;
+                btn.textContent = 'Войти';
+            }
+        } catch(err) {
+            errorEl.textContent = 'Ошибка соединения с сервером';
+            errorEl.classList.remove('hidden');
+            btn.disabled = false;
+            btn.textContent = 'Войти';
+        }
+    });
+});
+</script>
+{{end}}
+
+{{template "base" .}}
Author	SHA1	Message	Date
Michael Chus	3132ab2fa2	Add cron job functionality and Docker integration	2026-01-31 00:31:43 +03:00
Michael Chus	73acc5410f	Update documentation to reflect actual implementation	2026-01-31 00:06:46 +03:00
Michael Chus	68d0e9a540	delete dangling files	2026-01-30 23:51:24 +03:00
Michael Chus	8309a5dc0e	Add hide component feature, usage indicators, and Docker support - Add is_hidden field to hide components from configurator - Add colored dot indicator showing component usage status: - Green: available in configurator - Cyan: used as source for meta-articles - Gray: hidden from configurator - Optimize price recalculation with caching and skip unchanged - Show current lot name during price recalculation - Add Dockerfile (Alpine-based multi-stage build) - Add docker-compose.yml and .dockerignore Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-01-30 22:49:11 +03:00
Mikhail Chusavitin	48921c699d	Add meta component pricing functionality and admin UI enhancements	2026-01-30 20:49:59 +03:00
Mikhail Chusavitin	d32b1c5d0c	Добавлены сортировка по категориям, секции PCI и автосохранение Основные изменения: 1. CSV экспорт и веб-интерфейс: - Компоненты теперь сортируются по иерархии категорий (display_order) - Категории отображаются в правильном порядке: BB, CPU, MEM, GPU и т.д. - Компоненты без категории отображаются в конце 2. Раздел PCI в конфигураторе: - Разделен на секции: GPU/DPU, NIC/HCA, HBA - Улучшена навигация и выбор компонентов 3. Сохранение "своей цены": - Добавлено поле custom_price в модель Configuration - Создана миграция 002_add_custom_price.sql - "Своя цена" сохраняется при сохранении конфигурации - При загрузке конфигурации восстанавливается сохраненная цена 4. Автосохранение: - Конфигурация автоматически сохраняется через 1 секунду после изменений - Debounce предотвращает избыточные запросы - Автосохранение работает для всех изменений (компоненты, количество, цена) 5. Дополнительно: - Добавлен cmd/importer для импорта метаданных из таблицы lot - Создан скрипт apply_migration.sh для применения миграций - Оптимизирована работа с категориями в ExportService Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>	2026-01-30 17:48:44 +03:00
Mikhail Chusavitin	db37040399	Исправления расчёта цен и добавление функционала своей цены - Исправлен расчёт цен: теперь учитывается метод (медиана/среднее) и период для каждого компонента - Добавлены функции calculateMedian и calculateAverage - Исправлен PreviewPrice для корректного предпросмотра с учётом настроек - Сортировка по умолчанию изменена на популярность (desc) - Добавлен раздел "Своя цена" в конфигуратор: - Ввод целевой цены с пропорциональным пересчётом всех позиций - Отображение скидки в процентах - Таблица скорректированных цен - Экспорт CSV со скидкой Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-01-27 11:53:39 +03:00
Mikhail Chusavitin	7ded78f2c3	Улучшения управления ценами и конфигурациями - Добавлено отображение последней полученной цены в окне настройки цены - Добавлен функционал переименования конфигураций (PATCH /api/configs/:uuid/rename) - Изменён формат имени файла при экспорте: "YYYY-MM-DD NAME SPEC.ext" - Исправлена сортировка компонентов: перенесена на сервер для корректной работы с пагинацией - Добавлен расчёт popularity_score на основе котировок из lot_log - Исправлена потеря настроек (метод, период, коэффициент) при пересчёте цен Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-01-27 11:39:12 +03:00
Mikhail Chusavitin	d7d6e9d62c	New Quotator and some major changes to pricing admin	2026-01-26 18:30:45 +03:00
Mikhail Chusavitin	a93644131c	Redesign configurator UI with tabs and remove Excel export - Add tab-based configurator (Base, Storage, PCI, Power, Accessories, Other) - Base tab: single-select with autocomplete for MB, CPU, MEM - Other tabs: multi-select with autocomplete and quantity input - Table view with LOT, Description, Price, Quantity, Total columns - Add configuration list page with create modal (opportunity number) - Remove Excel export functionality and excelize dependency - Increase component list limit from 100 to 5000 - Add web templates (base, index, configs, login, admin_pricing) Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-01-26 15:57:15 +03:00
Mikhail Chusavitin	44ccb01203	Merge branch 'main' of https://git.mchus.pro/mchus/QuoteForge	2026-01-23 10:50:39 +03:00
Mikhail Chusavitin	190a9aa0a3	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>	2026-01-23 10:49:56 +03:00