Add projects table controls and sync status tab with app version

internal/handlers/sync.go

@@ -17,14 +17,16 @@ import (
 
 // SyncHandler handles sync API endpoints
 type SyncHandler struct {
-	localDB     *localdb.LocalDB
-	syncService *sync.Service
-	connMgr     *db.ConnectionManager
-	tmpl        *template.Template
+	localDB           *localdb.LocalDB
+	syncService       *sync.Service
+	connMgr           *db.ConnectionManager
+	autoSyncInterval  time.Duration
+	onlineGraceFactor float64
+	tmpl              *template.Template
 }
 
 // NewSyncHandler creates a new sync handler
-func NewSyncHandler(localDB *localdb.LocalDB, syncService *sync.Service, connMgr *db.ConnectionManager, templatesPath string) (*SyncHandler, error) {
+func NewSyncHandler(localDB *localdb.LocalDB, syncService *sync.Service, connMgr *db.ConnectionManager, templatesPath string, autoSyncInterval time.Duration) (*SyncHandler, error) {
 	// Load sync_status partial template
 	partialPath := filepath.Join(templatesPath, "partials", "sync_status.html")
 	var tmpl *template.Template
@@ -39,10 +41,12 @@ func NewSyncHandler(localDB *localdb.LocalDB, syncService *sync.Service, connMgr
 	}
 
 	return &SyncHandler{
-		localDB:     localDB,
-		syncService: syncService,
-		connMgr:     connMgr,
-		tmpl:        tmpl,
+		localDB:           localDB,
+		syncService:       syncService,
+		connMgr:           connMgr,
+		autoSyncInterval:  autoSyncInterval,
+		onlineGraceFactor: 1.10,
+		tmpl:              tmpl,
 	}, nil
 }
 
@@ -173,6 +177,7 @@ func (h *SyncHandler) SyncPricelists(c *gin.Context) {
 		Synced:   synced,
 		Duration: time.Since(startTime).String(),
 	})
+	h.syncService.RecordSyncHeartbeat()
 }
 
 // SyncAllResponse represents result of full sync
@@ -238,6 +243,7 @@ func (h *SyncHandler) SyncAll(c *gin.Context) {
 		PricelistsSynced: pricelistsSynced,
 		Duration:         time.Since(startTime).String(),
 	})
+	h.syncService.RecordSyncHeartbeat()
 }
 
 // checkOnline checks if MariaDB is accessible
@@ -273,6 +279,7 @@ func (h *SyncHandler) PushPendingChanges(c *gin.Context) {
 		Synced:   pushed,
 		Duration: time.Since(startTime).String(),
 	})
+	h.syncService.RecordSyncHeartbeat()
 }
 
 // GetPendingCount returns the number of pending changes
@@ -308,6 +315,14 @@ type SyncInfoResponse struct {
 	Errors     []SyncError `json:"errors,omitempty"`
 }
 
+type SyncUsersStatusResponse struct {
+	IsOnline                bool                  `json:"is_online"`
+	AutoSyncIntervalSeconds int64                 `json:"auto_sync_interval_seconds"`
+	OnlineThresholdSeconds  int64                 `json:"online_threshold_seconds"`
+	GeneratedAt             time.Time             `json:"generated_at"`
+	Users                   []sync.UserSyncStatus `json:"users"`
+}
+
 // SyncError represents a sync error
 type SyncError struct {
 	Timestamp time.Time `json:"timestamp"`
@@ -364,6 +379,40 @@ func (h *SyncHandler) GetInfo(c *gin.Context) {
 	})
 }
 
