felhom.eu/hub/internal/store/offsite_keys.go

package store

import (
	"database/sql"
	"time"
)

// OffsiteKey is the registrar's record of the box key the hub installed pinned (decision 69).
type OffsiteKey struct {
	CustomerID  string
	Fingerprint string
	InstalledAt time.Time
	ConfirmedAt time.Time // zero = the box has not confirmed it yet
}

// RecordOffsiteKeyInstalled records (last-write-wins) the key the hub just installed; confirmation resets.
func (s *Store) RecordOffsiteKeyInstalled(customerID, fp string) error {
	_, err := s.db.Exec(`
		INSERT INTO offsite_keys (customer_id, fingerprint, installed_at, confirmed_at) VALUES (?, ?, datetime('now'), NULL)
		ON CONFLICT(customer_id) DO UPDATE SET fingerprint = excluded.fingerprint, installed_at = datetime('now'), confirmed_at = NULL`,
		customerID, fp)
	return err
}

// RecordOffsiteKeyConfirmed marks the installed key confirmed by the box; false when fp is not the key on record.
func (s *Store) RecordOffsiteKeyConfirmed(customerID, fp string) (bool, error) {
	res, err := s.db.Exec(`UPDATE offsite_keys SET confirmed_at = datetime('now') WHERE customer_id = ? AND fingerprint = ?`, customerID, fp)
	if err != nil {
		return false, err
	}
	n, _ := res.RowsAffected()
	return n > 0, nil
}

// GetOffsiteKey returns the record, or (nil, nil) when none exists.
func (s *Store) GetOffsiteKey(customerID string) (*OffsiteKey, error) {
	var k OffsiteKey
	var inst string
	var conf sql.NullString
	err := s.db.QueryRow(`SELECT customer_id, fingerprint, installed_at, confirmed_at FROM offsite_keys WHERE customer_id = ?`, customerID).
		Scan(&k.CustomerID, &k.Fingerprint, &inst, &conf)
	if err == sql.ErrNoRows {
		return nil, nil
	}
	if err != nil {
		return nil, err
	}
	k.InstalledAt = parseSQLiteTime(inst)
	if conf.Valid {
		k.ConfirmedAt = parseSQLiteTime(conf.String)
	}
	return &k, nil
}

// OffsiteWindowOpen reports whether a clean-up window is open for the customer right now (decision 68):
// a window row not closed and not past its closes_by. Errors read as "closed" — the key check then
// alarms on a window line, which is the safe side.
func (s *Store) OffsiteWindowOpen(customerID string) bool {
	var n int
	err := s.db.QueryRow(`SELECT COUNT(*) FROM offsite_windows WHERE customer_id = ? AND closed_at IS NULL AND closes_by > datetime('now')`, customerID).Scan(&n)
	return err == nil && n > 0
}

// OffsiteWindow is one clean-up window (decision 68).
type OffsiteWindow struct {
	ID          int64
	CustomerID  string
	OpenedAt    time.Time
	ClosesBy    time.Time
	ClosedAt    time.Time
	CountBefore int
	CountAfter  int
	BoxResult   string
	CloseReason string
}

// OpenOffsiteWindowRow records a window the hub just opened.
func (s *Store) OpenOffsiteWindowRow(customerID string, closesBy time.Time, countBefore int) (int64, error) {
	res, err := s.db.Exec(`INSERT INTO offsite_windows (customer_id, opened_at, closes_by, count_before) VALUES (?, datetime('now'), ?, ?)`,
		customerID, closesBy.UTC().Format("2006-01-02 15:04:05"), countBefore)
	if err != nil {
		return 0, err
	}
	return res.LastInsertId()
}

// CloseOffsiteWindowRow closes a window (idempotent: an already-closed row is not touched).
func (s *Store) CloseOffsiteWindowRow(id int64, countAfter int, boxResult, reason string) (bool, error) {
	res, err := s.db.Exec(`UPDATE offsite_windows SET closed_at = datetime('now'), count_after = ?, box_result = ?, close_reason = ? WHERE id = ? AND closed_at IS NULL`,
		countAfter, boxResult, reason, id)
	if err != nil {
		return false, err
	}
	n, _ := res.RowsAffected()
	return n > 0, nil
}

// GetOffsiteWindow returns one window row, or (nil, nil).
func (s *Store) GetOffsiteWindow(id int64) (*OffsiteWindow, error) {
	var w OffsiteWindow
	var opened, closesBy string
	var closed, boxRes, reason sql.NullString
	var before, after sql.NullInt64
	err := s.db.QueryRow(`SELECT id, customer_id, opened_at, closes_by, closed_at, count_before, count_after, box_result, close_reason FROM offsite_windows WHERE id = ?`, id).
		Scan(&w.ID, &w.CustomerID, &opened, &closesBy, &closed, &before, &after, &boxRes, &reason)
	if err == sql.ErrNoRows {
		return nil, nil
	}
	if err != nil {
		return nil, err
	}
	w.OpenedAt, w.ClosesBy = parseSQLiteTime(opened), parseSQLiteTime(closesBy)
	if closed.Valid {
		w.ClosedAt = parseSQLiteTime(closed.String)
	}
	w.CountBefore, w.CountAfter = int(before.Int64), int(after.Int64)
	w.BoxResult, w.CloseReason = boxRes.String, reason.String
	return &w, nil
}

// LastOffsiteWindowOpened returns when the customer's most recent window was opened (zero = never).
func (s *Store) LastOffsiteWindowOpened(customerID string) time.Time {
	var v sql.NullString
	if err := s.db.QueryRow(`SELECT MAX(opened_at) FROM offsite_windows WHERE customer_id = ?`, customerID).Scan(&v); err != nil || !v.Valid {
		return time.Time{}
	}
	return parseSQLiteTime(v.String)
}

// ExpiredOffsiteWindows lists windows still open past their closes_by.
func (s *Store) ExpiredOffsiteWindows() ([]OffsiteWindow, error) {
	rows, err := s.db.Query(`SELECT id, customer_id FROM offsite_windows WHERE closed_at IS NULL AND closes_by <= datetime('now')`)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var out []OffsiteWindow
	for rows.Next() {
		var w OffsiteWindow
		if err := rows.Scan(&w.ID, &w.CustomerID); err != nil {
			return nil, err
		}
		out = append(out, w)
	}
	return out, rows.Err()
}

const offsiteWindowsEnabledKey = "offsite_prune_windows_enabled"

// OffsiteWindowsEnabled — the operator switch for WEEKLY windows (decision 68). Off by default: the
// interim is "nothing prunes" until the operator turns the weekly window on.
func (s *Store) OffsiteWindowsEnabled() bool { return s.getSetting(offsiteWindowsEnabledKey) == "on" }

// SetOffsiteWindowsEnabled flips the weekly switch.
func (s *Store) SetOffsiteWindowsEnabled(on bool) error {
	v := ""
	if on {
		v = "on"
	}
	return s.setSetting(offsiteWindowsEnabledKey, v)
}

// GrantOffsiteWindowOnce lets the customer's NEXT window request through regardless of the weekly
// cadence (operator one-shot).
func (s *Store) GrantOffsiteWindowOnce(customerID string) error {
	return s.setSetting("offsite_window_grant:"+customerID, "1")
}

// TakeOffsiteWindowGrant consumes a one-shot grant; true when one was present.
func (s *Store) TakeOffsiteWindowGrant(customerID string) bool {
	k := "offsite_window_grant:" + customerID
	if s.getSetting(k) != "1" {
		return false
	}
	_ = s.setSetting(k, "")
	return true
}