chore: refactor redis persistence to support all keys and types

internal/pkg/persistence/buckets.go

@@ -1,18 +0,0 @@
-package persistence
-
-import (
-	"log"
-
-	"github.com/AFASystems/presence/internal/pkg/model"
-	"github.com/boltdb/bolt"
-)
-
-func CreateBucketIfNotExists(db *bolt.DB) {
-	err := db.Update(func(tx *bolt.Tx) error {
-		_, err := tx.CreateBucketIfNotExists(model.World)
-		return err
-	})
-	if err != nil {
-		log.Fatal(err)
-	}
-}

internal/pkg/persistence/load.go

@@ -1,39 +0,0 @@
-package persistence
-
-import (
-	"bytes"
-	"encoding/gob"
-	"log"
-
-	"github.com/AFASystems/presence/internal/pkg/model"
-	"github.com/boltdb/bolt"
-)
-
-func LoadState(db *bolt.DB, ctx *model.AppContext) {
-	err := db.View(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket(model.World)
-		if bucket == nil {
-			return nil
-		}
-
-		decode := func(key string, dest interface{}) {
-			val := bucket.Get([]byte(key))
-			if val == nil {
-				return
-			}
-			buf := bytes.NewBuffer(val)
-			if err := gob.NewDecoder(buf).Decode(dest); err != nil {
-				log.Fatal("decode error: ", err)
-			}
-		}
-
-		decode("beaconsList", &ctx.Beacons.Beacons)
-		decode("buttonsList", &ctx.ButtonsList)
-		decode("settings", &ctx.Settings)
-		return nil
-	})
-
-	if err != nil {
-		log.Fatal(err)
-	}
-}

internal/pkg/persistence/persist.go

@@ -1,50 +0,0 @@
-package persistence
-
-import (
-	"bytes"
-	"encoding/gob"
-	"fmt"
-
-	"github.com/AFASystems/presence/internal/pkg/model"
-	"github.com/boltdb/bolt"
-)
-
-func PersistBeacons(beacons *model.BeaconsList) error {
-	buf := &bytes.Buffer{}
-	enc := gob.NewEncoder(buf)
-	if err := enc.Encode(beacons.Beacons); err != nil {
-		fmt.Println("error in encoding: ", err)
-		return err
-	}
-
-	key := []byte("beacons_list")
-	err := model.Db.Update(func(tx *bolt.Tx) error {
-		bucket, err := tx.CreateBucketIfNotExists(model.World)
-		if err != nil {
-			fmt.Println("error in creating a bucket")
-			return err
-		}
-		return bucket.Put(key, buf.Bytes())
-	})
-
-	return err
-}
-
-func PersistSettings(settings *model.Settings) error {
-	buf := &bytes.Buffer{}
-	enc := gob.NewEncoder(buf)
-	if err := enc.Encode(settings); err != nil {
-		return err
-	}
-
-	key := []byte("settings")
-	err := model.Db.Update(func(tx *bolt.Tx) error {
-		bucket, err := tx.CreateBucketIfNotExists(model.World)
-		if err != nil {
-			return err
-		}
-		return bucket.Put(key, buf.Bytes())
-	})
-
-	return err
-}

internal/pkg/redis/redis.go

@@ -5,84 +5,34 @@ import (
 	"encoding/json"
 	"fmt"
 
-	"github.com/AFASystems/presence/internal/pkg/model"
 	"github.com/redis/go-redis/v9"
 )
 
-func LoadBeaconsList(client *redis.Client, ctx context.Context) map[string]model.Beacon {
-	beaconsList, err := client.Get(ctx, "beaconsList").Result()
-	beaconsMap := make(map[string]model.Beacon)
+func LoadRedisMap[K comparable, V any, M map[K]V](client *redis.Client, ctx context.Context, key string) M {
+	redisValue, err := client.Get(ctx, key).Result()
+	resMap := make(M)
 
 	if err == redis.Nil {
-		fmt.Println("no beacons list, starting empty")
+		fmt.Printf("No list found for key %s, starting empty\n", key)
 	} else if err != nil {
-		fmt.Println("no connection to redis")
+		fmt.Printf("Error in connecting to Redis: %v, key: %s returning empty map\n", err, key)
 	} else {
-		json.Unmarshal([]byte(beaconsList), &beaconsMap)
+		if err := json.Unmarshal([]byte(redisValue), &resMap); err != nil {
+			fmt.Printf("Error in unmarshalling JSON for key: %s\n", key)
+		}
 	}
 
-	return beaconsMap
+	return resMap
 }
 
-func LoadLatestList(client *redis.Client, ctx context.Context) map[string]model.Beacon {
-	latestList, err := client.Get(ctx, "latestList").Result()
-	latestMap := make(map[string]model.Beacon)
-
-	if err == redis.Nil {
-		fmt.Println("no beacons list, starting empty")
-	} else if err != nil {
-		fmt.Println("no connection to redis")
-	} else {
-		json.Unmarshal([]byte(latestList), &latestMap)
-	}
-
-	return latestMap
-}
-
-func LoadSettings(client *redis.Client, ctx context.Context) model.SettingsVal {
-	redisSettings, err := client.Get(ctx, "settings").Result()
-	var settings model.SettingsVal
-
-	if err == redis.Nil {
-		fmt.Println("no beacons list, starting empty")
-	} else if err != nil {
-		fmt.Println("no connection to redis")
-	} else {
-		json.Unmarshal([]byte(redisSettings), &settings)
-	}
-
-	return settings
-}
-
-func SaveBeaconsList(appCtx *model.AppContext, client *redis.Client, ctx context.Context) {
-	appCtx.Beacons.Lock.Lock()
-	data, _ := json.Marshal(appCtx.Beacons.Beacons)
-	appCtx.Beacons.Lock.Unlock()
-
-	err := client.Set(ctx, "beaconsList", data, 0).Err()
-	if err != nil {
-		fmt.Println("error in saving to redis: ", err)
-	}
-}
-
-func SaveLatestList(appCtx *model.AppContext, client *redis.Client, ctx context.Context) {
-	appCtx.LatestList.Lock.Lock()
-	data, _ := json.Marshal(appCtx.LatestList.LatestList)
-	appCtx.LatestList.Lock.Unlock()
-
-	err := client.Set(ctx, "latestList", data, 0).Err()
+func SaveRedisMap(client *redis.Client, ctx context.Context, key string, data interface{}) {
+	eData, err := json.Marshal(data)
 	if err != nil {
-		fmt.Println("error in saving to redis: ", err)
+		fmt.Println("Error in marshalling, key: ", key)
 	}
-}
-
-func SaveSettings(appCtx *model.AppContext, client *redis.Client, ctx context.Context) {
-	appCtx.Settings.Lock.Lock()
-	data, _ := json.Marshal(appCtx.Settings.Settings)
-	appCtx.Settings.Lock.Unlock()
 
-	err := client.Set(ctx, "settings", data, 0).Err()
+	err = client.Set(ctx, key, eData, 0).Err()
 	if err != nil {
-		fmt.Println("error in saving to redis: ", err)
+		fmt.Println("Error in persisting in Redis, key: ", key)
 	}
 }