res_levis_backend/internal/pkg/apiclient/updatedb.go

package apiclient

import (
	"context"
	"crypto/tls"
	"fmt"
	"log/slog"
	"net/http"
	"reflect"

	"github.com/AFASystems/presence/internal/pkg/common/appcontext"
	"github.com/AFASystems/presence/internal/pkg/config"
	"github.com/AFASystems/presence/internal/pkg/controller"
	"github.com/AFASystems/presence/internal/pkg/model"
	"github.com/segmentio/kafka-go"
	"gorm.io/gorm"
	"gorm.io/gorm/clause"
)

func UpdateDB(db *gorm.DB, ctx context.Context, cfg *config.Config, writer *kafka.Writer, appState *appcontext.AppState) error {
	tr := &http.Transport{
		TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
	}
	client := &http.Client{Transport: tr}

	token, err := GetToken(ctx, cfg, client)
	if err != nil {
		return err
	}

	if trackers, err := GetTrackers(token, client, cfg); err == nil {
		syncTable(db, trackers)
		if err := controller.SendKafkaMessage(writer, &model.ApiUpdate{Method: "DELETE", MAC: "all"}, ctx); err != nil {
			slog.Error("Error in sending delete all from lookup message", "error", err)
		}

		for _, v := range trackers {
			apiUpdate := model.ApiUpdate{
				Method: "POST",
				ID:     v.ID,
				MAC:    v.MAC,
			}

			if err := controller.SendKafkaMessage(writer, &apiUpdate, ctx); err != nil {
				msg := fmt.Sprintf("Error in sending POST kafka message: %v", err)
				slog.Error(msg)
			}
		}
	}

	if gateways, err := GetGateways(token, client, cfg); err == nil {
		syncTable(db, gateways)
	}

	if zones, err := GetZones(token, client, cfg); err == nil {
		syncTable(db, zones)
	}

	if trackerZones, err := GetTrackerZones(token, client, cfg); err == nil {
		syncTable(db, trackerZones)
	}

	if inferredPosition, err := InferPosition(token, client, cfg); err == nil {
		for _, v := range inferredPosition.Items {
			mac := convertMac(v.Mac)
			db.Model(&model.Tracker{}).Where("mac = ?", mac).Update("x", v.X).Update("y", v.Y)
		}
	}

	var settings appcontext.Settings
	db.First(&settings)
	if settings.ID == 0 {
		msg := "settings are empty"
		slog.Info(msg)
		db.Create(appState.GetSettings())
	}

	return nil
}

func syncTable[T any](db *gorm.DB, data []T) {
	if len(data) == 0 {
		return
	}

	var ids []string
	for _, item := range data {
		v := reflect.ValueOf(item).FieldByName("ID").String()
		ids = append(ids, v)
	}

	db.Transaction(func(tx *gorm.DB) error {
		tx.Where("id NOT IN ?", ids).Delete(new(T))
		return tx.Clauses(clause.OnConflict{UpdateAll: true}).Create(&data).Error
	})
}