refactor: единый источник категории LOT — local_pricelist_items.lot_category

Удалён мёртвый серверный слой управления компонентами/категориями,
который дублировал источники категории LOT. В рантайме категория всегда
берётся из local_pricelist_items.lot_category (наполняется синком из
qt_pricelist_items.lot_category).

Удалено:
- repository: UnifiedRepo/DataSource, ComponentRepository, CategoryRepository
- services: старый ConfigurationService (заменён LocalConfigurationService),
  ComponentService, ComponentToLocal, ImportFromLot, ParsePartNumber
- quote.go: недостижимый online-блок (qt_categories) + componentRepo/
  pricingService/priceResolver

Сохранены живые типы: models.Category/DefaultCategories (для /api/categories),
ComponentView/ComponentListResult, CreateConfigRequest/ArticlePreviewRequest/
ConfigurationGetter/ErrConfig*.

bible-local/03-database.md: зафиксирован единственный источник категории LOT;
qt_categories/qt_lot_metadata перенесены в server-side only.

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

bible-local/02-architecture.md

@@ -40,14 +40,25 @@ Readiness guard:
 
 ## Pricing contract
 
-Prices come only from `local_pricelist_items`.
+`local_pricelist_items` is the single source of truth for both prices and component catalog (lot_name + lot_category). There is no separate component catalog table.
 
 Rules:
-- `local_components` is metadata-only;
+- `local_components` table has been removed; do not recreate it;
-- quote calculation must not read prices from components;
+- component list for the configurator autocomplete comes from `local_pricelist_items` via `ListComponents`;
+- quote calculation reads prices from `local_pricelist_items` only;
 - latest pricelist selection ignores snapshots without items;
 - auto pricelist mode stays auto and must not be persisted as an explicit resolved ID.
 
+## lot_name case handling
+
+lot_names in `local_pricelist_items` may be stored in mixed case in databases synced before normalization was enforced. `NormalizeLotName` (uppercase + trim) is applied at sync time via `PricelistItemToLocal`, but existing rows are not retroactively updated.
+
+Rules:
+- all SQLite queries that filter by `lot_name` must use `UPPER(lot_name) IN ?` or `UPPER(lot_name) = ?` with an uppercased input — never a bare `=` or `IN` on a string that may have been sourced from user input or a legacy row;
+- result map keys must preserve the original case passed by the caller (build a `uppercase → original` index before the query);
+- `GetLocalPricesForLots` is the canonical pattern: it uppercases the input list, queries with `UPPER(lot_name) IN ?`, and returns keys that match the input lot_names;
+- frontend JS must never infer a component category from the lot_name prefix; `lot_category` from `local_pricelist_items` is the only valid source; items without a category fall into the "Other" tab.
+
 ## Pricing tab layout
 
 The Pricing tab (Ценообразование) has two tables: Buy (Цена покупки) and Sale (Цена продажи).
@@ -133,7 +144,7 @@ full contract and JSON schemas.
 | `required_categories` | Per-config-type badge on tabs with unfilled required categories |
 
 Rules:
-- sync runs after `SyncComponents`; failure is non-fatal (Warn log only);
+- sync runs as part of the pricelist pull; failure is non-fatal (Warn log only);
 - `local_qt_settings` is a read-only cache — never written by user actions;
 - absent or unparseable settings: QF uses hardcoded fallbacks for that key only;
 - `config_types[].categories` is an allowlist: a category absent from all types is shown everywhere;

bible-local/03-database.md

@@ -8,9 +8,8 @@ Main tables:
 
 | Table | Purpose |
 | --- | --- |
-| `local_components` | synced component metadata |
 | `local_pricelists` | local pricelist headers |
-| `local_pricelist_items` | local pricelist rows, the only runtime price source |
+| `local_pricelist_items` | pricelist rows; the only runtime source of prices and component catalog |
 | `local_projects` | user projects |
 | `local_configurations` | user configurations |
 | `local_configuration_versions` | immutable revision snapshots |
@@ -25,8 +24,10 @@ Main tables:
 Rules:
 - cache tables may be rebuilt if local migration recovery requires it;
 - user-authored tables must not be dropped as a recovery shortcut;
-- `local_pricelist_items` is the only valid runtime source of prices;
+- `local_pricelist_items` is the only valid runtime source of prices and component catalog; do not add a separate component cache table;
-- configuration `items` and `vendor_spec` are stored as JSON payloads inside configuration rows.
+- `local_pricelist_items.lot_category` is the single source of a LOT's category at runtime (populated by sync from `qt_pricelist_items.lot_category`); do not derive category from a lot_name prefix or from `qt_categories`/`qt_lot_metadata`;
+- configuration `items` and `vendor_spec` are stored as JSON payloads inside configuration rows;
+- `local_components` table has been removed; any reference to it is dead code.
 
 ## MariaDB
 
@@ -35,8 +36,6 @@ MariaDB is the central sync database (`RFQ_LOG`). Final schema as of 2026-04-15.
 ### QuoteForge tables (qt_*)
 
 Runtime read:
-- `qt_categories` — pricelist categories (note: `name`/`name_ru` columns being removed; QF does not use them)
-- `qt_lot_metadata` — component metadata, price settings
 - `qt_pricelists` — pricelist headers (source: estimate / warehouse / competitor)
 - `qt_pricelist_items` — pricelist rows
 - `qt_partnumber_books` — partnumber book headers
@@ -53,6 +52,8 @@ Insert-only tracking:
 - `qt_vendor_partnumber_seen` — vendor partnumbers encountered during sync; `lot_suggestion` column updated when user manually maps PN → LOT in vendor-spec UI
 
 Server-side only (not queried by client runtime):
+- `qt_categories` — pricelist category registry; QF runtime serves category lists for the UI from `models.DefaultCategories` (Go) overlaid with categories present in `local_pricelist_items`, not from this table. `name`/`name_ru` columns being removed.
+- `qt_lot_metadata` — component metadata / price settings; the Go server-side component/category management layer (`ComponentRepository`, `CategoryRepository`, `ComponentService`) was removed — no client code reads this table
 - `qt_component_usage_stats` — aggregated component popularity stats (written by server jobs)
 - `qt_pricing_alerts` — price anomaly alerts (models exist in Go; feature disabled in runtime)
 - `qt_schema_migrations` — server migration history (applied via `go run ./cmd/qfs -migrate`)

cmd/qfs/main.go

