package store import ( "context" "database/sql" "errors" ) // Setting returns a global setting or the empty string. func (s *Store) Setting(ctx context.Context, key string) string { var value string err := s.db.QueryRowContext(ctx, "SELECT value FROM settings WHERE key=?", key).Scan(&value) if err != nil { return "" } return value } // SetSetting stores a global setting. func (s *Store) SetSetting(ctx context.Context, key, value string) error { _, err := s.db.ExecContext(ctx, ` INSERT INTO settings(key, value) VALUES(?, ?) ON CONFLICT(key) DO UPDATE SET value=excluded.value`, key, value) return err } // RemoveSetting deletes a global setting. func (s *Store) RemoveSetting(ctx context.Context, key string) error { _, err := s.db.ExecContext(ctx, "DELETE FROM settings WHERE key=?", key) return err } // TenantSetting returns a tenant-scoped setting or the empty string. func (s *Store) TenantSetting(ctx context.Context, tenantID, key string) string { var value string err := s.db.QueryRowContext(ctx, "SELECT value FROM tenant_settings WHERE tenant_id=? AND key=?", tenantID, key).Scan(&value) if err != nil { return "" } return value } // SetTenantSetting stores a tenant-scoped setting. func (s *Store) SetTenantSetting(ctx context.Context, tenantID, key, value string) error { _, err := s.db.ExecContext(ctx, ` INSERT INTO tenant_settings(tenant_id, key, value) VALUES(?, ?, ?) ON CONFLICT(tenant_id, key) DO UPDATE SET value=excluded.value`, tenantID, key, value) return err } // AllTenantSettings loads the settings map of one tenant. func (s *Store) AllTenantSettings(ctx context.Context, tenantID string) (map[string]string, error) { rows, err := s.db.QueryContext(ctx, "SELECT key, value FROM tenant_settings WHERE tenant_id=?", tenantID) if err != nil { return nil, err } defer rows.Close() out := map[string]string{} for rows.Next() { var key, value string if err := rows.Scan(&key, &value); err != nil { return nil, err } out[key] = value } return out, rows.Err() } // CountTenantData returns a small summary used by admin screens. func (s *Store) CountTenantData(ctx context.Context, tenantID string) (map[string]int, error) { counts := map[string]int{} queries := map[string]string{ "churches": "SELECT COUNT(*) FROM churches WHERE tenant_id=?", "people": "SELECT COUNT(*) FROM people WHERE tenant_id=?", "templates": "SELECT COUNT(*) FROM service_templates WHERE tenant_id=?", "services": "SELECT COUNT(*) FROM services WHERE tenant_id=?", "assignments": "SELECT COUNT(*) FROM assignments WHERE tenant_id=?", } for key, query := range queries { var value int if err := s.db.QueryRowContext(ctx, query, tenantID).Scan(&value); err != nil { return nil, err } counts[key] = value } return counts, nil } // DeleteAllTenantData empties one tenant's planning data but keeps accounts. func (s *Store) DeleteAllTenantData(ctx context.Context, tenantID string) error { return s.transaction(ctx, func(tx *sql.Tx) error { statements := []string{ "DELETE FROM assignments WHERE tenant_id=?", "DELETE FROM services WHERE tenant_id=?", "DELETE FROM service_exceptions WHERE tenant_id=?", "DELETE FROM service_templates WHERE tenant_id=?", "DELETE FROM absences WHERE tenant_id=?", "DELETE FROM people WHERE tenant_id=?", "DELETE FROM churches WHERE tenant_id=?", "DELETE FROM dispatch_preferences WHERE tenant_id=?", "DELETE FROM dispatch_log WHERE tenant_id=?", "DELETE FROM tenant_settings WHERE tenant_id=?", } for _, statement := range statements { if _, err := tx.ExecContext(ctx, statement, tenantID); err != nil { return err } } return nil }) } // Healthy verifies that the database answers a trivial query. func (s *Store) Healthy(ctx context.Context) error { var value int err := s.db.QueryRowContext(ctx, "SELECT 1").Scan(&value) if err != nil { return err } if value != 1 { return errors.New("unerwartete Datenbankantwort") } return nil }