Michael Chus
be77256d4e
Implements automatic background synchronization every 5 minutes: - Worker pushes pending changes to server (PushPendingChanges) - Worker pulls new pricelists (SyncPricelistsIfNeeded) - Graceful shutdown with context cancellation - Automatic online/offline detection via DB ping New files: - internal/services/sync/worker.go - Background sync worker - internal/services/local_configuration.go - Local-first CRUD - internal/localdb/converters.go - MariaDB ↔ SQLite converters Extended sync infrastructure: - Pending changes queue (pending_changes table) - Push/pull sync endpoints (/api/sync/push, /pending) - ConfigurationGetter interface for handler compatibility - LocalConfigurationService replaces ConfigurationService All configuration operations now run through SQLite with automatic background sync to MariaDB when online. Phase 2.5 nearly complete. Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>
446 lines
11 KiB
Go
446 lines
11 KiB
Go
package services
|
|
|
|
import (
|
|
"errors"
|
|
"time"
|
|
|
|
"github.com/google/uuid"
|
|
"git.mchus.pro/mchus/quoteforge/internal/models"
|
|
"git.mchus.pro/mchus/quoteforge/internal/repository"
|
|
)
|
|
|
|
var (
|
|
ErrConfigNotFound = errors.New("configuration not found")
|
|
ErrConfigForbidden = errors.New("access to configuration forbidden")
|
|
)
|
|
|
|
// ConfigurationGetter is an interface for services that can retrieve configurations
|
|
// Used by handlers to work with both ConfigurationService and LocalConfigurationService
|
|
type ConfigurationGetter interface {
|
|
GetByUUID(uuid string, userID uint) (*models.Configuration, error)
|
|
}
|
|
|
|
type ConfigurationService struct {
|
|
configRepo *repository.ConfigurationRepository
|
|
componentRepo *repository.ComponentRepository
|
|
quoteService *QuoteService
|
|
}
|
|
|
|
func NewConfigurationService(
|
|
configRepo *repository.ConfigurationRepository,
|
|
componentRepo *repository.ComponentRepository,
|
|
quoteService *QuoteService,
|
|
) *ConfigurationService {
|
|
return &ConfigurationService{
|
|
configRepo: configRepo,
|
|
componentRepo: componentRepo,
|
|
quoteService: quoteService,
|
|
}
|
|
}
|
|
|
|
type CreateConfigRequest struct {
|
|
Name string `json:"name"`
|
|
Items models.ConfigItems `json:"items"`
|
|
CustomPrice *float64 `json:"custom_price"`
|
|
Notes string `json:"notes"`
|
|
IsTemplate bool `json:"is_template"`
|
|
ServerCount int `json:"server_count"`
|
|
}
|
|
|
|
func (s *ConfigurationService) Create(userID uint, req *CreateConfigRequest) (*models.Configuration, error) {
|
|
total := req.Items.Total()
|
|
|
|
// If server count is greater than 1, multiply the total by server count
|
|
if req.ServerCount > 1 {
|
|
total *= float64(req.ServerCount)
|
|
}
|
|
|
|
config := &models.Configuration{
|
|
UUID: uuid.New().String(),
|
|
UserID: userID,
|
|
Name: req.Name,
|
|
Items: req.Items,
|
|
TotalPrice: &total,
|
|
CustomPrice: req.CustomPrice,
|
|
Notes: req.Notes,
|
|
IsTemplate: req.IsTemplate,
|
|
ServerCount: req.ServerCount,
|
|
}
|
|
|
|
if err := s.configRepo.Create(config); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Record usage stats
|
|
_ = s.quoteService.RecordUsage(req.Items)
|
|
|
|
return config, nil
|
|
}
|
|
|
|
func (s *ConfigurationService) GetByUUID(uuid string, userID uint) (*models.Configuration, error) {
|
|
config, err := s.configRepo.GetByUUID(uuid)
|
|
if err != nil {
|
|
return nil, ErrConfigNotFound
|
|
}
|
|
|
|
// Allow access if user owns config or it's a template
|
|
if config.UserID != userID && !config.IsTemplate {
|
|
return nil, ErrConfigForbidden
|
|
}
|
|
|
|
return config, nil
|
|
}
|
|
|
|
func (s *ConfigurationService) Update(uuid string, userID uint, req *CreateConfigRequest) (*models.Configuration, error) {
|
|
config, err := s.configRepo.GetByUUID(uuid)
|
|
if err != nil {
|
|
return nil, ErrConfigNotFound
|
|
}
|
|
|
|
if config.UserID != userID {
|
|
return nil, ErrConfigForbidden
|
|
}
|
|
|
|
total := req.Items.Total()
|
|
|
|
// If server count is greater than 1, multiply the total by server count
|
|
if req.ServerCount > 1 {
|
|
total *= float64(req.ServerCount)
|
|
}
|
|
|
|
config.Name = req.Name
|
|
config.Items = req.Items
|
|
config.TotalPrice = &total
|
|
config.CustomPrice = req.CustomPrice
|
|
config.Notes = req.Notes
|
|
config.IsTemplate = req.IsTemplate
|
|
config.ServerCount = req.ServerCount
|
|
|
|
if err := s.configRepo.Update(config); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return config, nil
|
|
}
|
|
|
|
func (s *ConfigurationService) Delete(uuid string, userID uint) error {
|
|
config, err := s.configRepo.GetByUUID(uuid)
|
|
if err != nil {
|
|
return ErrConfigNotFound
|
|
}
|
|
|
|
if config.UserID != userID {
|
|
return ErrConfigForbidden
|
|
}
|
|
|
|
return s.configRepo.Delete(config.ID)
|
|
}
|
|
|
|
func (s *ConfigurationService) Rename(uuid string, userID uint, newName string) (*models.Configuration, error) {
|
|
config, err := s.configRepo.GetByUUID(uuid)
|
|
if err != nil {
|
|
return nil, ErrConfigNotFound
|
|
}
|
|
|
|
if config.UserID != userID {
|
|
return nil, ErrConfigForbidden
|
|
}
|
|
|
|
config.Name = newName
|
|
|
|
if err := s.configRepo.Update(config); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return config, nil
|
|
}
|
|
|
|
func (s *ConfigurationService) Clone(configUUID string, userID uint, newName string) (*models.Configuration, error) {
|
|
original, err := s.GetByUUID(configUUID, userID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Create copy with new UUID and name
|
|
total := original.Items.Total()
|
|
|
|
// If server count is greater than 1, multiply the total by server count
|
|
if original.ServerCount > 1 {
|
|
total *= float64(original.ServerCount)
|
|
}
|
|
|
|
clone := &models.Configuration{
|
|
UUID: uuid.New().String(),
|
|
UserID: userID,
|
|
Name: newName,
|
|
Items: original.Items,
|
|
TotalPrice: &total,
|
|
CustomPrice: original.CustomPrice,
|
|
Notes: original.Notes,
|
|
IsTemplate: false, // Clone is never a template
|
|
ServerCount: original.ServerCount,
|
|
}
|
|
|
|
if err := s.configRepo.Create(clone); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return clone, nil
|
|
}
|
|
|
|
func (s *ConfigurationService) ListByUser(userID uint, page, perPage int) ([]models.Configuration, int64, error) {
|
|
if page < 1 {
|
|
page = 1
|
|
}
|
|
if perPage < 1 || perPage > 100 {
|
|
perPage = 20
|
|
}
|
|
offset := (page - 1) * perPage
|
|
|
|
return s.configRepo.ListByUser(userID, offset, perPage)
|
|
}
|
|
|
|
// 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
|
|
}
|
|
|
|
total := req.Items.Total()
|
|
if req.ServerCount > 1 {
|
|
total *= float64(req.ServerCount)
|
|
}
|
|
|
|
config.Name = req.Name
|
|
config.Items = req.Items
|
|
config.TotalPrice = &total
|
|
config.CustomPrice = req.CustomPrice
|
|
config.Notes = req.Notes
|
|
config.IsTemplate = req.IsTemplate
|
|
config.ServerCount = req.ServerCount
|
|
|
|
if err := s.configRepo.Update(config); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return config, nil
|
|
}
|
|
|
|
// 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, userID uint) (*models.Configuration, error) {
|
|
original, err := s.configRepo.GetByUUID(configUUID)
|
|
if err != nil {
|
|
return nil, ErrConfigNotFound
|
|
}
|
|
|
|
total := original.Items.Total()
|
|
if original.ServerCount > 1 {
|
|
total *= float64(original.ServerCount)
|
|
}
|
|
|
|
clone := &models.Configuration{
|
|
UUID: uuid.New().String(),
|
|
UserID: userID, // Use provided user ID
|
|
Name: newName,
|
|
Items: original.Items,
|
|
TotalPrice: &total,
|
|
CustomPrice: original.CustomPrice,
|
|
Notes: original.Notes,
|
|
IsTemplate: false,
|
|
ServerCount: original.ServerCount,
|
|
}
|
|
|
|
if err := s.configRepo.Create(clone); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return clone, 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
|
|
}
|
|
|
|
updatedItems := make(models.ConfigItems, len(config.Items))
|
|
for i, item := range config.Items {
|
|
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
|
|
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, userID uint) (*models.Configuration, error) {
|
|
config, err := s.configRepo.GetByUUID(uuid)
|
|
if err != nil {
|
|
return nil, ErrConfigNotFound
|
|
}
|
|
|
|
if config.UserID != userID {
|
|
return nil, ErrConfigForbidden
|
|
}
|
|
|
|
// Update prices for all items
|
|
updatedItems := make(models.ConfigItems, len(config.Items))
|
|
for i, item := range config.Items {
|
|
// Get current component price
|
|
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
|
|
|
|
// Set price update timestamp
|
|
now := time.Now()
|
|
config.PriceUpdatedAt = &now
|
|
|
|
if err := s.configRepo.Update(config); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return config, nil
|
|
}
|
|
|
|
// // 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)
|
|
// }
|