- ConnectionManager reuses a stale-but-healthy pool instead of dialing a new one every 30s, and closes every pool it replaces (one client held ~30 connections). Pool capped at 2 connections, idle released after 1 min. - Background sync every 1 min with ±30% jitter, scheduled from cycle start; users-status online threshold = interval × 1.3. One heartbeat per cycle. - Partnumber books: read headers only, fetch partnumbers_json per book when new/incomplete; empty book counts as complete; an incomplete book is re-pulled once per process (server book lists BOT_AGIBOT_G2_PERF missing from qt_partnumber_book_items). - NeedSync in one UNION ALL query; SyncQtSettings skips unchanged rewrite. - Migration 035: server-maintained server_updated_at on qt_configurations and qt_projects. Clients pull only changed rows after one full pull per process; servers without 035 and old clients keep full pulls. - Migrator: fresh GORM statement per verify query and history insert; files with two verify checks failed to record. ADL: bible-local/decisions/2026-10-26-mariadb-single-pool.md, bible-local/decisions/2026-10-26-incremental-config-project-pull.md Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
200 lines
5.7 KiB
Go
200 lines
5.7 KiB
Go
package repository
|
|
|
|
import (
|
|
"git.mchus.pro/mchus/quoteforge/internal/localdb"
|
|
"gorm.io/gorm"
|
|
"gorm.io/gorm/clause"
|
|
)
|
|
|
|
// PartnumberBookRepository provides read-only access to local partnumber book snapshots.
|
|
type PartnumberBookRepository struct {
|
|
db *gorm.DB
|
|
}
|
|
|
|
func NewPartnumberBookRepository(db *gorm.DB) *PartnumberBookRepository {
|
|
return &PartnumberBookRepository{db: db}
|
|
}
|
|
|
|
// GetActiveBook returns the most recently active local partnumber book.
|
|
func (r *PartnumberBookRepository) GetActiveBook() (*localdb.LocalPartnumberBook, error) {
|
|
var book localdb.LocalPartnumberBook
|
|
err := r.db.Where("is_active = 1").Order("created_at DESC, id DESC").First(&book).Error
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &book, nil
|
|
}
|
|
|
|
// GetBookItems returns all items for the given local book ID.
|
|
func (r *PartnumberBookRepository) GetBookItems(bookID uint) ([]localdb.LocalPartnumberBookItem, error) {
|
|
book, err := r.getBook(bookID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
items, _, err := r.listCatalogItems(book.PartnumbersJSON, "", 0, 0)
|
|
return items, err
|
|
}
|
|
|
|
// GetBookItemsPage returns items for the given local book ID with optional search and pagination.
|
|
func (r *PartnumberBookRepository) GetBookItemsPage(bookID uint, search string, page, perPage int) ([]localdb.LocalPartnumberBookItem, int64, error) {
|
|
if page < 1 {
|
|
page = 1
|
|
}
|
|
if perPage < 1 {
|
|
perPage = 100
|
|
}
|
|
|
|
book, err := r.getBook(bookID)
|
|
if err != nil {
|
|
return nil, 0, err
|
|
}
|
|
return r.listCatalogItems(book.PartnumbersJSON, search, page, perPage)
|
|
}
|
|
|
|
// FindLotByPartnumber looks up a partnumber in the active book and returns the matching items.
|
|
func (r *PartnumberBookRepository) FindLotByPartnumber(bookID uint, partnumber string) ([]localdb.LocalPartnumberBookItem, error) {
|
|
book, err := r.getBook(bookID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
found := false
|
|
for _, pn := range book.PartnumbersJSON {
|
|
if pn == partnumber {
|
|
found = true
|
|
break
|
|
}
|
|
}
|
|
if !found {
|
|
return nil, nil
|
|
}
|
|
var items []localdb.LocalPartnumberBookItem
|
|
err = r.db.Where("partnumber = ?", partnumber).Find(&items).Error
|
|
return items, err
|
|
}
|
|
|
|
// ListBooks returns all local partnumber books ordered newest first.
|
|
func (r *PartnumberBookRepository) ListBooks() ([]localdb.LocalPartnumberBook, error) {
|
|
var books []localdb.LocalPartnumberBook
|
|
err := r.db.Order("created_at DESC, id DESC").Find(&books).Error
|
|
return books, err
|
|
}
|
|
|
|
// SaveBook saves a new partnumber book snapshot.
|
|
func (r *PartnumberBookRepository) SaveBook(book *localdb.LocalPartnumberBook) error {
|
|
return r.db.Save(book).Error
|
|
}
|
|
|
|
// SaveBookItems upserts canonical PN catalog rows.
|
|
func (r *PartnumberBookRepository) SaveBookItems(items []localdb.LocalPartnumberBookItem) error {
|
|
if len(items) == 0 {
|
|
return nil
|
|
}
|
|
return r.db.Clauses(clause.OnConflict{
|
|
Columns: []clause.Column{{Name: "partnumber"}},
|
|
DoUpdates: clause.AssignmentColumns([]string{
|
|
"lots_json",
|
|
"description",
|
|
}),
|
|
}).CreateInBatches(items, 500).Error
|
|
}
|
|
|
|
// CountBookItems returns the number of items for a given local book ID.
|
|
func (r *PartnumberBookRepository) CountBookItems(bookID uint) int64 {
|
|
book, err := r.getBook(bookID)
|
|
if err != nil {
|
|
return 0
|
|
}
|
|
return int64(len(book.PartnumbersJSON))
|
|
}
|
|
|
|
func (r *PartnumberBookRepository) CountDistinctLots(bookID uint) int64 {
|
|
items, err := r.GetBookItems(bookID)
|
|
if err != nil {
|
|
return 0
|
|
}
|
|
seen := make(map[string]struct{})
|
|
for _, item := range items {
|
|
for _, lot := range item.LotsJSON {
|
|
if lot.LotName == "" {
|
|
continue
|
|
}
|
|
seen[lot.LotName] = struct{}{}
|
|
}
|
|
}
|
|
return int64(len(seen))
|
|
}
|
|
|
|
func (r *PartnumberBookRepository) HasAllBookItems(bookID uint) bool {
|
|
book, err := r.getBook(bookID)
|
|
if err != nil {
|
|
return false
|
|
}
|
|
if len(book.PartnumbersJSON) == 0 {
|
|
return true
|
|
}
|
|
var count int64
|
|
if err := r.db.Model(&localdb.LocalPartnumberBookItem{}).
|
|
Where("partnumber IN ?", []string(book.PartnumbersJSON)).
|
|
Count(&count).Error; err != nil {
|
|
return false
|
|
}
|
|
return count == int64(len(book.PartnumbersJSON))
|
|
}
|
|
|
|
// MissingBookItems returns the book's partnumbers that have no local catalog row.
|
|
func (r *PartnumberBookRepository) MissingBookItems(bookID uint) []string {
|
|
book, err := r.getBook(bookID)
|
|
if err != nil || len(book.PartnumbersJSON) == 0 {
|
|
return nil
|
|
}
|
|
var present []string
|
|
if err := r.db.Model(&localdb.LocalPartnumberBookItem{}).
|
|
Where("partnumber IN ?", []string(book.PartnumbersJSON)).
|
|
Pluck("partnumber", &present).Error; err != nil {
|
|
return nil
|
|
}
|
|
have := make(map[string]struct{}, len(present))
|
|
for _, pn := range present {
|
|
have[pn] = struct{}{}
|
|
}
|
|
var missing []string
|
|
for _, pn := range book.PartnumbersJSON {
|
|
if _, ok := have[pn]; !ok {
|
|
missing = append(missing, pn)
|
|
}
|
|
}
|
|
return missing
|
|
}
|
|
|
|
func (r *PartnumberBookRepository) getBook(bookID uint) (*localdb.LocalPartnumberBook, error) {
|
|
var book localdb.LocalPartnumberBook
|
|
if err := r.db.First(&book, bookID).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
return &book, nil
|
|
}
|
|
|
|
func (r *PartnumberBookRepository) listCatalogItems(partnumbers localdb.LocalStringList, search string, page, perPage int) ([]localdb.LocalPartnumberBookItem, int64, error) {
|
|
if len(partnumbers) == 0 {
|
|
return []localdb.LocalPartnumberBookItem{}, 0, nil
|
|
}
|
|
|
|
query := r.db.Model(&localdb.LocalPartnumberBookItem{}).Where("partnumber IN ?", []string(partnumbers))
|
|
if search != "" {
|
|
trimmedSearch := "%" + search + "%"
|
|
query = query.Where("partnumber LIKE ? OR CAST(lots_json AS TEXT) LIKE ? OR description LIKE ?", trimmedSearch, trimmedSearch, trimmedSearch)
|
|
}
|
|
|
|
var total int64
|
|
if err := query.Count(&total).Error; err != nil {
|
|
return nil, 0, err
|
|
}
|
|
|
|
var items []localdb.LocalPartnumberBookItem
|
|
if page > 0 && perPage > 0 {
|
|
query = query.Offset((page - 1) * perPage).Limit(perPage)
|
|
}
|
|
err := query.Order("partnumber ASC, id ASC").Find(&items).Error
|
|
return items, total, err
|
|
}
|