@@ -677,8 +677,7 @@ func setupRouter(cfg *config.Config, local *localdb.LocalDB, connMgr *db.Connect
 	var projectService *services.ProjectService
 
 	syncService = sync.NewService(connMgr, local)
-	componentService := services.NewComponentService(nil, nil)
+	quoteService := services.NewQuoteService(nil, local)
-	quoteService := services.NewQuoteService(nil, nil, local, nil)
 	exportService := services.NewExportService(cfg.Export, local)
 
 	// isOnline function for local-first architecture
@@ -775,7 +774,7 @@ func setupRouter(cfg *config.Config, local *localdb.LocalDB, connMgr *db.Connect
 	templatesPath := filepath.Join("web", "templates")
 
 	// Handlers
-	componentHandler := handlers.NewComponentHandler(componentService, local)
+	componentHandler := handlers.NewComponentHandler(local)
 	quoteHandler := handlers.NewQuoteHandler(quoteService)
 	exportHandler := handlers.NewExportHandler(exportService, configService, projectService, dbUsername)
 	pricelistHandler := handlers.NewPricelistHandler(local)
@@ -1811,7 +1810,6 @@ func setupRouter(cfg *config.Config, local *localdb.LocalDB, connMgr *db.Connect
 			syncAPI.GET("/readiness", syncHandler.GetReadiness)
 			syncAPI.GET("/info", syncHandler.GetInfo)
 			syncAPI.GET("/users-status", syncHandler.GetUsersStatus)
-			syncAPI.POST("/components", syncHandler.SyncComponents)
 			syncAPI.POST("/pricelists", syncHandler.SyncPricelists)
 			syncAPI.POST("/partnumber-books", syncHandler.SyncPartnumberBooks)
 			syncAPI.POST("/partnumber-seen", syncHandler.ReportPartnumberSeen)

internal/article/categories_test.go

@@ -45,38 +45,55 @@ func TestResolveLotCategoriesStrict_MissingCategoryReturnsError(t *testing.T) {
 	}
 }
 
-func TestResolveLotCategoriesStrict_FallbackToLocalComponents(t *testing.T) {
+func TestResolveLotCategoriesStrict_FallbackToLatestPricelist(t *testing.T) {
 	local, err := localdb.New(filepath.Join(t.TempDir(), "local.db"))
 	if err != nil {
 		t.Fatalf("init local db: %v", err)
 	}
 	t.Cleanup(func() { _ = local.Close() })
 
+	// Older pricelist used by the configuration — CPU_B has no category here
 	if err := local.SaveLocalPricelist(&localdb.LocalPricelist{
 		ServerID:  2,
 		Source:    "estimate",
 		Version:   "S-2026-02-11-002",
-		Name:      "test",
+		Name:      "old",
+		IsActive:  false,
+		CreatedAt: time.Now().Add(-time.Hour),
+		SyncedAt:  time.Now().Add(-time.Hour),
+	}); err != nil {
+		t.Fatalf("save old pricelist: %v", err)
+	}
+	oldPL, err := local.GetLocalPricelistByServerID(2)
+	if err != nil {
+		t.Fatalf("get old pricelist: %v", err)
+	}
+	if err := local.SaveLocalPricelistItems([]localdb.LocalPricelistItem{
+		{PricelistID: oldPL.ID, LotName: "CPU_B", LotCategory: "", Price: 10},
+	}); err != nil {
+		t.Fatalf("save old pricelist items: %v", err)
+	}
+
+	// Newer active pricelist — CPU_B has category set
+	if err := local.SaveLocalPricelist(&localdb.LocalPricelist{
+		ServerID:  3,
+		Source:    "estimate",
+		Version:   "S-2026-02-11-003",
+		Name:      "latest",
+		IsActive:  true,
 		CreatedAt: time.Now(),
 		SyncedAt:  time.Now(),
 	}); err != nil {
-		t.Fatalf("save local pricelist: %v", err)
+		t.Fatalf("save latest pricelist: %v", err)
 	}
-	localPL, err := local.GetLocalPricelistByServerID(2)
+	latestPL, err := local.GetLocalPricelistByServerID(3)
 	if err != nil {
-		t.Fatalf("get local pricelist: %v", err)
+		t.Fatalf("get latest pricelist: %v", err)
 	}
 	if err := local.SaveLocalPricelistItems([]localdb.LocalPricelistItem{
-		{PricelistID: localPL.ID, LotName: "CPU_B", LotCategory: "", Price: 10},
+		{PricelistID: latestPL.ID, LotName: "CPU_B", LotCategory: "CPU", Price: 10},
 	}); err != nil {
-		t.Fatalf("save local items: %v", err)
+		t.Fatalf("save latest pricelist items: %v", err)
-	}
-	if err := local.DB().Create(&localdb.LocalComponent{
-		LotName:        "CPU_B",
-		Category:       "CPU",
-		LotDescription: "cpu",
-	}).Error; err != nil {
-		t.Fatalf("save local components: %v", err)
 	}
 
 	cats, err := ResolveLotCategoriesStrict(local, 2, []string{"CPU_B"})

internal/handlers/component.go

@@ -7,20 +7,17 @@ import (
 
 	"git.mchus.pro/mchus/quoteforge/internal/localdb"
 	"git.mchus.pro/mchus/quoteforge/internal/models"
-	"git.mchus.pro/mchus/quoteforge/internal/repository"
 	"git.mchus.pro/mchus/quoteforge/internal/services"
 	"github.com/gin-gonic/gin"
 )
 
 type ComponentHandler struct {
-	componentService *services.ComponentService
+	localDB *localdb.LocalDB
-	localDB          *localdb.LocalDB
 }
 
-func NewComponentHandler(componentService *services.ComponentService, localDB *localdb.LocalDB) *ComponentHandler {
+func NewComponentHandler(localDB *localdb.LocalDB) *ComponentHandler {
 	return &ComponentHandler{
-		componentService: componentService,
+		localDB: localDB,
-		localDB:          localDB,
 	}
 }
 
@@ -34,17 +31,10 @@ func (h *ComponentHandler) List(c *gin.Context) {
 		perPage = 20
 	}
 
-	filter := repository.ComponentFilter{
-		Category:      c.Query("category"),
-		Search:        c.Query("search"),
-		HasPrice:      c.Query("has_price") == "true",
-		ExcludeHidden: c.Query("include_hidden") != "true", // По умолчанию скрытые не показываются
-	}
-
 	localFilter := localdb.ComponentFilter{
-		Category: filter.Category,
+		Category: c.Query("category"),
-		Search:   filter.Search,
+		Search:   c.Query("search"),
-		HasPrice: filter.HasPrice,
+		HasPrice: c.Query("has_price") == "true",
 	}
 	offset := (page - 1) * perPage
 	localComps, total, err := h.localDB.ListComponents(localFilter, offset, perPage)

internal/handlers/pricelist.go

@@ -177,22 +177,12 @@ func (h *PricelistHandler) GetItems(c *gin.Context) {
 		return
 	}
 
-	lotNames := make([]string, len(items))
-	for i, item := range items {
-		lotNames[i] = item.LotName
-	}
-	descMap, err := h.localDB.GetLocalComponentDescriptionsByLotNames(lotNames)
-	if err != nil {
-		RespondError(c, http.StatusInternalServerError, "internal server error", err)
-		return
-	}
-
 	resultItems := make([]gin.H, 0, len(items))
 	for _, item := range items {
 		resultItems = append(resultItems, gin.H{
 			"id":               item.ID,
 			"lot_name":         item.LotName,
-			"lot_description":  descMap[item.LotName],
+			"lot_description":  "",
 			"price":            item.Price,
 			"category":         item.LotCategory,
 			"available_qty":    item.AvailableQty,

internal/handlers/support_bundle.go

@@ -74,7 +74,7 @@ func (h *SupportBundleHandler) DownloadBundle(c *gin.Context) {
 
 	// local_db_stats.json
 	writeJSON("local_db_stats.json", map[string]any{
-		"components":                   h.localDB.CountLocalComponents(),
+		"components":                   h.localDB.CountComponents(),
 		"configurations":               h.localDB.CountConfigurations(),
 		"projects":                     h.localDB.CountProjects(),
 		"pricelists":                   h.localDB.CountLocalPricelists(),
@@ -139,6 +139,7 @@ func (h *SupportBundleHandler) DownloadBundle(c *gin.Context) {
 			CreatedAt time.Time `json:"created_at"`
 			SyncedAt  time.Time `json:"synced_at"`
 			IsUsed    bool      `json:"is_used"`
+			IsActive  bool      `json:"is_active"`
 		}
 		bySource := map[string][]plEntry{}
 		for _, pl := range pricelists {
@@ -150,12 +151,78 @@ func (h *SupportBundleHandler) DownloadBundle(c *gin.Context) {
 				CreatedAt: pl.CreatedAt,
 				SyncedAt:  pl.SyncedAt,
 				IsUsed:    pl.IsUsed,
+				IsActive:  pl.IsActive,
 			}
 			bySource[pl.Source] = append(bySource[pl.Source], e)
 		}
 		writeJSON("pricelists.json", bySource)
 	}
 
+	// pricelist_coverage.json — for each local estimate pricelist: item count by lot_category
+	if pl, err := h.localDB.GetLatestLocalPricelist(); err == nil {
+		type catRow struct {
+			Category string `json:"category"`
+			Count    int64  `json:"count"`
+		}
+		type plCoverage struct {
+			Version    string   `json:"version"`
+			ServerID   uint     `json:"server_id"`
+			TotalItems int64    `json:"total_items"`
+			Categories []catRow `json:"categories"`
+		}
+		rows, total, catErr := h.localDB.GetLocalPricelistCoverageByCategory(pl.ID)
+		if catErr == nil {
+			cats := make([]catRow, 0, len(rows))
+			for cat, cnt := range rows {
+				cats = append(cats, catRow{Category: cat, Count: cnt})
+			}
+			writeJSON("pricelist_coverage.json", plCoverage{
+				Version:    pl.Version,
+				ServerID:   pl.ServerID,
+				TotalItems: total,
+				Categories: cats,
+			})
+		}
+	}
+
+	// configurator_settings.json — what /api/configurator-settings actually returns
+	if cfgSettings, err := h.localDB.GetConfiguratorSettings(); err == nil {
+		writeJSON("configurator_settings.json", cfgSettings)
+	} else {
+		writeJSON("configurator_settings.json", map[string]any{"error": err.Error()})
+	}
+
+	// component_categories.json — distinct categories in active estimate pricelist
+	if cats, err := h.localDB.GetLocalComponentCategories(); err == nil {
+		writeJSON("component_categories.json", cats)
+	}
+
+	// autocomplete_lots.json — per-category breakdown of lots with their prices
+	// Mirrors what filterAutocomplete() works with: lot_name + estimate_price per category.
+	if pl, err := h.localDB.GetLatestLocalPricelist(); err == nil {
+		if items, err := h.localDB.GetLocalPricelistItems(pl.ID); err == nil {
+			type lotEntry struct {
+				LotName  string  `json:"lot_name"`
+				Price    float64 `json:"price"`
+				HasPrice bool    `json:"has_price"`
+			}
+			byCategory := map[string][]lotEntry{}
+			for _, it := range items {
+				entry := lotEntry{
+					LotName:  it.LotName,
+					Price:    it.Price,
+					HasPrice: it.Price > 0,
+				}
+				byCategory[it.LotCategory] = append(byCategory[it.LotCategory], entry)
+			}
+			writeJSON("autocomplete_lots.json", map[string]any{
+				"pricelist_version": pl.Version,
+				"pricelist_id":      pl.ServerID,
+				"by_category":       byCategory,
+			})
+		}
+	}
+
 	// schema_migrations.json
 	migrations, err := h.localDB.GetSchemaMigrations()
 	if err != nil {
@@ -163,6 +230,44 @@ func (h *SupportBundleHandler) DownloadBundle(c *gin.Context) {
 	}
 	writeJSON("schema_migrations.json", migrations)
 
+	// latest_pricelist_items.json — all items from the most recent active estimate pricelist
+	if pl, err := h.localDB.GetLatestLocalPricelist(); err == nil {
+		if items, err := h.localDB.GetLocalPricelistItems(pl.ID); err == nil {
+			type plItem struct {
+				LotName     string  `json:"lot_name"`
+				LotCategory string  `json:"lot_category"`
+				Price       float64 `json:"price"`
+			}
+			out := make([]plItem, len(items))
+			for i, it := range items {
+				out[i] = plItem{
+					LotName:     it.LotName,
+					LotCategory: it.LotCategory,
+					Price:       it.Price,
+				}
+			}
+			writeJSON("latest_pricelist_items.json", map[string]any{
+				"pricelist_version": pl.Version,
+				"pricelist_id":      pl.ServerID,
+				"source":            pl.Source,
+				"item_count":        len(out),
+				"items":             out,
+			})
+		}
+	}
+
+	// local.db — full SQLite database file (for deep diagnostics)
+	if dbPath := h.localDB.DBFilePath(); dbPath != "" {
+		if f, err := os.Open(dbPath); err == nil {
+			defer f.Close()
+			if w, err := zw.Create("local.db"); err == nil {
+				if _, err := io.Copy(w, f); err != nil {
+					slog.Warn("support bundle: error copying local.db", "err", err)
+				}
+			}
+		}
+	}
+
 	// app.log (tail 5 MiB)
 	if h.logFilePath != "" {
 		if f, err := os.Open(h.logFilePath); err == nil {

internal/handlers/sync.go

@@ -50,7 +50,6 @@ func NewSyncHandler(localDB *localdb.LocalDB, syncService *sync.Service, connMgr
 
 // SyncStatusResponse represents the sync status
 type SyncStatusResponse struct {
-	LastComponentSync       *time.Time          `json:"last_component_sync"`
 	LastPricelistSync       *time.Time          `json:"last_pricelist_sync"`
 	LastPricelistAttemptAt  *time.Time          `json:"last_pricelist_attempt_at,omitempty"`
 	LastPricelistSyncStatus string              `json:"last_pricelist_sync_status,omitempty"`
@@ -61,7 +60,6 @@ type SyncStatusResponse struct {
 	ComponentsCount         int64               `json:"components_count"`
 	PricelistsCount         int64               `json:"pricelists_count"`
 	ServerPricelists        int                 `json:"server_pricelists"`
-	NeedComponentSync       bool                `json:"need_component_sync"`
 	NeedPricelistSync       bool                `json:"need_pricelist_sync"`
 	Readiness               *sync.SyncReadiness `json:"readiness,omitempty"`
 }
@@ -80,19 +78,16 @@ type SyncReadinessResponse struct {
 func (h *SyncHandler) GetStatus(c *gin.Context) {
 	connStatus := h.connMgr.GetStatus()
 	isOnline := connStatus.IsConnected && strings.TrimSpace(connStatus.LastError) == ""
-	lastComponentSync := h.localDB.GetComponentSyncTime()
 	lastPricelistSync := h.localDB.GetLastSyncTime()
-	componentsCount := h.localDB.CountLocalComponents()
+	componentsCount := h.localDB.CountComponents()
 	pricelistsCount := h.localDB.CountLocalPricelists()
 	lastPricelistAttemptAt := h.localDB.GetLastPricelistSyncAttemptAt()
 	lastPricelistSyncStatus := h.localDB.GetLastPricelistSyncStatus()
 	lastPricelistSyncError := h.localDB.GetLastPricelistSyncError()
 	hasFailedSync := strings.EqualFold(lastPricelistSyncStatus, "failed")
-	needComponentSync := h.localDB.NeedComponentSync(24)
 	readiness := h.getReadinessLocal()
 
 	c.JSON(http.StatusOK, SyncStatusResponse{
-		LastComponentSync:       lastComponentSync,
 		LastPricelistSync:       lastPricelistSync,
 		LastPricelistAttemptAt:  lastPricelistAttemptAt,
 		LastPricelistSyncStatus: lastPricelistSyncStatus,
@@ -103,7 +98,6 @@ func (h *SyncHandler) GetStatus(c *gin.Context) {
 		ComponentsCount:         componentsCount,
 		PricelistsCount:         pricelistsCount,
 		ServerPricelists:        0,
-		NeedComponentSync:       needComponentSync,
 		NeedPricelistSync:       lastPricelistSync == nil || hasFailedSync,
 		Readiness:               readiness,
 	})
@@ -169,52 +163,6 @@ type SyncResultResponse struct {
 	Duration string `json:"duration"`
 }
 
-// SyncComponents syncs components from MariaDB to local SQLite
-// POST /api/sync/components
-func (h *SyncHandler) SyncComponents(c *gin.Context) {
-	if !h.ensureSyncReadiness(c) {
-		return
-	}
-
-	// Get database connection from ConnectionManager
-	mariaDB, err := h.connMgr.GetDB()
-	if err != nil {
-		c.JSON(http.StatusServiceUnavailable, gin.H{
-			"success": false,
-			"error":   "database connection failed",
-		})
-		_ = c.Error(err)
-		return
-	}
-
-	now := time.Now()
-	result, err := h.localDB.SyncComponents(mariaDB)
-	if err != nil {
-		_ = h.localDB.SetComponentSyncResult("error", err.Error(), now)
-		h.localDB.AppendSyncLog("components", "error", err.Error(), 0, now, time.Since(now).Milliseconds())
-		slog.Error("component sync failed", "error", err)
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"success": false,
-			"error":   "component sync failed",
-		})
-		_ = c.Error(err)
-		return
-	}
-	_ = h.localDB.SetComponentSyncResult("ok", "", now)
-	h.localDB.AppendSyncLog("components", "ok", "", result.TotalSynced, now, result.Duration.Milliseconds())
-
-	if err := h.localDB.SyncQtSettings(mariaDB); err != nil {
-		slog.Warn("qt_settings sync failed", "error", err)
-	}
-
-	c.JSON(http.StatusOK, SyncResultResponse{
-		Success:  true,
-		Message:  "Components synced successfully",
-		Synced:   result.TotalSynced,
-		Duration: result.Duration.String(),
-	})
-}
-
 // SyncPricelists syncs pricelists from MariaDB to local SQLite
 // POST /api/sync/pricelists
 func (h *SyncHandler) SyncPricelists(c *gin.Context) {
@@ -280,7 +228,6 @@ type SyncAllResponse struct {
 	Success                bool   `json:"success"`
 	Message                string `json:"message"`
 	PendingPushed          int    `json:"pending_pushed"`
-	ComponentsSynced       int    `json:"components_synced"`
 	PricelistsSynced       int    `json:"pricelists_synced"`
 	ProjectsImported       int    `json:"projects_imported"`
 	ProjectsUpdated        int    `json:"projects_updated"`
@@ -301,7 +248,7 @@ func (h *SyncHandler) SyncAll(c *gin.Context) {
 	}
 
 	startTime := time.Now()
-	var pendingPushed, componentsSynced, pricelistsSynced int
+	var pricelistsSynced int
 
 	// Push local pending changes first (projects/configurations)
 	pendingPushed, err := h.syncService.PushPendingChanges()
@@ -315,38 +262,6 @@ func (h *SyncHandler) SyncAll(c *gin.Context) {
 		return
 	}
 
-	// Sync components
-	mariaDB, err := h.connMgr.GetDB()
-	if err != nil {
-		c.JSON(http.StatusServiceUnavailable, gin.H{
-			"success": false,
-			"error":   "database connection failed",
-		})
-		_ = c.Error(err)
-		return
-	}
-
-	compNow := time.Now()
-	compResult, err := h.localDB.SyncComponents(mariaDB)
-	if err != nil {
-		_ = h.localDB.SetComponentSyncResult("error", err.Error(), compNow)
-		h.localDB.AppendSyncLog("components", "error", err.Error(), 0, compNow, time.Since(compNow).Milliseconds())
-		slog.Error("component sync failed during full sync", "error", err)
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"success": false,
-			"error":   "component sync failed",
-		})
-		_ = c.Error(err)
-		return
-	}
-	_ = h.localDB.SetComponentSyncResult("ok", "", compNow)
-	h.localDB.AppendSyncLog("components", "ok", "", compResult.TotalSynced, compNow, compResult.Duration.Milliseconds())
-	componentsSynced = compResult.TotalSynced
-
-	if err := h.localDB.SyncQtSettings(mariaDB); err != nil {
-		slog.Warn("qt_settings sync failed", "error", err)
-	}
-
 	// Sync pricelists
 	plNow := time.Now()
 	pricelistsSynced, err = h.syncService.SyncPricelists()
@@ -354,10 +269,9 @@ func (h *SyncHandler) SyncAll(c *gin.Context) {
 		h.localDB.AppendSyncLog("pricelists", "error", err.Error(), 0, plNow, time.Since(plNow).Milliseconds())
 		slog.Error("pricelist sync failed during full sync", "error", err)
 		c.JSON(http.StatusInternalServerError, gin.H{
-			"success":           false,
+			"success":        false,
-			"error":             "pricelist sync failed",
+			"error":          "pricelist sync failed",
-			"pending_pushed":    pendingPushed,
+			"pending_pushed": pendingPushed,
-			"components_synced": componentsSynced,
 		})
 		_ = c.Error(err)
 		return
@@ -375,7 +289,6 @@ func (h *SyncHandler) SyncAll(c *gin.Context) {
 			"success":           false,
 			"error":             "project import failed",
 			"pending_pushed":    pendingPushed,
-			"components_synced": componentsSynced,
 			"pricelists_synced": pricelistsSynced,
 		})
 		_ = c.Error(err)
@@ -389,7 +302,6 @@ func (h *SyncHandler) SyncAll(c *gin.Context) {
 			"success":           false,
 			"error":             "configuration import failed",
 			"pending_pushed":    pendingPushed,
-			"components_synced": componentsSynced,
 			"pricelists_synced": pricelistsSynced,
 			"projects_imported": projectsResult.Imported,
 			"projects_updated":  projectsResult.Updated,
@@ -403,7 +315,6 @@ func (h *SyncHandler) SyncAll(c *gin.Context) {
 		Success:                true,
 		Message:                "Full sync completed successfully",
 		PendingPushed:          pendingPushed,
-		ComponentsSynced:       componentsSynced,
 		PricelistsSynced:       pricelistsSynced,
 		ProjectsImported:       projectsResult.Imported,
 		ProjectsUpdated:        projectsResult.Updated,
@@ -564,7 +475,7 @@ func (h *SyncHandler) GetInfo(c *gin.Context) {
 	// Get local counts
 	configCount := h.localDB.CountConfigurations()
 	projectCount := h.localDB.CountProjects()
-	componentCount := h.localDB.CountLocalComponents()
+	componentCount := h.localDB.CountComponents()
 	pricelistCount := h.localDB.CountLocalPricelists()
 
 	// Get error count (only changes with LastError != "")

internal/handlers/vendor_spec.go

@@ -4,9 +4,9 @@ import (
 	"errors"
 	"log/slog"
 	"net/http"
-	"strings"
 
 	"git.mchus.pro/mchus/quoteforge/internal/localdb"
+	"git.mchus.pro/mchus/quoteforge/internal/models"
 	"git.mchus.pro/mchus/quoteforge/internal/repository"
 	"git.mchus.pro/mchus/quoteforge/internal/services"
 	syncsvc "git.mchus.pro/mchus/quoteforge/internal/services/sync"
@@ -172,7 +172,7 @@ func normalizeLotMappings(in []localdb.VendorSpecLotMapping) []localdb.VendorSpe
 	merged := make(map[string]int, len(in))
 	order := make([]string, 0, len(in))
 	for _, m := range in {
-		lot := strings.TrimSpace(m.LotName)
+		lot := models.NormalizeLotName(m.LotName)
 		if lot == "" {
 			continue
 		}

internal/localdb/components.go

@@ -2,11 +2,8 @@ package localdb
 
 import (
 	"fmt"
-	"log/slog"
 	"strings"
 	"time"
-
-	"gorm.io/gorm"
 )
 
 // ComponentFilter for searching with filters
@@ -24,344 +21,213 @@ type ComponentSyncResult struct {
 	Duration    time.Duration
 }
 
-// SyncComponents loads components from MariaDB (lot + qt_lot_metadata) into local_components
+// latestActivePricelistID returns the local DB id of the most recently created
-func (l *LocalDB) SyncComponents(mariaDB *gorm.DB) (*ComponentSyncResult, error) {
+// active pricelist for the given source ("estimate", "warehouse", etc.).
-	startTime := time.Now()
+func (l *LocalDB) latestActivePricelistID(source string) (uint, error) {
-
+	var id uint
-	// Build the component catalog from every runtime source of LOT names.
+	err := l.db.Table("local_pricelists").
-	// Storage lots may exist in qt_lot_metadata / qt_pricelist_items before they appear in lot,
+		Select("id").
-	// so the sync cannot start from lot alone.
+		Where("is_active = ? AND source = ?", true, source).
-	type componentRow struct {
+		Order("created_at DESC, id DESC").
-		LotName        string
+		Limit(1).
-		LotDescription string
+		Scan(&id).Error
-		Category       *string
-		Model          *string
-	}
-
-	var rows []componentRow
-	err := mariaDB.Raw(`
-		SELECT
-			src.lot_name,
-			COALESCE(MAX(NULLIF(TRIM(l.lot_description), '')), '') AS lot_description,
-			COALESCE(
-				MAX(NULLIF(TRIM(c.code), '')),
-				MAX(NULLIF(TRIM(l.lot_category), '')),
-				SUBSTRING_INDEX(src.lot_name, '_', 1)
-			) AS category,
-			MAX(NULLIF(TRIM(m.model), '')) AS model
-		FROM (
-			SELECT lot_name FROM lot
-			UNION
-			SELECT lot_name FROM qt_lot_metadata
-			WHERE is_hidden = FALSE OR is_hidden IS NULL
-			UNION
-			SELECT lot_name FROM qt_pricelist_items
-		) src
-		LEFT JOIN lot l ON l.lot_name = src.lot_name
-		LEFT JOIN qt_lot_metadata m
-			ON m.lot_name = src.lot_name
-			AND (m.is_hidden = FALSE OR m.is_hidden IS NULL)
-		LEFT JOIN qt_categories c ON m.category_id = c.id
-		GROUP BY src.lot_name
-		ORDER BY src.lot_name
-	`).Scan(&rows).Error
 	if err != nil {
-		return nil, fmt.Errorf("querying components from MariaDB: %w", err)
+		return 0, err
 	}
-
+	if id == 0 {
-	if len(rows) == 0 {
+		return 0, fmt.Errorf("no active %s pricelist", source)
-		slog.Warn("no components found in MariaDB")
-		return &ComponentSyncResult{
-			Duration: time.Since(startTime),
-		}, nil
 	}
-
+	return id, nil
-	// Get existing local components for comparison
-	existingMap := make(map[string]bool)
-	var existing []LocalComponent
-	if err := l.db.Find(&existing).Error; err != nil {
-		return nil, fmt.Errorf("reading existing local components: %w", err)
-	}
-	for _, c := range existing {
-		existingMap[c.LotName] = true
-	}
-
-	// Prepare components for batch insert/update.
-	// Source joins may duplicate the same lot_name, so collapse them before insert.
-	syncTime := time.Now()
-	components := make([]LocalComponent, 0, len(rows))
-	componentIndex := make(map[string]int, len(rows))
-	newCount := 0
-
-	for _, row := range rows {
-		lotName := strings.TrimSpace(row.LotName)
-		if lotName == "" {
-			continue
-		}
-
-		category := ""
-		if row.Category != nil {
-			category = strings.TrimSpace(*row.Category)
-		} else {
-			// Parse category from lot_name (e.g., "CPU_AMD_9654" -> "CPU")
-			parts := strings.SplitN(lotName, "_", 2)
-			if len(parts) >= 1 {
-				category = parts[0]
-			}
-		}
-
-		model := ""
-		if row.Model != nil {
-			model = strings.TrimSpace(*row.Model)
-		}
-
-		comp := LocalComponent{
-			LotName:        lotName,
-			LotDescription: strings.TrimSpace(row.LotDescription),
-			Category:       category,
-			Model:          model,
-		}
-
-		if idx, exists := componentIndex[lotName]; exists {
-			// Keep the first row, but fill any missing metadata from duplicates.
-			if components[idx].LotDescription == "" && comp.LotDescription != "" {
-				components[idx].LotDescription = comp.LotDescription
-			}
-			if components[idx].Category == "" && comp.Category != "" {
-				components[idx].Category = comp.Category
-			}
-			if components[idx].Model == "" && comp.Model != "" {
-				components[idx].Model = comp.Model
-			}
-			continue
-		}
-
-		componentIndex[lotName] = len(components)
-		components = append(components, comp)
-
-		if !existingMap[lotName] {
-			newCount++
-		}
-	}
-
-	// Use transaction for bulk upsert
-	err = l.db.Transaction(func(tx *gorm.DB) error {
-		// Delete all existing and insert new (simpler than upsert for SQLite)
-		if err := tx.Where("1=1").Delete(&LocalComponent{}).Error; err != nil {
-			return fmt.Errorf("clearing local components: %w", err)
-		}
-
-		// Batch insert
-		batchSize := 500
-		for i := 0; i < len(components); i += batchSize {
-			end := i + batchSize
-			if end > len(components) {
-				end = len(components)
-			}
-			if err := tx.CreateInBatches(components[i:end], batchSize).Error; err != nil {
-				return fmt.Errorf("inserting components batch: %w", err)
-			}
-		}
-
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	// Update last sync time
-	if err := l.SetComponentSyncTime(syncTime); err != nil {
-		slog.Warn("failed to update component sync time", "error", err)
-	}
-
-	result := &ComponentSyncResult{
-		TotalSynced: len(components),
-		NewCount:    newCount,
-		UpdateCount: len(components) - newCount,
-		Duration:    time.Since(startTime),
-	}
-
-	slog.Info("components synced",
-		"total", result.TotalSynced,
-		"new", result.NewCount,
-		"updated", result.UpdateCount,
-		"duration", result.Duration)
-
-	return result, nil
 }
 
-// SearchLocalComponents searches components in local cache by query string
+// pricelistItemRow is used for scanning rows from local_pricelist_items.
-// Searches in lot_name, lot_description, category, and model fields
+type pricelistItemRow struct {
+	LotName  string `gorm:"column:lot_name"`
+	Category string `gorm:"column:lot_category"`
+}
+
+func (r pricelistItemRow) toLocalComponent() LocalComponent {
+	return LocalComponent{
+		LotName:  r.LotName,
+		Category: r.Category,
+	}
+}
+
+
+// SearchLocalComponents searches components in the latest active estimate
+// pricelist by lot_name.
 func (l *LocalDB) SearchLocalComponents(query string, limit int) ([]LocalComponent, error) {
 	if limit <= 0 {
 		limit = 50
 	}
-
+	pricelistID, err := l.latestActivePricelistID("estimate")
-	var components []LocalComponent
-
-	if query == "" {
-		// Return all components with limit
-		err := l.db.Order("lot_name").Limit(limit).Find(&components).Error
-		return components, err
-	}
-
-	// Search with LIKE on multiple fields
-	searchPattern := "%" + strings.ToLower(query) + "%"
-
-	err := l.db.Where(
-		"LOWER(lot_name) LIKE ? OR LOWER(lot_description) LIKE ? OR LOWER(category) LIKE ? OR LOWER(model) LIKE ?",
-		searchPattern, searchPattern, searchPattern, searchPattern,
-	).Order("lot_name").Limit(limit).Find(&components).Error
-
-	return components, err
-}
-
-// SearchLocalComponentsByCategory searches components by category and optional query
-func (l *LocalDB) SearchLocalComponentsByCategory(category string, query string, limit int) ([]LocalComponent, error) {
-	if limit <= 0 {
-		limit = 50
-	}
-
-	var components []LocalComponent
-	db := l.db.Where("LOWER(category) = ?", strings.ToLower(category))
-
-	if query != "" {
-		searchPattern := "%" + strings.ToLower(query) + "%"
-		db = db.Where(
-			"LOWER(lot_name) LIKE ? OR LOWER(lot_description) LIKE ? OR LOWER(model) LIKE ?",
-			searchPattern, searchPattern, searchPattern,
-		)
-	}
-
-	err := db.Order("lot_name").Limit(limit).Find(&components).Error
-	return components, err
-}
-
-// ListComponents returns components with filtering and pagination
-func (l *LocalDB) ListComponents(filter ComponentFilter, offset, limit int) ([]LocalComponent, int64, error) {
-	db := l.db
-
-	// Apply category filter
-	if filter.Category != "" {
-		db = db.Where("LOWER(category) = ?", strings.ToLower(filter.Category))
-	}
-
-	// Apply search filter
-	if filter.Search != "" {
-		searchPattern := "%" + strings.ToLower(filter.Search) + "%"
-		db = db.Where(
-			"LOWER(lot_name) LIKE ? OR LOWER(lot_description) LIKE ? OR LOWER(category) LIKE ? OR LOWER(model) LIKE ?",
-			searchPattern, searchPattern, searchPattern, searchPattern,
-		)
-	}
-
-	// Get total count
-	var total int64
-	if err := db.Model(&LocalComponent{}).Count(&total).Error; err != nil {
-		return nil, 0, err
-	}
-
-	// Apply pagination and get results
-	var components []LocalComponent
-	if err := db.Order("lot_name").Offset(offset).Limit(limit).Find(&components).Error; err != nil {
-		return nil, 0, err
-	}
-
-	return components, total, nil
-}
-
-// GetLocalComponent returns a single component by lot_name
-func (l *LocalDB) GetLocalComponent(lotName string) (*LocalComponent, error) {
-	var component LocalComponent
-	err := l.db.Where("lot_name = ?", lotName).First(&component).Error
 	if err != nil {
 		return nil, err
 	}
-	return &component, nil
+
+	db := l.db.Table("local_pricelist_items").
+		Where("pricelist_id = ?", pricelistID)
+	if query != "" {
+		db = db.Where("LOWER(lot_name) LIKE ?", "%"+strings.ToLower(query)+"%")
+	}
+
+	var rows []pricelistItemRow
+	if err := db.Select("lot_name, lot_category").Order("lot_name").Limit(limit).Scan(&rows).Error; err != nil {
+		return nil, err
+	}
+	components := make([]LocalComponent, len(rows))
+	for i, r := range rows {
+		components[i] = r.toLocalComponent()
+	}
+	return components, nil
 }
 
-// GetLocalComponentCategoriesByLotNames returns category for each lot_name in the local component cache.
+// SearchLocalComponentsByCategory searches components in the latest active
-// Missing lots are not included in the map; caller is responsible for strict validation.
+// estimate pricelist filtered by category.
+func (l *LocalDB) SearchLocalComponentsByCategory(category, query string, limit int) ([]LocalComponent, error) {
+	if limit <= 0 {
+		limit = 50
+	}
+	pricelistID, err := l.latestActivePricelistID("estimate")
+	if err != nil {
+		return nil, err
+	}
+
+	db := l.db.Table("local_pricelist_items").
+		Where("pricelist_id = ? AND UPPER(lot_category) = ?", pricelistID, strings.ToUpper(category))
+	if query != "" {
+		db = db.Where("LOWER(lot_name) LIKE ?", "%"+strings.ToLower(query)+"%")
+	}
+
+	var rows []pricelistItemRow
+	if err := db.Select("lot_name, lot_category").Order("lot_name").Limit(limit).Scan(&rows).Error; err != nil {
+		return nil, err
+	}
+	components := make([]LocalComponent, len(rows))
+	for i, r := range rows {
+		components[i] = r.toLocalComponent()
+	}
+	return components, nil
+}
+
+// ListComponents returns components from the latest active estimate pricelist
+// with optional category/search filtering and pagination.
+func (l *LocalDB) ListComponents(filter ComponentFilter, offset, limit int) ([]LocalComponent, int64, error) {
+	pricelistID, err := l.latestActivePricelistID("estimate")
+	if err != nil {
+		return nil, 0, err
+	}
+
+	db := l.db.Table("local_pricelist_items").
+		Where("pricelist_id = ?", pricelistID)
+
+	if filter.Category != "" {
+		db = db.Where("UPPER(lot_category) = ?", strings.ToUpper(filter.Category))
+	}
+	if filter.Search != "" {
+		db = db.Where("LOWER(lot_name) LIKE ?", "%"+strings.ToLower(filter.Search)+"%")
+	}
+
+	var total int64
+	if err := db.Count(&total).Error; err != nil {
+		return nil, 0, err
+	}
+
+	var rows []pricelistItemRow
+	if err := db.Select("lot_name, lot_category").Order("lot_name").Offset(offset).Limit(limit).Scan(&rows).Error; err != nil {
+		return nil, 0, err
+	}
+	components := make([]LocalComponent, len(rows))
+	for i, r := range rows {
+		components[i] = r.toLocalComponent()
+	}
+	return components, total, nil
+}
+
+// GetLocalComponent returns a single component by lot_name from the latest
+// active estimate pricelist.
+func (l *LocalDB) GetLocalComponent(lotName string) (*LocalComponent, error) {
+	pricelistID, err := l.latestActivePricelistID("estimate")
+	if err != nil {
+		return nil, err
+	}
+
+	var row pricelistItemRow
+	if err := l.db.Table("local_pricelist_items").
+		Select("lot_name, lot_category").
+		Where("pricelist_id = ? AND UPPER(lot_name) = ?", pricelistID, strings.ToUpper(lotName)).
+		First(&row).Error; err != nil {
+		return nil, err
+	}
+	c := row.toLocalComponent()
+	return &c, nil
+}
+
+// GetLocalComponentCategoriesByLotNames returns category for each lot_name
+// from the latest active estimate pricelist.
 func (l *LocalDB) GetLocalComponentCategoriesByLotNames(lotNames []string) (map[string]string, error) {
 	result := make(map[string]string, len(lotNames))
 	if len(lotNames) == 0 {
 		return result, nil
 	}
-
+	pricelistID, err := l.latestActivePricelistID("estimate")
-	type row struct {
+	if err != nil {
-		LotName  string `gorm:"column:lot_name"`
+		return result, nil
-		Category string `gorm:"column:category"`
 	}
-	var rows []row
+
-	if err := l.db.Model(&LocalComponent{}).
+	// Build uppercase → original mapping so result keys match what the caller passed.
-		Select("lot_name, category").
+	upperToOrig := make(map[string]string, len(lotNames))
-		Where("lot_name IN ?", lotNames).
+	upper := make([]string, len(lotNames))
-		Find(&rows).Error; err != nil {
+	for i, n := range lotNames {
+		u := strings.ToUpper(n)
+		upper[i] = u
+		upperToOrig[u] = n
+	}
+	var rows []pricelistItemRow
+	if err := l.db.Table("local_pricelist_items").
+		Select("lot_name, lot_category").
+		Where("pricelist_id = ? AND UPPER(lot_name) IN ?", pricelistID, upper).
+		Scan(&rows).Error; err != nil {
 		return nil, err
 	}
 	for _, r := range rows {
-		result[r.LotName] = r.Category
+		orig := upperToOrig[strings.ToUpper(r.LotName)]
+		if orig == "" {
+			orig = r.LotName
+		}
+		result[orig] = r.Category
 	}
 	return result, nil
 }
 
-// GetLocalComponentCategories returns distinct categories from local components
+// GetLocalComponentCategories returns distinct categories from the latest
+// active estimate pricelist.
 func (l *LocalDB) GetLocalComponentCategories() ([]string, error) {
-	var categories []string
+	pricelistID, err := l.latestActivePricelistID("estimate")
-	err := l.db.Model(&LocalComponent{}).
-		Distinct("category").
-		Where("category != ''").
-		Order("category").
-		Pluck("category", &categories).Error
-	return categories, err
-}
-
-// CountLocalComponents returns the total number of local components
-func (l *LocalDB) CountLocalComponents() int64 {
-	var count int64
-	l.db.Model(&LocalComponent{}).Count(&count)
-	return count
-}
-
-// CountLocalComponentsByCategory returns component count by category
-func (l *LocalDB) CountLocalComponentsByCategory(category string) int64 {
-	var count int64
-	l.db.Model(&LocalComponent{}).Where("LOWER(category) = ?", strings.ToLower(category)).Count(&count)
-	return count
-}
-
-// GetComponentSyncTime returns the last component sync timestamp
-func (l *LocalDB) GetComponentSyncTime() *time.Time {
-	var setting struct {
-		Value string
-	}
-	if err := l.db.Table("app_settings").
-		Where("key = ?", "last_component_sync").
-		First(&setting).Error; err != nil {
-		return nil
-	}
-
-	t, err := time.Parse(time.RFC3339, setting.Value)
 	if err != nil {
-		return nil
+		return nil, err
 	}
-	return &t
+
+	var categories []string
+	if err := l.db.Table("local_pricelist_items").
+		Where("pricelist_id = ? AND lot_category != ''", pricelistID).
+		Distinct("lot_category").
+		Order("lot_category").
+		Pluck("lot_category", &categories).Error; err != nil {
+		return nil, err
+	}
+	return categories, nil
 }
 
-// SetComponentSyncTime sets the last component sync timestamp
+// CountComponents returns the number of distinct lot names in the latest
-func (l *LocalDB) SetComponentSyncTime(t time.Time) error {
+// active estimate pricelist (used to check if data is available).
-	return l.db.Exec(`
+func (l *LocalDB) CountComponents() int64 {
-		INSERT INTO app_settings (key, value, updated_at)
+	pricelistID, err := l.latestActivePricelistID("estimate")
-		VALUES (?, ?, ?)
+	if err != nil {
-		ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at
+		return 0
-	`, "last_component_sync", t.Format(time.RFC3339), time.Now().Format(time.RFC3339)).Error
+	}
+	var count int64
+	l.db.Table("local_pricelist_items").Where("pricelist_id = ?", pricelistID).Count(&count)
+	return count
 }
 
-// NeedComponentSync checks if component sync is needed (older than specified hours)
-func (l *LocalDB) NeedComponentSync(maxAgeHours int) bool {
-	syncTime := l.GetComponentSyncTime()
-	if syncTime == nil {
-		return true
-	}
-	return time.Since(*syncTime).Hours() > float64(maxAgeHours)
-}

internal/localdb/converters.go

@@ -11,7 +11,7 @@ func ConfigurationToLocal(cfg *models.Configuration) *LocalConfiguration {
 	items := make(LocalConfigItems, len(cfg.Items))
 	for i, item := range cfg.Items {
 		items[i] = LocalConfigItem{
-			LotName:   item.LotName,
+			LotName:   models.NormalizeLotName(item.LotName),
 			Quantity:  item.Quantity,
 			UnitPrice: item.UnitPrice,
 		}
@@ -271,7 +271,7 @@ func PricelistItemToLocal(item *models.PricelistItem, localPricelistID uint) *Lo
 	partnumbers = append(partnumbers, item.Partnumbers...)
 	return &LocalPricelistItem{
 		PricelistID:  localPricelistID,
-		LotName:      item.LotName,
+		LotName:      models.NormalizeLotName(item.LotName),
 		LotCategory:  item.LotCategory,
 		Price:        item.Price,
 		AvailableQty: item.AvailableQty,
@@ -294,33 +294,6 @@ func LocalToPricelistItem(local *LocalPricelistItem, serverPricelistID uint) *mo
 	}
 }
 
-// ComponentToLocal converts models.LotMetadata to LocalComponent
-func ComponentToLocal(meta *models.LotMetadata) *LocalComponent {
-	var lotDesc string
-	var category string
-
-	if meta.Lot != nil {
-		lotDesc = meta.Lot.LotDescription
-	}
-
-	// Extract category from lot_name (e.g., "CPU_AMD_9654" -> "CPU")
-	if len(meta.LotName) > 0 {
-		for i, ch := range meta.LotName {
-			if ch == '_' {
-				category = meta.LotName[:i]
-				break
-			}
-		}
-	}
-
-	return &LocalComponent{
-		LotName:        meta.LotName,
-		LotDescription: lotDesc,
-		Category:       category,
-		Model:          meta.Model,
-	}
-}
-
 // LocalToComponent converts LocalComponent to models.LotMetadata
 func LocalToComponent(local *LocalComponent) *models.LotMetadata {
 	return &models.LotMetadata{

internal/localdb/localdb.go

@@ -46,7 +46,6 @@ type LocalDB struct {
 var localReadOnlyCacheTables = []string{
 	"local_pricelist_items",
 	"local_pricelists",
-	"local_components",
 	"local_partnumber_book_items",
 	"local_partnumber_books",
 }
@@ -78,7 +77,6 @@ func ResetData(dbPath string) error {
 		"local_configuration_versions",
 		"local_pricelists",
 		"local_pricelist_items",
-		"local_components",
 		"local_sync_guard_state",
 		"pending_changes",
 		"app_settings",
@@ -224,7 +222,6 @@ func autoMigrateLocalSchema(db *gorm.DB) error {
 		&LocalConfigurationVersion{},
 		&LocalPricelist{},
 		&LocalPricelistItem{},
-		&LocalComponent{},
 		&AppSetting{},
 		&LocalSyncGuardState{},
 		&PendingChange{},
@@ -1237,25 +1234,6 @@ func (l *LocalDB) GetLastComponentSyncError() string {
 	return strings.TrimSpace(value)
 }
 
-func (l *LocalDB) SetComponentSyncResult(status, errorText string, attemptedAt time.Time) error {
-	status = strings.TrimSpace(status)
-	errorText = strings.TrimSpace(errorText)
-	if status == "" {
-		status = "unknown"
-	}
-	return l.db.Transaction(func(tx *gorm.DB) error {
-		if err := l.upsertAppSetting(tx, "last_component_sync_status", status, attemptedAt); err != nil {
-			return err
-		}
-		if err := l.upsertAppSetting(tx, "last_component_sync_error", errorText, attemptedAt); err != nil {
-			return err
-		}
-		if err := l.upsertAppSetting(tx, "last_component_sync_attempt_at", attemptedAt.Format(time.RFC3339), attemptedAt); err != nil {
-			return err
-		}
-		return nil
-	})
-}
 
 // CountLocalPricelists returns the number of local pricelists
 func (l *LocalDB) CountLocalPricelists() int64 {
@@ -1271,11 +1249,10 @@ func (l *LocalDB) CountAllPricelistItems() int64 {
 	return count
 }
 
-// CountComponents returns the number of rows in local_components.
+
-func (l *LocalDB) CountComponents() int64 {
+// DBFilePath returns the path to the SQLite database file.
-	var count int64
+func (l *LocalDB) DBFilePath() string {
-	l.db.Model(&LocalComponent{}).Count(&count)
+	return l.path
-	return count
 }
 
 // DBFileSizeBytes returns the size of the SQLite database file in bytes.
@@ -1287,11 +1264,11 @@ func (l *LocalDB) DBFileSizeBytes() int64 {
 	return info.Size()
 }
 
-// GetLatestLocalPricelist returns the most recently synced pricelist
+// GetLatestLocalPricelist returns the most recently synced active estimate pricelist.
 func (l *LocalDB) GetLatestLocalPricelist() (*LocalPricelist, error) {
 	var pricelist LocalPricelist
 	if err := l.db.
-		Where("source = ?", "estimate").
+		Where("source = ? AND is_active = ?", "estimate", true).
 		Where("EXISTS (SELECT 1 FROM local_pricelist_items WHERE local_pricelist_items.pricelist_id = local_pricelists.id)").
 		Order("created_at DESC, id DESC").
 		First(&pricelist).Error; err != nil {
@@ -1300,11 +1277,11 @@ func (l *LocalDB) GetLatestLocalPricelist() (*LocalPricelist, error) {
 	return &pricelist, nil
 }
 
-// GetLatestLocalPricelistBySource returns the most recently synced pricelist for a source.
+// GetLatestLocalPricelistBySource returns the most recently synced active pricelist for a source.
 func (l *LocalDB) GetLatestLocalPricelistBySource(source string) (*LocalPricelist, error) {
 	var pricelist LocalPricelist
 	if err := l.db.
-		Where("source = ?", source).
+		Where("source = ? AND is_active = ?", source, true).
 		Where("EXISTS (SELECT 1 FROM local_pricelist_items WHERE local_pricelist_items.pricelist_id = local_pricelists.id)").
 		Order("created_at DESC, id DESC").
 		First(&pricelist).Error; err != nil {
@@ -1313,6 +1290,17 @@ func (l *LocalDB) GetLatestLocalPricelistBySource(source string) (*LocalPricelis
 	return &pricelist, nil
 }
 
+// DeactivateLocalPricelistsNotIn marks all local pricelists with is_active=true whose
+// server_id is not in activeServerIDs as inactive. Used after each pricelist sync to
+// mirror server-side deactivations locally.
+func (l *LocalDB) DeactivateLocalPricelistsNotIn(activeServerIDs []uint) error {
+	q := l.db.Model(&LocalPricelist{}).Where("is_active = ?", true)
+	if len(activeServerIDs) > 0 {
+		q = q.Where("server_id NOT IN ?", activeServerIDs)
+	}
+	return q.Update("is_active", false).Error
+}
+
 // GetLocalPricelistByServerID returns a local pricelist by its server ID
 func (l *LocalDB) GetLocalPricelistByServerID(serverID uint) (*LocalPricelist, error) {
 	var pricelist LocalPricelist
@@ -1380,6 +1368,30 @@ func (l *LocalDB) CountLocalPricelistItems(pricelistID uint) int64 {
 	return count
 }
 
+// GetLocalPricelistCoverageByCategory returns item count per lot_category and the total
+// for the given local pricelist ID. Only items with price > 0 are counted.
+func (l *LocalDB) GetLocalPricelistCoverageByCategory(pricelistID uint) (map[string]int64, int64, error) {
+	type row struct {
+		Category string `gorm:"column:lot_category"`
+		Count    int64  `gorm:"column:cnt"`
+	}
+	var rows []row
+	if err := l.db.Model(&LocalPricelistItem{}).
+		Select("COALESCE(NULLIF(TRIM(lot_category),''), '?') AS lot_category, COUNT(*) AS cnt").
+		Where("pricelist_id = ? AND price > 0", pricelistID).
+		Group("lot_category").
+		Scan(&rows).Error; err != nil {
+		return nil, 0, err
+	}
+	result := make(map[string]int64, len(rows))
+	var total int64
+	for _, r := range rows {
+		result[r.Category] = r.Count
+		total += r.Count
+	}
+	return result, total, nil
+}
+
 // CountLocalPricelistItemsWithEmptyCategory returns the number of items for a pricelist with missing lot_category.
 func (l *LocalDB) CountLocalPricelistItemsWithEmptyCategory(pricelistID uint) (int64, error) {
 	var count int64
@@ -1444,10 +1456,11 @@ func (l *LocalDB) GetLocalPricelistItems(pricelistID uint) ([]LocalPricelistItem
 	return items, nil
 }
 
-// GetLocalPriceForLot returns the price for a lot from a local pricelist
+// GetLocalPriceForLot returns the price for a lot from a local pricelist.
+// Matching is case-insensitive via UPPER(lot_name) to handle legacy mixed-case rows.
 func (l *LocalDB) GetLocalPriceForLot(pricelistID uint, lotName string) (float64, error) {
 	var item LocalPricelistItem
-	if err := l.db.Where("pricelist_id = ? AND lot_name = ?", pricelistID, lotName).
+	if err := l.db.Where("pricelist_id = ? AND UPPER(lot_name) = ?", pricelistID, strings.ToUpper(lotName)).
 		First(&item).Error; err != nil {
 		return 0, err
 	}
@@ -1455,26 +1468,32 @@ func (l *LocalDB) GetLocalPriceForLot(pricelistID uint, lotName string) (float64
 }
 
 // GetLocalPricesForLots returns prices for multiple lots from a local pricelist in a single query.
-// Uses the composite index (pricelist_id, lot_name). Missing lots are omitted from the result.
+// Missing lots are omitted from the result.
+// lotNames must already be normalized (uppercased); matching is done via UPPER(lot_name) to handle
+// legacy rows that were stored in mixed case before normalization was enforced at sync time.
+// Keys in the returned map are uppercased (matching the input lotNames).
 func (l *LocalDB) GetLocalPricesForLots(pricelistID uint, lotNames []string) (map[string]float64, error) {
 	result := make(map[string]float64, len(lotNames))
 	if len(lotNames) == 0 {
 		return result, nil
 	}
+
 	type row struct {
 		LotName string  `gorm:"column:lot_name"`
 		Price   float64 `gorm:"column:price"`
 	}
 	var rows []row
+	// Use UPPER(lot_name) so rows synced before normalization (mixed-case) are still matched.
 	if err := l.db.Model(&LocalPricelistItem{}).
 		Select("lot_name, price").
-		Where("pricelist_id = ? AND lot_name IN ?", pricelistID, lotNames).
+		Where("pricelist_id = ? AND UPPER(lot_name) IN ?", pricelistID, lotNames).
 		Find(&rows).Error; err != nil {
 		return nil, err
 	}
 	for _, r := range rows {
 		if r.Price > 0 {
-			result[r.LotName] = r.Price
+			// Key must be uppercase to match callers that normalise lot names before lookup.
+			result[strings.ToUpper(r.LotName)] = r.Price
 		}
 	}
 	return result, nil
@@ -1497,15 +1516,27 @@ func (l *LocalDB) GetLocalLotCategoriesByServerPricelistID(serverPricelistID uin
 		LotName     string `gorm:"column:lot_name"`
 		LotCategory string `gorm:"column:lot_category"`
 	}
+	// Build uppercase → original mapping so result keys match what the caller passed.
+	upperToOrig := make(map[string]string, len(lotNames))
+	upper := make([]string, len(lotNames))
+	for i, n := range lotNames {
+		u := strings.ToUpper(n)
+		upper[i] = u
+		upperToOrig[u] = n
+	}
 	var rows []row
 	if err := l.db.Model(&LocalPricelistItem{}).
 		Select("lot_name, lot_category").
-		Where("pricelist_id = ? AND lot_name IN ?", localPL.ID, lotNames).
+		Where("pricelist_id = ? AND UPPER(lot_name) IN ?", localPL.ID, upper).
 		Find(&rows).Error; err != nil {
 		return nil, err
 	}
 	for _, r := range rows {
-		result[r.LotName] = r.LotCategory
+		orig := upperToOrig[strings.ToUpper(r.LotName)]
+		if orig == "" {
+			orig = r.LotName
+		}
+		result[orig] = r.LotCategory
 	}
 	return result, nil
 }
@@ -1689,12 +1720,13 @@ func (l *LocalDB) RepairPendingChanges() (int, []string, error) {
 	var remainingErrors []string
 
 	for _, change := range erroredChanges {
+		var modified bool
 		var repairErr error
 		switch change.EntityType {
 		case "project":
-			repairErr = l.repairProjectChange(&change)
+			modified, repairErr = l.repairProjectChange(&change)
 		case "configuration":
-			repairErr = l.repairConfigurationChange(&change)
+			modified, repairErr = l.repairConfigurationChange(&change)
 		default:
 			repairErr = fmt.Errorf("unknown entity type: %s", change.EntityType)
 		}
@@ -1705,7 +1737,13 @@ func (l *LocalDB) RepairPendingChanges() (int, []string, error) {
 			continue
 		}
 
-		// Clear error and reset attempts
+		// Only reset attempts when the repair actually changed local data.
+		// If nothing was modified, the error is server-side; leaving attempts
+		// intact lets maxPendingChangeAttempts eventually abandon the change.
+		if !modified {
+			continue
+		}
+
 		if err := l.db.Model(&PendingChange{}).Where("id = ?", change.ID).Updates(map[string]interface{}{
 			"last_error": "",
 			"attempts":   0,
@@ -1721,12 +1759,13 @@ func (l *LocalDB) RepairPendingChanges() (int, []string, error) {
 }
 
 // repairProjectChange validates and fixes project data.
+// Returns (modified, err): modified=true only when local data was actually changed.
 // Note: This only validates local data. Server-side conflicts (like duplicate code+variant)
 // are handled by sync service layer with deduplication logic.
-func (l *LocalDB) repairProjectChange(change *PendingChange) error {
+func (l *LocalDB) repairProjectChange(change *PendingChange) (bool, error) {
 	project, err := l.GetProjectByUUID(change.EntityUUID)
 	if err != nil {
-		return fmt.Errorf("project not found locally: %w", err)
+		return false, fmt.Errorf("project not found locally: %w", err)
 	}
 
 	modified := false
@@ -1752,7 +1791,7 @@ func (l *LocalDB) repairProjectChange(change *PendingChange) error {
 	if strings.TrimSpace(project.OwnerUsername) == "" {
 		project.OwnerUsername = l.GetDBUser()
 		if project.OwnerUsername == "" {
-			return fmt.Errorf("cannot determine owner username")
+			return false, fmt.Errorf("cannot determine owner username")
 		}
 		modified = true
 	}
@@ -1773,18 +1812,19 @@ func (l *LocalDB) repairProjectChange(change *PendingChange) error {
 
 	if modified {
 		if err := l.SaveProject(project); err != nil {
-			return fmt.Errorf("saving repaired project: %w", err)
+			return false, fmt.Errorf("saving repaired project: %w", err)
 		}
 	}
 
-	return nil
+	return modified, nil
 }
 
-// repairConfigurationChange validates and fixes configuration data
+// repairConfigurationChange validates and fixes configuration data.
-func (l *LocalDB) repairConfigurationChange(change *PendingChange) error {
+// Returns (modified, err): modified=true only when local data was actually changed.
+func (l *LocalDB) repairConfigurationChange(change *PendingChange) (bool, error) {
 	config, err := l.GetConfigurationByUUID(change.EntityUUID)
 	if err != nil {
-		return fmt.Errorf("configuration not found locally: %w", err)
+		return false, fmt.Errorf("configuration not found locally: %w", err)
 	}
 
 	modified := false
@@ -1796,7 +1836,7 @@ func (l *LocalDB) repairConfigurationChange(change *PendingChange) error {
 			// Project doesn't exist locally - use default system project
 			systemProject, sysErr := l.EnsureDefaultProject(config.OriginalUsername)
 			if sysErr != nil {
-				return fmt.Errorf("getting system project: %w", sysErr)
+				return false, fmt.Errorf("getting system project: %w", sysErr)
 			}
 			config.ProjectUUID = &systemProject.UUID
 			modified = true
@@ -1805,11 +1845,11 @@ func (l *LocalDB) repairConfigurationChange(change *PendingChange) error {
 
 	if modified {
 		if err := l.SaveConfiguration(config); err != nil {
-			return fmt.Errorf("saving repaired configuration: %w", err)
+			return false, fmt.Errorf("saving repaired configuration: %w", err)
 		}
 	}
 
-	return nil
+	return modified, nil
 }
 
 // GetSyncGuardState returns the latest readiness guard state.
@@ -1871,28 +1911,6 @@ func (l *LocalDB) GetLocalPricelistItemsPage(pricelistID uint, search string, pa
 	return items, total, nil
 }
 
-// GetLocalComponentDescriptionsByLotNames returns a map of lot_name → lot_description for the given lots.
-func (l *LocalDB) GetLocalComponentDescriptionsByLotNames(lotNames []string) (map[string]string, error) {
-	if len(lotNames) == 0 {
-		return map[string]string{}, nil
-	}
-	type row struct {
-		LotName        string
-		LotDescription string
-	}
-	var rows []row
-	if err := l.db.Table("local_components").
-		Select("lot_name, lot_description").
-		Where("lot_name IN ?", lotNames).
-		Scan(&rows).Error; err != nil {
-		return nil, fmt.Errorf("fetch component descriptions: %w", err)
-	}
-	m := make(map[string]string, len(rows))
-	for _, r := range rows {
-		m[r.LotName] = r.LotDescription
-	}
-	return m, nil
-}
 
 // GetSchemaMigrations returns all applied local schema migrations ordered by applied_at.
 func (l *LocalDB) GetSchemaMigrations() ([]LocalSchemaMigration, error) {

internal/localdb/migrations.go

@@ -1120,3 +1120,4 @@ func deduplicatePricelistItemsAndAddUniqueIndex(tx *gorm.DB) error {
 	slog.Info("deduplicated local_pricelist_items and added unique index")
 	return nil
 }
+

internal/localdb/models.go

@@ -5,6 +5,8 @@ import (
 	"encoding/json"
 	"errors"
 	"time"
+
+	"git.mchus.pro/mchus/quoteforge/internal/models"
 )
 
 // AppSetting stores application settings in local SQLite
@@ -46,7 +48,13 @@ func (c *LocalConfigItems) Scan(value interface{}) error {
 	default:
 		return errors.New("type assertion failed for LocalConfigItems")
 	}
-	return json.Unmarshal(bytes, c)
+	if err := json.Unmarshal(bytes, c); err != nil {
+		return err
+	}
+	for i := range *c {
+		(*c)[i].LotName = models.NormalizeLotName((*c)[i].LotName)
+	}
+	return nil
 }
 
 func (c LocalConfigItems) Total() float64 {
@@ -169,7 +177,8 @@ type LocalPricelist struct {
 	Name      string    `json:"name"`
 	CreatedAt time.Time `gorm:"index:idx_local_pricelists_source_created_at,priority:2,sort:desc" json:"created_at"`
 	SyncedAt  time.Time `json:"synced_at"`
-	IsUsed    bool      `gorm:"default:false" json:"is_used"` // Used by any local configuration
+	IsUsed    bool      `gorm:"default:false" json:"is_used"`   // Used by any local configuration
+	IsActive  bool      `gorm:"not null;default:true;index" json:"is_active"` // Mirrors qt_pricelists.is_active
 }
 
 func (LocalPricelist) TableName() string {

internal/localdb/qt_settings.go

@@ -42,25 +42,29 @@ type ConfiguratorSettings struct {
 }
 
 // SyncQtSettings reads all rows from qt_settings on MariaDB and replaces the
-// local_qt_settings cache in a single SQLite transaction. Returns an error if
+// local_qt_settings cache in a single SQLite transaction.
-// the qt_settings table doesn't exist on the server (old server without the
+// If the read fails (no connection, table missing on old server) or the server
-// table) or on any query/write failure.
+// returns an empty table, the existing local_qt_settings are preserved so the
+// configurator keeps working offline or against old server versions.
 func (l *LocalDB) SyncQtSettings(mariaDB *gorm.DB) error {
 	var rows []LocalQtSetting
 	if err := mariaDB.
 		Table("qt_settings").
 		Select("name, value").
 		Find(&rows).Error; err != nil {
+		slog.Warn("qt_settings: read from MariaDB failed, keeping existing local cache", "error", err)
 		return fmt.Errorf("reading qt_settings from MariaDB: %w", err)
 	}
 
+	if len(rows) == 0 {
+		slog.Warn("qt_settings: server returned empty table, keeping existing local cache")
+		return nil
+	}
+
 	return l.db.Transaction(func(tx *gorm.DB) error {
 		if err := tx.Exec("DELETE FROM local_qt_settings").Error; err != nil {
 			return fmt.Errorf("clearing local_qt_settings: %w", err)
 		}
-		if len(rows) == 0 {
-			return nil
-		}
 		if err := tx.Create(&rows).Error; err != nil {
 			return fmt.Errorf("inserting local_qt_settings: %w", err)
 		}

internal/models/lot.go

@@ -1,5 +1,13 @@
 package models
 
+import "strings"
+
+// NormalizeLotName returns the canonical form of a lot name: trimmed and uppercased.
+// Apply at every point where a lot name enters the system (sync, API input, config load).
+func NormalizeLotName(s string) string {
+	return strings.ToUpper(strings.TrimSpace(s))
+}
+
 // Lot represents existing lot table
 type Lot struct {
 	LotName        string  `gorm:"column:lot_name;primaryKey;size:255" json:"lot_name"`

internal/repository/category.go

@@ -1,76 +0,0 @@
-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
-}

internal/repository/component.go

@@ -1,140 +0,0 @@
-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)
-	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) DB() *gorm.DB {
-	return r.db
-}
-
-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
-}

internal/repository/pricelist.go

@@ -269,12 +269,21 @@ func (r *PricelistRepository) GetPriceForLot(pricelistID uint, lotName string) (
 }
 
 // GetPricesForLots returns price map for given lots within a pricelist.
+// Keys in the returned map match the requested lot names (case-preserving) so that
+// callers using Go map lookups are not confused by case differences between the
+// requested name and the stored value (e.g. pricelist renamed lots to UPPERCASE).
 func (r *PricelistRepository) GetPricesForLots(pricelistID uint, lotNames []string) (map[string]float64, error) {
 	result := make(map[string]float64, len(lotNames))
 	if pricelistID == 0 || len(lotNames) == 0 {
 		return result, nil
 	}
 
+	// Build case-insensitive index: lowercase → original requested name.
+	lotIndex := make(map[string]string, len(lotNames))
+	for _, n := range lotNames {
+		lotIndex[strings.ToLower(n)] = n
+	}
+
 	var rows []models.PricelistItem
 	if err := r.db.Select("lot_name, price").
 		Where("pricelist_id = ? AND lot_name IN ?", pricelistID, lotNames).
@@ -284,7 +293,11 @@ func (r *PricelistRepository) GetPricesForLots(pricelistID uint, lotNames []stri
 
 	for _, row := range rows {
 		if row.Price > 0 {
-			result[row.LotName] = row.Price
+			key := row.LotName
+			if requested, ok := lotIndex[strings.ToLower(row.LotName)]; ok {
+				key = requested
+			}
+			result[key] = row.Price
 		}
 	}
 	return result, nil

internal/repository/project.go

@@ -23,6 +23,11 @@ func (r *ProjectRepository) Update(project *models.Project) error {
 }
 
 func (r *ProjectRepository) UpsertByUUID(project *models.Project) error {
+	// Clear the client-side primary key so the upsert is driven purely by the
+	// uuid unique constraint. Passing a non-zero ID can trigger ON DUPLICATE KEY
+	// on the primary key of an unrelated row, leaving uuid unchanged and causing
+	// the follow-up SELECT to return ErrRecordNotFound.
+	project.ID = 0
 	if err := r.db.Clauses(clause.OnConflict{
 		Columns: []clause.Column{{Name: "uuid"}},
 		DoUpdates: clause.AssignmentColumns([]string{

internal/repository/unified.go

@@ -1,393 +0,0 @@
-package repository
-
-import (
-	"encoding/json"
-	"fmt"
-	"time"
-
-	"git.mchus.pro/mchus/quoteforge/internal/localdb"
-	"git.mchus.pro/mchus/quoteforge/internal/models"
-	"gorm.io/gorm"
-)
-
-// DataSource defines the unified interface for data access
-// It abstracts whether data comes from MariaDB (online) or SQLite (offline)
-type DataSource interface {
-	// Components
-	GetComponents(filter ComponentFilter, offset, limit int) ([]models.LotMetadata, int64, error)
-	GetComponent(lotName string) (*models.LotMetadata, error)
-
-	// Configurations
-	SaveConfiguration(cfg *models.Configuration) error
-	GetConfigurations(ownerUsername string) ([]models.Configuration, error)
-	GetConfigurationByUUID(uuid string) (*models.Configuration, error)
-	DeleteConfiguration(uuid string) error
-
-	// Pricelists (read-only in offline mode)
-	GetPricelists() ([]models.PricelistSummary, error)
-	GetPricelistByID(id uint) (*models.Pricelist, error)
-	GetPricelistItems(pricelistID uint) ([]models.PricelistItem, error)
-	GetLatestPricelist() (*models.Pricelist, error)
-}
-
-// UnifiedRepo implements DataSource with automatic online/offline switching
-type UnifiedRepo struct {
-	mariaDB  *gorm.DB
-	localDB  *localdb.LocalDB
-	isOnline bool
-}
-
-// NewUnifiedRepo creates a new unified repository
-func NewUnifiedRepo(mariaDB *gorm.DB, localDB *localdb.LocalDB, isOnline bool) *UnifiedRepo {
-	return &UnifiedRepo{
-		mariaDB:  mariaDB,
-		localDB:  localDB,
-		isOnline: isOnline,
-	}
-}
-
-// SetOnlineStatus updates the online/offline status
-func (r *UnifiedRepo) SetOnlineStatus(online bool) {
-	r.isOnline = online
-}
-
-// IsOnline returns the current online/offline status
-func (r *UnifiedRepo) IsOnline() bool {
-	return r.isOnline
-}
-
-// Component methods
-
-// GetComponents returns components from MariaDB (online) or local cache (offline)
-func (r *UnifiedRepo) GetComponents(filter ComponentFilter, offset, limit int) ([]models.LotMetadata, int64, error) {
-	if r.isOnline {
-		return r.getComponentsOnline(filter, offset, limit)
-	}
-	return r.getComponentsOffline(filter, offset, limit)
-}
-
-func (r *UnifiedRepo) getComponentsOnline(filter ComponentFilter, offset, limit int) ([]models.LotMetadata, int64, error) {
-	repo := NewComponentRepository(r.mariaDB)
-	return repo.List(filter, offset, limit)
-}
-
-func (r *UnifiedRepo) getComponentsOffline(filter ComponentFilter, offset, limit int) ([]models.LotMetadata, int64, error) {
-	var components []localdb.LocalComponent
-	query := r.localDB.DB().Model(&localdb.LocalComponent{})
-
-	// Apply filters
-	if filter.Category != "" {
-		query = query.Where("category = ?", filter.Category)
-	}
-	if filter.Search != "" {
-		search := "%" + filter.Search + "%"
-		query = query.Where("lot_name LIKE ? OR lot_description LIKE ? OR model LIKE ?", search, search, search)
-	}
-	var total int64
-	query.Count(&total)
-
-	// Apply sorting
-	sortDir := "ASC"
-	if filter.SortDir == "desc" {
-		sortDir = "DESC"
-	}
-	switch filter.SortField {
-	case "lot_name":
-		query = query.Order("lot_name " + sortDir)
-	default:
-		query = query.Order("lot_name ASC")
-	}
-
-	if err := query.Offset(offset).Limit(limit).Find(&components).Error; err != nil {
-		return nil, 0, fmt.Errorf("fetching offline components: %w", err)
-	}
-
-	// Convert to models.LotMetadata
-	result := make([]models.LotMetadata, len(components))
-	for i, comp := range components {
-		result[i] = models.LotMetadata{
-			LotName: comp.LotName,
-			Model:   comp.Model,
-			Lot: &models.Lot{
-				LotName:        comp.LotName,
-				LotDescription: comp.LotDescription,
-			},
-		}
-	}
-
-	return result, total, nil
-}
-
-// GetComponent returns a single component by lot name
-func (r *UnifiedRepo) GetComponent(lotName string) (*models.LotMetadata, error) {
-	if r.isOnline {
-		repo := NewComponentRepository(r.mariaDB)
-		return repo.GetByLotName(lotName)
-	}
-
-	var comp localdb.LocalComponent
-	if err := r.localDB.DB().Where("lot_name = ?", lotName).First(&comp).Error; err != nil {
-		return nil, fmt.Errorf("fetching offline component: %w", err)
-	}
-
-	return &models.LotMetadata{
-		LotName: comp.LotName,
-		Model:   comp.Model,
-		Lot: &models.Lot{
-			LotName:        comp.LotName,
-			LotDescription: comp.LotDescription,
-		},
-	}, nil
-}
-
-// Configuration methods
-
-// SaveConfiguration saves a configuration (online: MariaDB, offline: SQLite + pending_changes)
-func (r *UnifiedRepo) SaveConfiguration(cfg *models.Configuration) error {
-	if r.isOnline {
-		repo := NewConfigurationRepository(r.mariaDB)
-		return repo.Create(cfg)
-	}
-
-	// Offline: save to local SQLite and queue for sync
-	localCfg := &localdb.LocalConfiguration{
-		UUID:             cfg.UUID,
-		Name:             cfg.Name,
-		TotalPrice:       cfg.TotalPrice,
-		CustomPrice:      cfg.CustomPrice,
-		Notes:            cfg.Notes,
-		IsTemplate:       cfg.IsTemplate,
-		ServerCount:      cfg.ServerCount,
-		CreatedAt:        cfg.CreatedAt,
-		UpdatedAt:        time.Now(),
-		SyncStatus:       "pending",
-		OriginalUsername: cfg.OwnerUsername,
-	}
-
-	// Convert items
-	localItems := make(localdb.LocalConfigItems, len(cfg.Items))
-	for i, item := range cfg.Items {
-		localItems[i] = localdb.LocalConfigItem{
-			LotName:   item.LotName,
-			Quantity:  item.Quantity,
-			UnitPrice: item.UnitPrice,
-		}
-	}
-	localCfg.Items = localItems
-
-	if err := r.localDB.SaveConfiguration(localCfg); err != nil {
-		return fmt.Errorf("saving local configuration: %w", err)
-	}
-
-	// Add to pending changes queue
-	payload, err := json.Marshal(cfg)
-	if err != nil {
-		return fmt.Errorf("marshaling configuration for sync: %w", err)
-	}
-
-	return r.localDB.AddPendingChange("configuration", cfg.UUID, "create", string(payload))
-}
-
-// GetConfigurations returns all configurations for a user
-func (r *UnifiedRepo) GetConfigurations(ownerUsername string) ([]models.Configuration, error) {
-	if r.isOnline {
-		repo := NewConfigurationRepository(r.mariaDB)
-		configs, _, err := repo.ListByUser(ownerUsername, 0, 1000)
-		return configs, err
-	}
-
-	// Offline: get from local SQLite
-	localConfigs, err := r.localDB.GetConfigurations()
-	if err != nil {
-		return nil, fmt.Errorf("fetching local configurations: %w", err)
-	}
-
-	// Convert to models.Configuration
-	result := make([]models.Configuration, len(localConfigs))
-	for i, lc := range localConfigs {
-		items := make(models.ConfigItems, len(lc.Items))
-		for j, item := range lc.Items {
-			items[j] = models.ConfigItem{
-				LotName:   item.LotName,
-				Quantity:  item.Quantity,
-				UnitPrice: item.UnitPrice,
-			}
-		}
-
-		result[i] = models.Configuration{
-			UUID:          lc.UUID,
-			OwnerUsername: lc.OriginalUsername,
-			Name:          lc.Name,
-			Items:         items,
-			TotalPrice:    lc.TotalPrice,
-			CustomPrice:   lc.CustomPrice,
-			Notes:         lc.Notes,
-			IsTemplate:    lc.IsTemplate,
-			ServerCount:   lc.ServerCount,
-			CreatedAt:     lc.CreatedAt,
-		}
-	}
-
-	return result, nil
-}
-
-// GetConfigurationByUUID returns a configuration by UUID
-func (r *UnifiedRepo) GetConfigurationByUUID(uuid string) (*models.Configuration, error) {
-	if r.isOnline {
-		repo := NewConfigurationRepository(r.mariaDB)
-		return repo.GetByUUID(uuid)
-	}
-
-	localCfg, err := r.localDB.GetConfigurationByUUID(uuid)
-	if err != nil {
-		return nil, fmt.Errorf("fetching local configuration: %w", err)
-	}
-
-	items := make(models.ConfigItems, len(localCfg.Items))
-	for i, item := range localCfg.Items {
-		items[i] = models.ConfigItem{
-			LotName:   item.LotName,
-			Quantity:  item.Quantity,
-			UnitPrice: item.UnitPrice,
-		}
-	}
-
-	return &models.Configuration{
-		UUID:        localCfg.UUID,
-		Name:        localCfg.Name,
-		Items:       items,
-		TotalPrice:  localCfg.TotalPrice,
-		CustomPrice: localCfg.CustomPrice,
-		Notes:       localCfg.Notes,
-		IsTemplate:  localCfg.IsTemplate,
-		ServerCount: localCfg.ServerCount,
-		CreatedAt:   localCfg.CreatedAt,
-	}, nil
-}
-
-// DeleteConfiguration deletes a configuration
-func (r *UnifiedRepo) DeleteConfiguration(uuid string) error {
-	if r.isOnline {
-		// Get ID first
-		cfg, err := r.GetConfigurationByUUID(uuid)
-		if err != nil {
-			return err
-		}
-		repo := NewConfigurationRepository(r.mariaDB)
-		return repo.Delete(cfg.ID)
-	}
-
-	// Offline: delete from local and queue sync
-	if err := r.localDB.DeleteConfiguration(uuid); err != nil {
-		return fmt.Errorf("deleting local configuration: %w", err)
-	}
-
-	return r.localDB.AddPendingChange("configuration", uuid, "delete", "")
-}
-
-// Pricelist methods
-
-// GetPricelists returns all pricelists
-func (r *UnifiedRepo) GetPricelists() ([]models.PricelistSummary, error) {
-	if r.isOnline {
-		repo := NewPricelistRepository(r.mariaDB)
-		summaries, _, err := repo.List(0, 1000)
-		return summaries, err
-	}
-
-	// Offline: get from local cache
-	localPLs, err := r.localDB.GetLocalPricelists()
-	if err != nil {
-		return nil, fmt.Errorf("fetching local pricelists: %w", err)
-	}
-
-	summaries := make([]models.PricelistSummary, len(localPLs))
-	for i, pl := range localPLs {
-		itemCount := r.localDB.CountLocalPricelistItems(pl.ID)
-		summaries[i] = models.PricelistSummary{
-			ID:        pl.ServerID,
-			Version:   pl.Version,
-			CreatedAt: pl.CreatedAt,
-			ItemCount: itemCount,
-		}
-	}
-
-	return summaries, nil
-}
-
-// GetPricelistByID returns a pricelist by ID
-func (r *UnifiedRepo) GetPricelistByID(id uint) (*models.Pricelist, error) {
-	if r.isOnline {
-		repo := NewPricelistRepository(r.mariaDB)
-		return repo.GetByID(id)
-	}
-
-	// Offline: get from local cache
-	localPL, err := r.localDB.GetLocalPricelistByServerID(id)
-	if err != nil {
-		return nil, fmt.Errorf("fetching local pricelist: %w", err)
-	}
-
-	itemCount := r.localDB.CountLocalPricelistItems(localPL.ID)
-	return &models.Pricelist{
-		ID:        localPL.ServerID,
-		Version:   localPL.Version,
-		CreatedAt: localPL.CreatedAt,
-		ItemCount: int(itemCount),
-	}, nil
-}
-
-// GetPricelistItems returns items for a pricelist
-func (r *UnifiedRepo) GetPricelistItems(pricelistID uint) ([]models.PricelistItem, error) {
-	if r.isOnline {
-		repo := NewPricelistRepository(r.mariaDB)
-		items, _, err := repo.GetItems(pricelistID, 0, 100000, "")
-		return items, err
-	}
-
-	// Offline: get from local cache
-	// First find the local pricelist by server ID
-	localPL, err := r.localDB.GetLocalPricelistByServerID(pricelistID)
-	if err != nil {
-		return nil, fmt.Errorf("fetching local pricelist: %w", err)
-	}
-
-	localItems, err := r.localDB.GetLocalPricelistItems(localPL.ID)
-	if err != nil {
-		return nil, fmt.Errorf("fetching local pricelist items: %w", err)
-	}
-
-	items := make([]models.PricelistItem, len(localItems))
-	for i, item := range localItems {
-		items[i] = models.PricelistItem{
-			ID:          item.ID,
-			PricelistID: pricelistID,
-			LotName:     item.LotName,
-			Price:       item.Price,
-		}
-	}
-
-	return items, nil
-}
-
-// GetLatestPricelist returns the latest pricelist
-func (r *UnifiedRepo) GetLatestPricelist() (*models.Pricelist, error) {
-	if r.isOnline {
-		repo := NewPricelistRepository(r.mariaDB)
-		return repo.GetLatestActive()
-	}
-
-	// Offline: get from local cache
-	localPL, err := r.localDB.GetLatestLocalPricelist()
-	if err != nil {
-		return nil, fmt.Errorf("fetching latest local pricelist: %w", err)
-	}
-
-	itemCount := r.localDB.CountLocalPricelistItems(localPL.ID)
-	return &models.Pricelist{
-		ID:        localPL.ServerID,
-		Version:   localPL.Version,
-		CreatedAt: localPL.CreatedAt,
-		ItemCount: int(itemCount),
-	}, nil
-}

internal/services/component.go

@@ -1,43 +1,9 @@
 package services
 
 import (
-	"fmt"
-	"log/slog"
-	"strings"
-
 	"git.mchus.pro/mchus/quoteforge/internal/models"
-	"git.mchus.pro/mchus/quoteforge/internal/repository"
 )
 
-type ComponentService struct {
-	componentRepo *repository.ComponentRepository
-	categoryRepo  *repository.CategoryRepository
-}
-
-func NewComponentService(
-	componentRepo *repository.ComponentRepository,
-	categoryRepo *repository.CategoryRepository,
-) *ComponentService {
-	return &ComponentService{
-		componentRepo: componentRepo,
-		categoryRepo:  categoryRepo,
-	}
-}
-
-// 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 {
 	Items      []ComponentView `json:"items"`
 	TotalCount int64           `json:"total_count"`
@@ -56,169 +22,3 @@ type ComponentView struct {
 	PopularityScore float64               `json:"popularity_score"`
 	Specs           models.Specs          `json:"specs,omitempty"`
 }
-
-func (s *ComponentService) List(filter repository.ComponentFilter, page, perPage int) (*ComponentListResult, error) {
-	// If no database connection (offline mode), return empty list
-	// Components should be loaded via /api/sync/components first
-	if s.componentRepo == nil {
-		return &ComponentListResult{
-			Items:      []ComponentView{},
-			TotalCount: 0,
-			Page:       page,
-			PerPage:    perPage,
-			TotalPages: 1,
-		}, nil
-	}
-
-	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,
-			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
-	}
-
-	totalPages := int((total + int64(perPage) - 1) / int64(perPage))
-	if totalPages < 1 {
-		totalPages = 1
-	}
-	return &ComponentListResult{
-		Items:      views,
-		TotalCount: total,
-		Page:       page,
-		PerPage:    perPage,
-		TotalPages: totalPages,
-	}, nil
-}
-
-func (s *ComponentService) GetByLotName(lotName string) (*ComponentView, error) {
-	// If no database connection (offline mode), return error
-	if s.componentRepo == nil {
-		return nil, fmt.Errorf("offline mode: component data not available")
-	}
-
-	c, err := s.componentRepo.GetByLotName(lotName)
-	if err != nil {
-		return nil, err
-	}
-
-	// Track usage (best-effort)
-	if err := s.componentRepo.IncrementRequestCount(lotName); err != nil {
-		slog.Warn("component: could not increment request count", "lot", lotName, "err", err)
-	}
-
-	view := &ComponentView{
-		LotName:         c.LotName,
-		Model:           c.Model,
-		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) {
-	// If no database connection (offline mode), return default categories
-	if s.categoryRepo == nil {
-		return models.DefaultCategories, nil
-	}
-	return s.categoryRepo.GetAll()
-}
-
-// ImportFromLot creates metadata entries for lots that don't have them
-func (s *ComponentService) ImportFromLot() (int, error) {
-	// If no database connection (offline mode), return error
-	if s.componentRepo == nil || s.categoryRepo == nil {
-		return 0, fmt.Errorf("offline mode: import not available")
-	}
-
-	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
-}

internal/services/configuration.go

@@ -2,11 +2,8 @@ package services
 
 import (
 	"errors"
-	"time"
 
 	"git.mchus.pro/mchus/quoteforge/internal/models"
-	"git.mchus.pro/mchus/quoteforge/internal/repository"
-	"github.com/google/uuid"
 )
 
 var (
@@ -14,37 +11,13 @@ var (
 	ErrConfigForbidden = errors.New("access to configuration forbidden")
 )
 
-// ConfigurationGetter is an interface for services that can retrieve configurations
+// ConfigurationGetter is an interface for services that can retrieve configurations.
-// Used by handlers to work with both ConfigurationService and LocalConfigurationService
+// Used by handlers to work with LocalConfigurationService.
 type ConfigurationGetter interface {
 	GetByUUID(uuid string, ownerUsername string) (*models.Configuration, error)
 	GetByUUIDNoAuth(uuid string) (*models.Configuration, error)
 }
 
-type ConfigurationService struct {
-	configRepo    *repository.ConfigurationRepository
-	projectRepo   *repository.ProjectRepository
-	componentRepo *repository.ComponentRepository
-	pricelistRepo *repository.PricelistRepository
-	quoteService  *QuoteService
-}
-
-func NewConfigurationService(
-	configRepo *repository.ConfigurationRepository,
-	projectRepo *repository.ProjectRepository,
-	componentRepo *repository.ComponentRepository,
-	pricelistRepo *repository.PricelistRepository,
-	quoteService *QuoteService,
-) *ConfigurationService {
-	return &ConfigurationService{
-		configRepo:    configRepo,
-		projectRepo:   projectRepo,
-		componentRepo: componentRepo,
-		pricelistRepo: pricelistRepo,
-		quoteService:  quoteService,
-	}
-}
-
 type CreateConfigRequest struct {
 	Name                  string             `json:"name"`
 	Items                 models.ConfigItems `json:"items"`
@@ -70,583 +43,3 @@ type ArticlePreviewRequest struct {
 	SupportCode string             `json:"support_code,omitempty"`
 	PricelistID *uint              `json:"pricelist_id,omitempty"`
 }
-
-func (s *ConfigurationService) Create(ownerUsername string, req *CreateConfigRequest) (*models.Configuration, error) {
-	projectUUID, err := s.resolveProjectUUID(ownerUsername, req.ProjectUUID)
-	if err != nil {
-		return nil, err
-	}
-	pricelistID, err := s.resolvePricelistID(req.PricelistID)
-	if err != nil {
-		return nil, err
-	}
-
-	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(),
-		OwnerUsername:         ownerUsername,
-		ProjectUUID:           projectUUID,
-		Name:                  req.Name,
-		Items:                 req.Items,
-		TotalPrice:            &total,
-		CustomPrice:           req.CustomPrice,
-		Notes:                 req.Notes,
-		IsTemplate:            req.IsTemplate,
-		ServerCount:           req.ServerCount,
-		ServerModel:           req.ServerModel,
-		SupportCode:           req.SupportCode,
-		Article:               req.Article,
-		PricelistID:           pricelistID,
-		WarehousePricelistID:  req.WarehousePricelistID,
-		CompetitorPricelistID: req.CompetitorPricelistID,
-		ConfigType:            req.ConfigType,
-		DisablePriceRefresh:   req.DisablePriceRefresh,
-		OnlyInStock:           req.OnlyInStock,
-	}
-	if config.ConfigType == "" {
-		config.ConfigType = "server"
-	}
-
-	if err := s.configRepo.Create(config); err != nil {
-		return nil, err
-	}
-
-	return config, nil
-}
-
-func (s *ConfigurationService) GetByUUID(uuid string, ownerUsername string) (*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 !s.isOwner(config, ownerUsername) && !config.IsTemplate {
-		return nil, ErrConfigForbidden
-	}
-
-	return config, nil
-}
-
-func (s *ConfigurationService) Update(uuid string, ownerUsername string, req *CreateConfigRequest) (*models.Configuration, error) {
-	config, err := s.configRepo.GetByUUID(uuid)
-	if err != nil {
-		return nil, ErrConfigNotFound
-	}
-
-	if !s.isOwner(config, ownerUsername) {
-		return nil, ErrConfigForbidden
-	}
-
-	projectUUID, err := s.resolveProjectUUID(ownerUsername, req.ProjectUUID)
-	if err != nil {
-		return nil, err
-	}
-	pricelistID, err := s.resolvePricelistID(req.PricelistID)
-	if err != nil {
-		return nil, err
-	}
-
-	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.ProjectUUID = projectUUID
-	config.Items = req.Items
-	config.TotalPrice = &total
-	config.CustomPrice = req.CustomPrice
-	config.Notes = req.Notes
-	config.IsTemplate = req.IsTemplate
-	config.ServerCount = req.ServerCount
-	config.ServerModel = req.ServerModel
-	config.SupportCode = req.SupportCode
-	config.Article = req.Article
-	config.PricelistID = pricelistID
-	config.WarehousePricelistID = req.WarehousePricelistID
-	config.CompetitorPricelistID = req.CompetitorPricelistID
-	config.DisablePriceRefresh = req.DisablePriceRefresh
-	config.OnlyInStock = req.OnlyInStock
-
-	if err := s.configRepo.Update(config); err != nil {
-		return nil, err
-	}
-
-	return config, nil
-}
-
-func (s *ConfigurationService) Delete(uuid string, ownerUsername string) error {
-	config, err := s.configRepo.GetByUUID(uuid)
-	if err != nil {
-		return ErrConfigNotFound
-	}
-
-	if !s.isOwner(config, ownerUsername) {
-		return ErrConfigForbidden
-	}
-
-	return s.configRepo.Delete(config.ID)
-}
-
-func (s *ConfigurationService) Rename(uuid string, ownerUsername string, newName string) (*models.Configuration, error) {
-	config, err := s.configRepo.GetByUUID(uuid)
-	if err != nil {
-		return nil, ErrConfigNotFound
-	}
-
-	if !s.isOwner(config, ownerUsername) {
-		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, ownerUsername string, newName string) (*models.Configuration, error) {
-	return s.CloneToProject(configUUID, ownerUsername, newName, nil)
-}
-
-func (s *ConfigurationService) CloneToProject(configUUID string, ownerUsername string, newName string, projectUUID *string) (*models.Configuration, error) {
-	original, err := s.GetByUUID(configUUID, ownerUsername)
-	if err != nil {
-		return nil, err
-	}
-	resolvedProjectUUID := original.ProjectUUID
-	if projectUUID != nil {
-		resolvedProjectUUID, err = s.resolveProjectUUID(ownerUsername, projectUUID)
-		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(),
-		OwnerUsername:         ownerUsername,
-		ProjectUUID:           resolvedProjectUUID,
-		Name:                  newName,
-		Items:                 original.Items,
-		TotalPrice:            &total,
-		CustomPrice:           original.CustomPrice,
-		Notes:                 original.Notes,
-		IsTemplate:            false, // Clone is never a template
-		ServerCount:           original.ServerCount,
-		ServerModel:           original.ServerModel,
-		SupportCode:           original.SupportCode,
-		Article:               original.Article,
-		PricelistID:           original.PricelistID,
-		WarehousePricelistID:  original.WarehousePricelistID,
-		CompetitorPricelistID: original.CompetitorPricelistID,
-		DisablePriceRefresh:   original.DisablePriceRefresh,
-		OnlyInStock:           original.OnlyInStock,
-	}
-
-	if err := s.configRepo.Create(clone); err != nil {
-		return nil, err
-	}
-
-	return clone, nil
-}
-
-func (s *ConfigurationService) ListByUser(ownerUsername string, 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(ownerUsername, offset, perPage)
-}
-
-// ListAll returns all configurations without user filter (for use when auth is disabled)
-func (s *ConfigurationService) ListAll(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.ListAll(offset, perPage)
-}
-
-// GetByUUIDNoAuth returns configuration without ownership check (for use when auth is disabled)
-func (s *ConfigurationService) GetByUUIDNoAuth(uuid string) (*models.Configuration, error) {
-	config, err := s.configRepo.GetByUUID(uuid)
-	if err != nil {
-		return nil, ErrConfigNotFound
-	}
-	return config, nil
-}
-
-// UpdateNoAuth updates configuration without ownership check
-func (s *ConfigurationService) UpdateNoAuth(uuid string, req *CreateConfigRequest) (*models.Configuration, error) {
-	config, err := s.configRepo.GetByUUID(uuid)
-	if err != nil {
-		return nil, ErrConfigNotFound
-	}
-
-	projectUUID, err := s.resolveProjectUUID(config.OwnerUsername, req.ProjectUUID)
-	if err != nil {
-		return nil, err
-	}
-	pricelistID, err := s.resolvePricelistID(req.PricelistID)
-	if err != nil {
-		return nil, err
-	}
-
-	total := req.Items.Total()
-	if req.ServerCount > 1 {
-		total *= float64(req.ServerCount)
-	}
-
-	config.Name = req.Name
-	config.ProjectUUID = projectUUID
-	config.Items = req.Items
-	config.TotalPrice = &total
-	config.CustomPrice = req.CustomPrice
-	config.Notes = req.Notes
-	config.IsTemplate = req.IsTemplate
-	config.ServerCount = req.ServerCount
-	config.ServerModel = req.ServerModel
-	config.SupportCode = req.SupportCode
-	config.Article = req.Article
-	config.PricelistID = pricelistID
-	config.WarehousePricelistID = req.WarehousePricelistID
-	config.CompetitorPricelistID = req.CompetitorPricelistID
-	config.DisablePriceRefresh = req.DisablePriceRefresh
-	config.OnlyInStock = req.OnlyInStock
-
-	if err := s.configRepo.Update(config); err != nil {
-		return nil, err
-	}
-
-	return config, nil
-}
-
-// DeleteNoAuth deletes configuration without ownership check
-func (s *ConfigurationService) DeleteNoAuth(uuid string) error {
-	config, err := s.configRepo.GetByUUID(uuid)
-	if err != nil {
-		return ErrConfigNotFound
-	}
-	return s.configRepo.Delete(config.ID)
-}
-
-// RenameNoAuth renames configuration without ownership check
-func (s *ConfigurationService) RenameNoAuth(uuid string, newName string) (*models.Configuration, error) {
-	config, err := s.configRepo.GetByUUID(uuid)
-	if err != nil {
-		return nil, ErrConfigNotFound
-	}
-
-	config.Name = newName
-	if err := s.configRepo.Update(config); err != nil {
-		return nil, err
-	}
-
-	return config, nil
-}
-
-// CloneNoAuth clones configuration without ownership check
-func (s *ConfigurationService) CloneNoAuth(configUUID string, newName string, ownerUsername string) (*models.Configuration, error) {
-	return s.CloneNoAuthToProject(configUUID, newName, ownerUsername, nil)
-}
-
-func (s *ConfigurationService) CloneNoAuthToProject(configUUID string, newName string, ownerUsername string, projectUUID *string) (*models.Configuration, error) {
-	original, err := s.configRepo.GetByUUID(configUUID)
-	if err != nil {
-		return nil, ErrConfigNotFound
-	}
-	resolvedProjectUUID := original.ProjectUUID
-	if projectUUID != nil {
-		resolvedProjectUUID, err = s.resolveProjectUUID(ownerUsername, projectUUID)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	total := original.Items.Total()
-	if original.ServerCount > 1 {
-		total *= float64(original.ServerCount)
-	}
-
-	clone := &models.Configuration{
-		UUID:          uuid.New().String(),
-		OwnerUsername: ownerUsername,
-		ProjectUUID:   resolvedProjectUUID,
-		Name:          newName,
-		Items:         original.Items,
-		TotalPrice:    &total,
-		CustomPrice:   original.CustomPrice,
-		Notes:         original.Notes,
-		IsTemplate:    false,
-		ServerCount:   original.ServerCount,
-		PricelistID:   original.PricelistID,
-		OnlyInStock:   original.OnlyInStock,
-	}
-
-	if err := s.configRepo.Create(clone); err != nil {
-		return nil, err
-	}
-
-	return clone, nil
-}
-
-func (s *ConfigurationService) resolveProjectUUID(ownerUsername string, projectUUID *string) (*string, error) {
-	_ = ownerUsername
-	if s.projectRepo == nil {
-		return projectUUID, nil
-	}
-	if projectUUID == nil || *projectUUID == "" {
-		return nil, nil
-	}
-
-	project, err := s.projectRepo.GetByUUID(*projectUUID)
-	if err != nil {
-		return nil, ErrProjectNotFound
-	}
-	if !project.IsActive {
-		return nil, errors.New("project is archived")
-	}
-
-	return &project.UUID, nil
-}
-
-func (s *ConfigurationService) resolvePricelistID(pricelistID *uint) (*uint, error) {
-	if s.pricelistRepo == nil {
-		return pricelistID, nil
-	}
-	if pricelistID != nil && *pricelistID > 0 {
-		if _, err := s.pricelistRepo.GetByID(*pricelistID); err != nil {
-			return nil, err
-		}
-		return pricelistID, nil
-	}
-	latest, err := s.pricelistRepo.GetLatestActive()
-	if err != nil {
-		return nil, nil
-	}
-	return &latest.ID, nil
-}
-
-// RefreshPricesNoAuth refreshes prices without ownership check
-func (s *ConfigurationService) RefreshPricesNoAuth(uuid string) (*models.Configuration, error) {
-	config, err := s.configRepo.GetByUUID(uuid)
-	if err != nil {
-		return nil, ErrConfigNotFound
-	}
-
-	var latestPricelistID *uint
-	if s.pricelistRepo != nil {
-		if pl, err := s.pricelistRepo.GetLatestActive(); err == nil {
-			latestPricelistID = &pl.ID
-		}
-	}
-
-	updatedItems := make(models.ConfigItems, len(config.Items))
-	for i, item := range config.Items {
-		if latestPricelistID != nil {
-			if price, err := s.pricelistRepo.GetPriceForLot(*latestPricelistID, item.LotName); err == nil && price > 0 {
-				updatedItems[i] = models.ConfigItem{
-					LotName:   item.LotName,
-					Quantity:  item.Quantity,
-					UnitPrice: price,
-				}
-				continue
-			}
-		}
-
-		if s.componentRepo == nil {
-			updatedItems[i] = item
-			continue
-		}
-		metadata, err := s.componentRepo.GetByLotName(item.LotName)
-		if err != nil || metadata.CurrentPrice == nil {
-			updatedItems[i] = item
-			continue
-		}
-
-		updatedItems[i] = models.ConfigItem{
-			LotName:   item.LotName,
-			Quantity:  item.Quantity,
-			UnitPrice: *metadata.CurrentPrice,
-		}
-	}
-
-	config.Items = updatedItems
-	total := updatedItems.Total()
-	if config.ServerCount > 1 {
-		total *= float64(config.ServerCount)
-	}
-
-	config.TotalPrice = &total
-	if latestPricelistID != nil {
-		config.PricelistID = latestPricelistID
-	}
-	now := time.Now()
-	config.PriceUpdatedAt = &now
-
-	if err := s.configRepo.Update(config); err != nil {
-		return nil, err
-	}
-
-	return config, nil
-}
-
-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)
-}
-
-// RefreshPrices updates all component prices in the configuration with current prices
-func (s *ConfigurationService) RefreshPrices(uuid string, ownerUsername string) (*models.Configuration, error) {
-	config, err := s.configRepo.GetByUUID(uuid)
-	if err != nil {
-		return nil, ErrConfigNotFound
-	}
-
-	if !s.isOwner(config, ownerUsername) {
-		return nil, ErrConfigForbidden
-	}
-
-	var latestPricelistID *uint
-	if s.pricelistRepo != nil {
-		if pl, err := s.pricelistRepo.GetLatestActive(); err == nil {
-			latestPricelistID = &pl.ID
-		}
-	}
-
-	// Update prices for all items
-	updatedItems := make(models.ConfigItems, len(config.Items))
-	for i, item := range config.Items {
-		if latestPricelistID != nil {
-			if price, err := s.pricelistRepo.GetPriceForLot(*latestPricelistID, item.LotName); err == nil && price > 0 {
-				updatedItems[i] = models.ConfigItem{
-					LotName:   item.LotName,
-					Quantity:  item.Quantity,
-					UnitPrice: price,
-				}
-				continue
-			}
-		}
-
-		// Get current component price
-		if s.componentRepo == nil {
-			updatedItems[i] = item
-			continue
-		}
-		metadata, err := s.componentRepo.GetByLotName(item.LotName)
-		if err != nil || metadata.CurrentPrice == nil {
-			// Keep original item if component not found or no price available
-			updatedItems[i] = item
-			continue
-		}
-
-		// Update item with current price
-		updatedItems[i] = models.ConfigItem{
-			LotName:   item.LotName,
-			Quantity:  item.Quantity,
-			UnitPrice: *metadata.CurrentPrice,
-		}
-	}
-
-	// Update configuration
-	config.Items = updatedItems
-	total := updatedItems.Total()
-
-	// If server count is greater than 1, multiply the total by server count
-	if config.ServerCount > 1 {
-		total *= float64(config.ServerCount)
-	}
-
-	config.TotalPrice = &total
-	if latestPricelistID != nil {
-		config.PricelistID = latestPricelistID
-	}
-
-	// Set price update timestamp
-	now := time.Now()
-	config.PriceUpdatedAt = &now
-
-	if err := s.configRepo.Update(config); err != nil {
-		return nil, err
-	}
-
-	return config, nil
-}
-
-func (s *ConfigurationService) isOwner(config *models.Configuration, ownerUsername string) bool {
-	if config == nil || ownerUsername == "" {
-		return false
-	}
-	return config.OwnerUsername == ownerUsername
-}
-
-// // Export configuration as JSON
-// type ConfigExport struct {
-// 	Name  string             `json:"name"`
-// 	Notes string             `json:"notes"`
-// 	Items models.ConfigItems `json:"items"`
-// }
-//
-// func (s *ConfigurationService) ExportJSON(uuid string, userID uint) ([]byte, error) {
-// 	config, err := s.GetByUUID(uuid, userID)
-// 	if err != nil {
-// 		return nil, err
-// 	}
-//
-// 	export := ConfigExport{
-// 		Name:  config.Name,
-// 		Notes: config.Notes,
-// 		Items: config.Items,
-// 	}
-//
-// 	return json.MarshalIndent(export, "", "  ")
-// }
-//
-// func (s *ConfigurationService) ImportJSON(userID uint, data []byte) (*models.Configuration, error) {
-// 	var export ConfigExport
-// 	if err := json.Unmarshal(data, &export); err != nil {
-// 		return nil, err
-// 	}
-//
-// 	req := &CreateConfigRequest{
-// 		Name:  export.Name,
-// 		Notes: export.Notes,
-// 		Items: export.Items,
-// 	}
-//
-// 	return s.Create(userID, req)
-// }

internal/services/export.go

@@ -656,16 +656,8 @@ func (s *ExportService) batchLookupPrices(serverPricelistID *uint, lots []string
 	return prices
 }
 
-func (s *ExportService) resolveLotDescriptions(cfg *models.Configuration, localCfg *localdb.LocalConfiguration) map[string]string {
+func (s *ExportService) resolveLotDescriptions(_ *models.Configuration, _ *localdb.LocalConfiguration) map[string]string {
-	lots := collectPricingLots(cfg, localCfg, true)
+	return map[string]string{}
-	if s.localDB == nil || len(lots) == 0 {
-		return map[string]string{}
-	}
-	descriptions, err := s.localDB.GetLocalComponentDescriptionsByLotNames(lots)
-	if err != nil {
-		return map[string]string{}
-	}
-	return descriptions
 }
 
 func collectPricingLots(cfg *models.Configuration, localCfg *localdb.LocalConfiguration, includeBOM bool) []string {

internal/services/quote.go

@@ -18,32 +18,22 @@ var (
 )
 
 type QuoteService struct {
-	componentRepo  *repository.ComponentRepository
+	pricelistRepo *repository.PricelistRepository
-	pricelistRepo  *repository.PricelistRepository
+	localDB       *localdb.LocalDB
-	localDB        *localdb.LocalDB
+	cacheMu       sync.RWMutex
-	pricingService priceResolver
+	priceCache    map[string]cachedLotPrice
-	cacheMu        sync.RWMutex
+	cacheTTL      time.Duration
-	priceCache     map[string]cachedLotPrice
-	cacheTTL       time.Duration
-}
-
-type priceResolver interface {
-	GetEffectivePrice(lotName string) (*float64, error)
 }
 
 func NewQuoteService(
-	componentRepo *repository.ComponentRepository,
 	pricelistRepo *repository.PricelistRepository,
 	localDB *localdb.LocalDB,
-	pricingService priceResolver,
 ) *QuoteService {
 	return &QuoteService{
-		componentRepo:  componentRepo,
+		pricelistRepo: pricelistRepo,
-		pricelistRepo:  pricelistRepo,
+		localDB:       localDB,
-		localDB:        localDB,
+		priceCache:    make(map[string]cachedLotPrice, 4096),
-		pricingService: pricingService,
+		cacheTTL:      10 * time.Second,
-		priceCache:     make(map[string]cachedLotPrice, 4096),
-		cacheTTL:       10 * time.Second,
 	}
 }
 
@@ -111,6 +101,9 @@ func (s *QuoteService) ValidateAndCalculate(req *QuoteRequest) (*QuoteValidation
 	if len(req.Items) == 0 {
 		return nil, ErrEmptyQuote
 	}
+	for i := range req.Items {
+		req.Items[i].LotName = models.NormalizeLotName(req.Items[i].LotName)
+	}
 
 	// Strict local-first path: calculations use local SQLite snapshot regardless of online status.
 	if s.localDB != nil {
@@ -172,79 +165,23 @@ func (s *QuoteService) ValidateAndCalculate(req *QuoteRequest) (*QuoteValidation
 		return result, nil
 	}
 
-	if s.componentRepo == nil || s.pricingService == nil {
+	return nil, errors.New("quote calculation requires local database")
-		return nil, errors.New("quote calculation not available")
-	}
-
-	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
 }
 
 func (s *QuoteService) CalculatePriceLevels(req *PriceLevelsRequest) (*PriceLevelsResult, error) {
 	if len(req.Items) == 0 {
 		return nil, ErrEmptyQuote
 	}
+	// Keep original lot names so the response mirrors what the caller sent.
+	// Normalization is applied only for internal DB lookups.
+	originalLotNames := make(map[string]string, len(req.Items))
+	for i := range req.Items {
+		upper := models.NormalizeLotName(req.Items[i].LotName)
+		if _, exists := originalLotNames[upper]; !exists {
+			originalLotNames[upper] = req.Items[i].LotName
+		}
+		req.Items[i].LotName = upper
+	}
 
 	lotNames := make([]string, 0, len(req.Items))
 	seenLots := make(map[string]struct{}, len(req.Items))
@@ -303,8 +240,12 @@ func (s *QuoteService) CalculatePriceLevels(req *PriceLevelsRequest) (*PriceLeve
 	}
 
 	for _, reqItem := range req.Items {
+		responseLotName := originalLotNames[reqItem.LotName]
+		if responseLotName == "" {
+			responseLotName = reqItem.LotName
+		}
 		item := PriceLevelsItem{
-			LotName:      reqItem.LotName,
+			LotName:      responseLotName,
 			Quantity:     reqItem.Quantity,
 			PriceMissing: make([]string, 0, 3),
 		}

internal/services/quote_price_levels_test.go

@@ -13,7 +13,7 @@ import (
 func TestCalculatePriceLevels_WithMissingLevel(t *testing.T) {
 	db := newPriceLevelsTestDB(t)
 	repo := repository.NewPricelistRepository(db)
-	service := NewQuoteService(nil, repo, nil, nil)
+	service := NewQuoteService(repo, nil)
 
 	estimate := seedPricelistWithItem(t, repo, "estimate", "CPU_X", 100)
 	_ = estimate
@@ -57,7 +57,7 @@ func TestCalculatePriceLevels_WithMissingLevel(t *testing.T) {
 func TestCalculatePriceLevels_UsesExplicitPricelistIDs(t *testing.T) {
 	db := newPriceLevelsTestDB(t)
 	repo := repository.NewPricelistRepository(db)
-	service := NewQuoteService(nil, repo, nil, nil)
+	service := NewQuoteService(repo, nil)
 
 	olderEstimate := seedPricelistWithItem(t, repo, "estimate", "CPU_Y", 80)
 	seedPricelistWithItem(t, repo, "estimate", "CPU_Y", 90)

internal/services/sync/service.go

@@ -404,6 +404,7 @@ func (s *Service) syncPricelists() (int, error) {
 			CreatedAt: pl.CreatedAt,
 			SyncedAt:  time.Now(),
 			IsUsed:    false,
+			IsActive:  true,
 		}
 
 		itemCount, err := s.syncNewPricelistSnapshot(localPL)
@@ -426,6 +427,12 @@ func (s *Service) syncPricelists() (int, error) {
 		slog.Info("deleted stale local pricelists", "deleted", removed)
 	}
 
+	// Mirror server-side deactivations: any local pricelist not in the current active set
+	// is marked is_active=false so offline lookups skip it.
+	if err := s.localDB.DeactivateLocalPricelistsNotIn(serverPricelistIDs); err != nil {
+		slog.Warn("failed to deactivate stale local pricelists", "error", err)
+	}
+
 	// Backfill lot_category for used pricelists (older local caches may miss the column values).
 	s.backfillUsedPricelistItemCategories(pricelistRepo, serverPricelistIDs)
 
@@ -1638,24 +1645,3 @@ func (s *Service) getConnectionStatus() db.ConnectionStatus {
 	return s.connMgr.GetStatus()
 }
 
-// SyncComponentsIfEmpty syncs components from MariaDB when local_components is empty.
-// Used by the background worker on first run to populate the catalog for new users.
-func (s *Service) SyncComponentsIfEmpty() error {
-	if s.localDB.CountComponents() > 0 {
-		return nil
-	}
-	mariaDB, err := s.getDB()
-	if err != nil {
-		_ = s.localDB.SetComponentSyncResult("error", err.Error(), time.Now())
-		return err
-	}
-	result, err := s.localDB.SyncComponents(mariaDB)
-	now := time.Now()
-	if err != nil {
-		_ = s.localDB.SetComponentSyncResult("error", err.Error(), now)
-		return err
-	}
-	_ = s.localDB.SetComponentSyncResult("ok", "", now)
-	slog.Info("background sync: initial component sync completed", "synced", result.TotalSynced)
-	return nil
-}

internal/services/sync/worker.go

@@ -80,11 +80,6 @@ func (w *Worker) runSync() {
 		return
 	}
 
-	// Populate component catalog on first run (empty local_components)
-	if err := w.service.SyncComponentsIfEmpty(); err != nil {
-		w.logger.Warn("background sync: initial component sync failed", "error", err)
-	}
-
 	// Push pending changes first
 	pushed, err := w.service.PushPendingChanges()
 	if err != nil {

releases/v2.22/RELEASE_NOTES.md

@@ -0,0 +1,23 @@
+# QuoteForge v2.22
+
+Дата релиза: 2026-06-26
+Тег: `v2.22`
+
+## Что нового
+
+### Исправления
+
+- **MB-автокомплит в конфигураторе теперь работает в offline-режиме.** Корневая причина: прайслист мог быть синхронизирован до введения нормализации имён лотов, из-за чего SQLite хранил их в исходном регистре (`MB_AMD_2.Rome_...`). Запрос на поиск цены отправлял уже нормализованное имя (`MB_AMD_2.ROME_...`), `IN`-сравнение в SQLite регистрозависимо — совпадений не было, цена возвращалась как null, и автокомплит показывал пустой список. Все запросы к `local_pricelist_items` по `lot_name` переведены на `UPPER(lot_name)`.
+
+- **Удалён мёртвый код инференса категории из имени лота.** Функция `getCategoryFromLotName` на фронтенде выводила категорию из префикса лота (`DKC_AFF_A1K` → `DKC`) как fallback. Категория всегда приходит из прайслиста; функция удалена. Позиции без категории корректно попадают во вкладку «Other».
+
+- **Удалена таблица `local_components` и весь связанный с ней код.** Источник данных для компонентов — только `local_pricelist_items`. Убраны маршрут `POST /api/sync/components`, поля `ComponentsSynced` и `LastComponentSync` в ответах синхронизации.
+
+- **Support bundle расширен диагностическими файлами:** `latest_pricelist_items.json` (все позиции активного estimate-прайслиста), `autocomplete_lots.json` (позиции по категориям с флагом `has_price`), `local.db` (полная копия SQLite-базы).
+
+- **Регистронезависимые сравнения lot_name на фронтенде:** Set-коллекции для склада, добавленных позиций и корзины BOM теперь нормализуют ключи через `.toUpperCase()`.
+
+## Запуск на macOS
+
+Снимите карантинный атрибут через терминал: `xattr -d com.apple.quarantine /path/to/qfs-darwin-arm64`  
+После этого бинарник запустится без предупреждения Gatekeeper.

releases/v2.23/RELEASE_NOTES.md

@@ -0,0 +1,23 @@
+# QuoteForge v2.23
+
+Дата релиза: 2026-06-26
+Тег: `v2.23`
+
+## Что нового
+
+### Исправления
+
+- **Конфигуратор больше не зависает на «Загрузка...».** При открытии сохранённой конфигурации поле `category` у позиций корзины было `undefined` (в `config.items` хранятся только `lot_name/quantity/unit_price`), что приводило к `TypeError` в JS. Теперь после загрузки `allComponents` корзина обогащается категориями из справочника компонентов.
+
+- **Регистронезависимые сравнения категорий в конфигураторе.** Все сравнения `category` переведены на хелпер `ciStr()` вместо принудительного `.toUpperCase()` — интерфейс показывает категории как есть, логика сравнения регистронезависима.
+
+- **Вкладка Other показывает только компоненты без назначенной категории.** Исправлена ошибка при которой компоненты DKC/CTL/ENC попадали в Other при режиме «server»: `ASSIGNED_CATEGORIES` пересобирался из отфильтрованного списка, а не из полного статического. Теперь используется `_allCategories`.
+
+- **Исправлена ошибка «record not found» при синхронизации проектов.** `UpsertByUUID` передавал ненулевой `ID` в `INSERT … ON DUPLICATE KEY UPDATE`, из-за чего MariaDB разрешала коллизию по первичному ключу чужой строки, не обновляя `uuid`, — последующий `SELECT` не находил запись. Теперь `project.ID` сбрасывается в `0` до вставки.
+
+- **Устранён бесконечный retry при ошибках синхронизации на стороне сервера.** `RepairPendingChanges` сбрасывал счётчик попыток даже если локальные данные не менялись, что создавало бесконечный цикл при серверных ошибках. Repair-функции теперь возвращают `(bool, error)` и сброс происходит только при `modified=true`.
+
+## Запуск на macOS
+
+Снимите карантинный атрибут через терминал: `xattr -d com.apple.quarantine /path/to/qfs-darwin-arm64`  
+После этого бинарник запустится без предупреждения Gatekeeper.

releases/v2.24/RELEASE_NOTES.md

@@ -0,0 +1,15 @@
+# QuoteForge v2.24
+
+Дата релиза: 2026-06-26
+Тег: `v2.24`
+
+## Что нового
+
+### Исправления
+
+- **Исправлен ReferenceError в конфигураторе при выборе компонента в секционированных вкладках (Storage, PCI).** Переменная `sectionCategories` не была определена — опечатка, должно быть `section.categories`. Ошибка возникала при клике на элемент автокомплита во вкладках с секциями.
+
+## Запуск на macOS
+
+Снимите карантинный атрибут через терминал: `xattr -d com.apple.quarantine /path/to/qfs-darwin-arm64`  
+После этого бинарник запустится без предупреждения Gatekeeper.

web/templates/index.html

@@ -417,7 +417,7 @@ let TAB_CONFIG = {
 
 let ASSIGNED_CATEGORIES = Object.values(TAB_CONFIG)
     .flatMap(t => t.categories)
-    .map(c => c.toUpperCase());
+    .map(c => ciStr(c));
 
 // State
 let configUUID = '{{.ConfigUUID}}';
@@ -713,7 +713,7 @@ async function loadWarehouseInStockLots() {
         const lotNames = Array.isArray(data.lot_names) ? data.lot_names : [];
         lotNames.forEach(lot => {
             if (typeof lot === 'string' && lot.trim() !== '') {
-                result.add(lot);
+                result.add(lot.toUpperCase());
             }
         });
 
@@ -748,7 +748,7 @@ function isComponentAllowedByStockFilter(comp) {
     const availableLots = warehouseStockLotsByPricelist.get(pricelistID);
     // Don't block UI while stock set is being loaded.
     if (!availableLots) return true;
-    return availableLots.has(comp.lot_name);
+    return availableLots.has((comp.lot_name || '').toUpperCase());
 }
 
 // Load categories from API and update tab configuration
@@ -760,16 +760,16 @@ async function loadCategoriesFromAPI() {
         // Build category order map
         categoryOrderMap = {};
         cats.forEach(cat => {
-            categoryOrderMap[cat.code.toUpperCase()] = cat.display_order;
+            categoryOrderMap[ciStr(cat.code)] = cat.display_order;
         });
 
         // Build list of unassigned categories
         const knownCodes = Object.values(TAB_CONFIG)
             .flatMap(t => t.categories)
-            .map(c => c.toUpperCase());
+            .map(c => ciStr(c));
 
         const unassignedCategories = cats
-            .filter(cat => !knownCodes.includes(cat.code.toUpperCase()))
+            .filter(cat => !knownCodes.includes(ciStr(cat.code)))
             .sort((a, b) => a.display_order - b.display_order)
             .map(cat => cat.code);
 
@@ -779,7 +779,7 @@ async function loadCategoriesFromAPI() {
         // Rebuild ASSIGNED_CATEGORIES
         ASSIGNED_CATEGORIES = Object.values(TAB_CONFIG)
             .flatMap(t => t.categories)
-            .map(c => c.toUpperCase());
+            .map(c => ciStr(c));
     } catch(e) {
         console.error('Failed to load categories, using defaults', e);
         // Will use default configuration if API fails
@@ -824,7 +824,7 @@ function applyServerSettings(settings) {
             };
         });
         TAB_CONFIG.other = otherTab || { categories: [], singleSelect: false, label: 'Other' };
-        ASSIGNED_CATEGORIES = Object.values(TAB_CONFIG).flatMap(t => t.categories).map(c => c.toUpperCase());
+        ASSIGNED_CATEGORIES = Object.values(TAB_CONFIG).flatMap(t => t.categories).map(c => ciStr(c));
     }
 
     // always_visible_tabs
@@ -853,7 +853,7 @@ function updateRequiredCategoryBadges() {
 
     // Build set of categories that have at least one cart item
     const filledCategories = new Set(
-        cart.map(item => (item.category || getCategoryFromLotName(item.lot_name) || '').toUpperCase())
+        cart.map(item => (item.category || '').toUpperCase())
     );
 
     // For each tab, check if it contains any required-but-unfilled category
@@ -925,8 +925,7 @@ document.addEventListener('DOMContentLoaded', async function() {
                 warehouse_price: null,
                 competitor_price: null,
                 description: item.description || '',
-                category: item.category || getCategoryFromLotName(item.lot_name)
+                category: item.category            }));
-            }));
         }
         serverModelForQuote = config.server_model || '';
         supportCode = config.support_code || '';
@@ -954,6 +953,10 @@ document.addEventListener('DOMContentLoaded', async function() {
         loadAllComponents(),
         categoriesPromise,
     ]);
+    cart = cart.map(item => ({
+        ...item,
+        category: item.category || allComponents.find(c => c.lot_name.toUpperCase() === (item.lot_name || '').toUpperCase())?.category || ''
+    }));
     syncPriceSettingsControls();
     renderPricelistSettingsSummary();
     updateRefreshPricesButtonState();
@@ -1003,7 +1006,7 @@ const BOM_LOT_DATALIST_DIVIDER = '────────';
 function _bomLotValid(v) {
     const lot = (v || '').trim();
     if (!lot || lot === BOM_LOT_DATALIST_DIVIDER) return false;
-    return (window._bomAllComponents || allComponents).some(c => c.lot_name === lot);
+    return (window._bomAllComponents || allComponents).some(c => c.lot_name.toUpperCase() === lot.toUpperCase());
 }
 
 function updateServerCount() {
@@ -1219,19 +1222,16 @@ function applyPriceSettings() {
     schedulePriceLevelsRefresh({ delay: 0, rerender: true, autosave: true });
 }
 
-function getCategoryFromLotName(lotName) {
+function ciStr(s) { return (s || '').toLowerCase(); }
-    const parts = lotName.split('_');
-    return parts[0] || '';
-}
 
 function getComponentCategory(comp) {
-    return (comp.category || getCategoryFromLotName(comp.lot_name)).toUpperCase();
+    return comp.category || '';
 }
 
 function getTabForCategory(category) {
-    const cat = category.toUpperCase();
+    const cat = ciStr(category);
     for (const [tabKey, tabConfig] of Object.entries(TAB_CONFIG)) {
-        if (tabConfig.categories.map(c => c.toUpperCase()).includes(cat)) {
+        if (tabConfig.categories.some(c => ciStr(c) === cat)) {
             return tabKey;
         }
     }
@@ -1309,10 +1309,11 @@ function applyConfigTypeToTabs() {
         }
     });
 
-    // Rebuild assigned categories index
+    // Rebuild assigned categories index using the full static list (_allCategories),
+    // not the filtered one — hidden categories still belong to their tab, not to Other.
     ASSIGNED_CATEGORIES = Object.values(TAB_CONFIG)
-        .flatMap(t => t.categories)
+        .flatMap(t => t._allCategories || t.categories)
-        .map(c => c.toUpperCase());
+        .map(c => ciStr(c));
 }
 
 function updateTabVisibility() {
@@ -1323,8 +1324,7 @@ function updateTabVisibility() {
         if (!btn) continue;
         const hasComponents = getComponentsForTab(tabId).length > 0;
         const hasCartItems = cart.some(item => {
-            const cat = (item.category || getCategoryFromLotName(item.lot_name) || '').toUpperCase();
+            return getTabForCategory(item.category) === tabId;
-            return getTabForCategory(cat) === tabId;
         });
         const visible = hasComponents || hasCartItems;
         btn.classList.toggle('hidden', !visible);
@@ -1340,15 +1340,15 @@ function getComponentsForTab(tab) {
     return allComponents.filter(comp => {
         const category = getComponentCategory(comp);
         if (tab === 'other') {
-            return !ASSIGNED_CATEGORIES.includes(category);
+            return !ASSIGNED_CATEGORIES.includes(ciStr(category));
         }
-        return config.categories.map(c => c.toUpperCase()).includes(category);
+        return config.categories.some(c => ciStr(c) === ciStr(category));
     });
 }
 
 function getComponentsForCategory(category) {
     return allComponents.filter(comp => {
-        return getComponentCategory(comp) === category.toUpperCase();
+        return ciStr(getComponentCategory(comp)) === ciStr(category);
     });
 }
 
@@ -1410,10 +1410,10 @@ function renderSingleSelectTab(categories) {
     categories.forEach(cat => {
         const catLabel = cat === 'MB' ? 'MB' : cat === 'CPU' ? 'CPU' : cat === 'MEM' ? 'MEM' : cat;
         const selectedItem = cart.find(item =>
-            (item.category || getCategoryFromLotName(item.lot_name)).toUpperCase() === cat.toUpperCase()
+            ciStr(item.category) === ciStr(cat)
         );
 
-        const comp = selectedItem ? allComponents.find(c => c.lot_name === selectedItem.lot_name) : null;
+        const comp = selectedItem ? allComponents.find(c => c.lot_name.toUpperCase() === (selectedItem.lot_name || '').toUpperCase()) : null;
         const price = comp?.current_price || 0;
         const estimate = selectedItem?.estimate_price ?? price;
         const qty = selectedItem?.quantity || 1;
@@ -1463,9 +1463,7 @@ function renderSingleSelectTab(categories) {
 function renderMultiSelectTab(components) {
     // Get cart items for this tab
     const tabItems = cart.filter(item => {
-        const cat = (item.category || getCategoryFromLotName(item.lot_name)).toUpperCase();
+        return getTabForCategory(item.category) === currentTab;
-        const tab = getTabForCategory(cat);
-        return tab === currentTab;
     });
 
     let html = `
@@ -1485,7 +1483,7 @@ function renderMultiSelectTab(components) {
 
     // Render existing cart items for this tab
     tabItems.forEach((item, idx) => {
-        const comp = allComponents.find(c => c.lot_name === item.lot_name);
+        const comp = allComponents.find(c => c.lot_name.toUpperCase() === (item.lot_name || '').toUpperCase());
         const total = getDisplayPrice(item) * item.quantity;
 
         html += `
@@ -1552,9 +1550,7 @@ function renderMultiSelectTab(components) {
 function renderMultiSelectTabWithSections(sections) {
     // Get cart items for this tab
     const tabItems = cart.filter(item => {
-        const cat = (item.category || getCategoryFromLotName(item.lot_name)).toUpperCase();
+        return getTabForCategory(item.category) === currentTab;
-        const tab = getTabForCategory(cat);
-        return tab === currentTab;
     });
 
     let html = '';
@@ -1562,17 +1558,14 @@ function renderMultiSelectTabWithSections(sections) {
 
     sections.forEach((section, sectionIdx) => {
         // Get components for this section's categories
-        const sectionCategories = section.categories.map(c => c.toUpperCase());
         const sectionComponents = allComponents.filter(comp => {
-            const category = getComponentCategory(comp);
+            return section.categories.some(c => ciStr(c) === ciStr(getComponentCategory(comp)));
-            return sectionCategories.includes(category);
         });
         totalComponents += sectionComponents.length;
 
         // Get cart items for this section
         const sectionItems = tabItems.filter(item => {
-            const cat = (item.category || getCategoryFromLotName(item.lot_name)).toUpperCase();
+            return section.categories.some(c => ciStr(c) === ciStr(item.category));
-            return sectionCategories.includes(cat);
         });
 
         // Section header
@@ -1599,7 +1592,7 @@ function renderMultiSelectTabWithSections(sections) {
 
         // Render existing cart items for this section
         sectionItems.forEach((item) => {
-            const comp = allComponents.find(c => c.lot_name === item.lot_name);
+            const comp = allComponents.find(c => c.lot_name.toUpperCase() === (item.lot_name || '').toUpperCase());
             const total = getDisplayPrice(item) * item.quantity;
 
             html += `
@@ -1812,7 +1805,7 @@ function selectAutocompleteItem(index) {
 
     // Remove existing item of this category
     cart = cart.filter(item =>
-        (item.category || getCategoryFromLotName(item.lot_name)).toUpperCase() !== autocompleteCategory.toUpperCase()
+        ciStr(item.category) !== ciStr(autocompleteCategory)
     );
 
     const qtyInput = document.getElementById('qty-' + autocompleteCategory);
@@ -1868,11 +1861,11 @@ function filterAutocompleteMulti(search) {
     const searchLower = search.toLowerCase();
 
     // Filter out already added items
-    const addedLots = new Set(cart.map(i => i.lot_name));
+    const addedLots = new Set(cart.map(i => (i.lot_name || '').toUpperCase()));
 
     autocompleteFiltered = components.filter(c => {
         if (!hasComponentPrice(c.lot_name)) return false;
-        if (addedLots.has(c.lot_name)) return false;
+        if (addedLots.has((c.lot_name || '').toUpperCase())) return false;
         if (!isComponentAllowedByStockFilter(c)) return false;
         const text = (c.lot_name + ' ' + (c.description || '')).toLowerCase();
         return text.includes(searchLower);
@@ -1973,11 +1966,11 @@ function filterAutocompleteSection(sectionId, search, inputElement) {
     });
 
     // Filter out already added items
-    const addedLots = new Set(cart.map(i => i.lot_name));
+    const addedLots = new Set(cart.map(i => (i.lot_name || '').toUpperCase()));
 
     autocompleteFiltered = sectionComponents.filter(c => {
         if (!hasComponentPrice(c.lot_name)) return false;
-        if (addedLots.has(c.lot_name)) return false;
+        if (addedLots.has((c.lot_name || '').toUpperCase())) return false;
         if (!isComponentAllowedByStockFilter(c)) return false;
         const text = (c.lot_name + ' ' + (c.description || '')).toLowerCase();
         return text.includes(searchLower);
@@ -2143,14 +2136,14 @@ function showAutocompleteBOM(rowIdx, input) {
 
 function filterAutocompleteBOM(rowIdx, search) {
     const searchLower = (search || '').toLowerCase();
-    const cartLots = new Set(cart.map(i => i.lot_name));
+    const cartLots = new Set(cart.map(i => (i.lot_name || '').toUpperCase()));
     const all = (window._bomAllComponents || allComponents).filter(c => {
         const text = (c.lot_name + ' ' + (c.description || '')).toLowerCase();
         return text.includes(searchLower);
     });
-    const inCart = all.filter(c => cartLots.has(c.lot_name))
+    const inCart = all.filter(c => cartLots.has((c.lot_name || '').toUpperCase()))
         .sort((a, b) => a.lot_name.localeCompare(b.lot_name));
-    const notInCart = all.filter(c => !cartLots.has(c.lot_name))
+    const notInCart = all.filter(c => !cartLots.has((c.lot_name || '').toUpperCase()))
         .sort((a, b) => {
             const popDiff = (b.popularity_score || 0) - (a.popularity_score || 0);
             if (popDiff !== 0) return popDiff;
@@ -2195,7 +2188,7 @@ function selectAutocompleteItemBOM(index, rowIdx) {
 
 function clearSingleSelect(category) {
     cart = cart.filter(item =>
-        (item.category || getCategoryFromLotName(item.lot_name)).toUpperCase() !== category.toUpperCase()
+        ciStr(item.category) !== ciStr(category)
     );
     renderTab();
     updateCartUI();
@@ -2205,7 +2198,7 @@ function clearSingleSelect(category) {
 function updateSingleQuantity(category, value) {
     const qty = parseInt(value) || 1;
     const item = cart.find(i =>
-        (i.category || getCategoryFromLotName(i.lot_name)).toUpperCase() === category.toUpperCase()
+        ciStr(i.category) === ciStr(category)
     );
 
     if (item) {
@@ -2264,8 +2257,8 @@ function updateCartUI() {
 
     // Sort cart items by category display order
     const sortedCart = [...cart].sort((a, b) => {
-        const catA = (a.category || getCategoryFromLotName(a.lot_name)).toUpperCase();
+        const catA = ciStr(a.category);
-        const catB = (b.category || getCategoryFromLotName(b.lot_name)).toUpperCase();
+        const catB = ciStr(b.category);
         const orderA = categoryOrderMap[catA] || 9999;
         const orderB = categoryOrderMap[catB] || 9999;
         return orderA - orderB;
@@ -2273,8 +2266,7 @@ function updateCartUI() {
 
     const grouped = {};
     sortedCart.forEach(item => {
-        const cat = item.category || getCategoryFromLotName(item.lot_name);
+        const tab = getTabForCategory(item.category);
-        const tab = getTabForCategory(cat);
         if (!grouped[tab]) grouped[tab] = [];
         grouped[tab].push(item);
     });
@@ -2282,11 +2274,11 @@ function updateCartUI() {
     // Sort tabs by minimum display order of their categories
     const sortedTabs = Object.entries(grouped).sort((a, b) => {
         const minOrderA = Math.min(...a[1].map(item => {
-            const cat = (item.category || getCategoryFromLotName(item.lot_name)).toUpperCase();
+            const cat = ciStr(item.category);
             return categoryOrderMap[cat] || 9999;
         }));
         const minOrderB = Math.min(...b[1].map(item => {
-            const cat = (item.category || getCategoryFromLotName(item.lot_name)).toUpperCase();
+            const cat = ciStr(item.category);
             return categoryOrderMap[cat] || 9999;
         }));
         return minOrderA - minOrderB;
@@ -2517,8 +2509,7 @@ function restoreAutosaveDraftIfAny() {
                 warehouse_price: null,
                 competitor_price: null,
                 description: item.description || '',
-                category: item.category || getCategoryFromLotName(item.lot_name)
+                category: item.category            }));
-            }));
         }
         if (typeof payload.server_count === 'number' && payload.server_count > 0) {
             serverCount = payload.server_count;
@@ -2738,8 +2729,8 @@ function renderSalePriceTable() {
     }
 
     const sortedCart = [...cart].sort((a, b) => {
-        const catA = (a.category || getCategoryFromLotName(a.lot_name)).toUpperCase();
+        const catA = ciStr(a.category);
-        const catB = (b.category || getCategoryFromLotName(b.lot_name)).toUpperCase();
+        const catB = ciStr(b.category);
         const orderA = categoryOrderMap[catA] || 9999;
         const orderB = categoryOrderMap[catB] || 9999;
         return orderA - orderB;
@@ -2842,8 +2833,8 @@ function calculateCustomPrice() {
     // Build adjusted prices table
     // Sort cart items by category display order
     const sortedCart = [...cart].sort((a, b) => {
-        const catA = (a.category || getCategoryFromLotName(a.lot_name)).toUpperCase();
+        const catA = ciStr(a.category);
-        const catB = (b.category || getCategoryFromLotName(b.lot_name)).toUpperCase();
+        const catB = ciStr(b.category);
         const orderA = categoryOrderMap[catA] || 9999;
         const orderB = categoryOrderMap[catB] || 9999;
         return orderA - orderB;
@@ -4153,8 +4144,8 @@ async function renderPricingTab() {
 
         if (!bomRows.length) {
             const sortedByCategory = [...cart].sort((a, b) => {
-                const catA = (a.category || getCategoryFromLotName(a.lot_name)).toUpperCase();
+                const catA = ciStr(a.category);
-                const catB = (b.category || getCategoryFromLotName(b.lot_name)).toUpperCase();
+                const catB = ciStr(b.category);
                 return (categoryOrderMap[catA] || 9999) - (categoryOrderMap[catB] || 9999);
             });
             sortedByCategory.forEach(item => { _pushCartRow(item, false); coveredLots.add(item.lot_name); });