+// GetUsersStatus returns last sync timestamps for users with sync heartbeats.
+// GET /api/sync/users-status
+func (h *SyncHandler) GetUsersStatus(c *gin.Context) {
+	threshold := time.Duration(float64(h.autoSyncInterval) * h.onlineGraceFactor)
+	isOnline := h.checkOnline()
+
+	if !isOnline {
+		c.JSON(http.StatusOK, SyncUsersStatusResponse{
+			IsOnline:                false,
+			AutoSyncIntervalSeconds: int64(h.autoSyncInterval.Seconds()),
+			OnlineThresholdSeconds:  int64(threshold.Seconds()),
+			GeneratedAt:             time.Now().UTC(),
+			Users:                   []sync.UserSyncStatus{},
+		})
+		return
+	}
+
+	users, err := h.syncService.ListUserSyncStatuses(threshold)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{
+			"error": err.Error(),
+		})
+		return
+	}
+
+	c.JSON(http.StatusOK, SyncUsersStatusResponse{
+		IsOnline:                true,
+		AutoSyncIntervalSeconds: int64(h.autoSyncInterval.Seconds()),
+		OnlineThresholdSeconds:  int64(threshold.Seconds()),
+		GeneratedAt:             time.Now().UTC(),
+		Users:                   users,
+	})
+}
+
 // SyncStatusPartial renders the sync status partial for htmx
 // GET /partials/sync-status
 func (h *SyncHandler) SyncStatusPartial(c *gin.Context) {

internal/services/sync/service.go

@@ -5,6 +5,7 @@ import (
 	"errors"
 	"fmt"
 	"log/slog"
+	"strings"
 	"time"
 
 	"git.mchus.pro/mchus/quoteforge/internal/appmeta"
@@ -49,6 +50,13 @@ type SyncStatus struct {
 	NeedsSync        bool       `json:"needs_sync"`
 }
 
+type UserSyncStatus struct {
+	Username   string    `json:"username"`
+	LastSyncAt time.Time `json:"last_sync_at"`
+	AppVersion string    `json:"app_version,omitempty"`
+	IsOnline   bool      `json:"is_online"`
+}
+
 // ConfigImportResult represents server->local configuration import stats.
 type ConfigImportResult struct {
 	Imported int `json:"imported"`
@@ -301,11 +309,104 @@ func (s *Service) SyncPricelists() (int, error) {
 
 	// Update last sync time
 	s.localDB.SetLastSyncTime(time.Now())
+	s.RecordSyncHeartbeat()
 
 	slog.Info("pricelist sync completed", "synced", synced, "total", len(serverPricelists))
 	return synced, nil
 }
 
+// RecordSyncHeartbeat updates shared sync heartbeat for current DB user.
+// Only users with write rights are expected to be able to update this table.
+func (s *Service) RecordSyncHeartbeat() {
+	username := strings.TrimSpace(s.localDB.GetDBUser())
+	if username == "" {
+		return
+	}
+
+	mariaDB, err := s.getDB()
+	if err != nil || mariaDB == nil {
+		return
+	}
+
+	if err := ensureUserSyncStatusTable(mariaDB); err != nil {
+		slog.Warn("sync heartbeat: failed to ensure table", "error", err)
+		return
+	}
+
+	now := time.Now().UTC()
+	if err := mariaDB.Exec(`
+		INSERT INTO qt_pricelist_sync_status (username, last_sync_at, updated_at, app_version)
+		VALUES (?, ?, ?, ?)
+		ON DUPLICATE KEY UPDATE
+			last_sync_at = VALUES(last_sync_at),
+			updated_at = VALUES(updated_at),
+			app_version = VALUES(app_version)
+	`, username, now, now, appmeta.Version()).Error; err != nil {
+		slog.Debug("sync heartbeat: skipped", "username", username, "error", err)
+	}
+}
+
+// ListUserSyncStatuses returns users who have recorded sync heartbeat.
+func (s *Service) ListUserSyncStatuses(onlineThreshold time.Duration) ([]UserSyncStatus, error) {
+	mariaDB, err := s.getDB()
+	if err != nil || mariaDB == nil {
+		return nil, ErrOffline
+	}
+
+	if err := ensureUserSyncStatusTable(mariaDB); err != nil {
+		return nil, fmt.Errorf("ensure sync status table: %w", err)
+	}
+
+	type row struct {
+		Username   string    `gorm:"column:username"`
+		LastSyncAt time.Time `gorm:"column:last_sync_at"`
+		AppVersion string    `gorm:"column:app_version"`
+	}
+	var rows []row
+	if err := mariaDB.Raw(`
+		SELECT username, last_sync_at, COALESCE(app_version, '') AS app_version
+		FROM qt_pricelist_sync_status
+		ORDER BY last_sync_at DESC, username ASC
+	`).Scan(&rows).Error; err != nil {
+		return nil, fmt.Errorf("load sync status rows: %w", err)
+	}
+
+	now := time.Now().UTC()
+	result := make([]UserSyncStatus, 0, len(rows))
+	for i := range rows {
+		r := rows[i]
+		result = append(result, UserSyncStatus{
+			Username:   r.Username,
+			LastSyncAt: r.LastSyncAt,
+			AppVersion: strings.TrimSpace(r.AppVersion),
+			IsOnline:   now.Sub(r.LastSyncAt) <= onlineThreshold,
+		})
+	}
+
+	return result, nil
+}
+
+func ensureUserSyncStatusTable(db *gorm.DB) error {
+	if err := db.Exec(`
+		CREATE TABLE IF NOT EXISTS qt_pricelist_sync_status (
+			username VARCHAR(100) NOT NULL,
+			last_sync_at DATETIME NOT NULL,
+			updated_at DATETIME NOT NULL,
+			app_version VARCHAR(64) NULL,
+			PRIMARY KEY (username),
+			INDEX idx_qt_pricelist_sync_status_last_sync (last_sync_at)
+		)
+	`).Error; err != nil {
+		return err
+	}
+
+	// Backward compatibility for environments where table was created without app_version.
+	return db.Exec(`
+		ALTER TABLE qt_pricelist_sync_status
+		ADD COLUMN IF NOT EXISTS app_version VARCHAR(64) NULL
+	`).Error
+}
+
 // SyncPricelistItems synchronizes items for a specific pricelist
 func (s *Service) SyncPricelistItems(localPricelistID uint) (int, error) {
 	// Get local pricelist
@@ -711,10 +812,10 @@ func (s *Service) pushConfigurationUpdate(change *localdb.PendingChange) error {
 				cfg.ID = serverCfg.ID
 			}
 
-				// Update local with server ID
-				serverID := cfg.ID
-				localCfg.ServerID = &serverID
-				s.localDB.SaveConfiguration(localCfg)
+			// Update local with server ID
+			serverID := cfg.ID
+			localCfg.ServerID = &serverID
+			s.localDB.SaveConfiguration(localCfg)
 		} else {
 			cfg.ID = *localCfg.ServerID
 		}

internal/services/sync/worker.go

@@ -83,7 +83,11 @@ func (w *Worker) runSync() {
 	err = w.service.SyncPricelistsIfNeeded()
 	if err != nil {
 		w.logger.Warn("background sync: failed to sync pricelists", "error", err)
+		return
 	}
 
+	// Mark user's sync heartbeat (used for online/offline status in UI).
+	w.service.RecordSyncHeartbeat()
+
 	w.logger.Info("background sync cycle completed")
 }