res_levis_backend/internal/pkg/controller/trackers_controller.go

package controller

import (
	"context"
	"encoding/json"
	"log/slog"
	"net/http"
	"strconv"

	"github.com/AFASystems/presence/internal/pkg/api/response"
	"github.com/AFASystems/presence/internal/pkg/kafkaclient"
	"github.com/AFASystems/presence/internal/pkg/model"
	"github.com/AFASystems/presence/internal/pkg/validation"
	"github.com/gorilla/mux"
	"github.com/segmentio/kafka-go"
	"gorm.io/gorm"
)

func SendKafkaMessage(writer *kafka.Writer, value *model.ApiUpdate, context context.Context) error {
	valueStr, err := json.Marshal(&value)
	if err != nil {
		slog.Error("error encoding", "error", err)
		return err
	}
	msg := kafka.Message{
		Value: valueStr,
	}

	if err := kafkaclient.Write(context, writer, msg); err != nil {
		slog.Error("error sending kafka message", "error", err)
		return err
	}

	return nil
}

func TrackerAdd(db *gorm.DB, writer *kafka.Writer, context context.Context) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		var tracker model.Tracker
		if err := json.NewDecoder(r.Body).Decode(&tracker); err != nil {
			response.BadRequest(w, "invalid request body")
			return
		}
		if err := validation.Struct(&tracker); err != nil {
			response.BadRequest(w, err.Error())
			return
		}
		if err := db.WithContext(context).Create(&tracker).Error; err != nil {
			response.InternalError(w, "failed to create tracker", err)
			return
		}

		apiUpdate := model.ApiUpdate{
			Method: "POST",
			ID:     tracker.ID,
			MAC:    tracker.MAC,
		}

		if err := SendKafkaMessage(writer, &apiUpdate, context); err != nil {
			slog.Error("error sending Kafka POST message", "err", err)
			response.InternalError(w, "failed to publish tracker update", err)
			return
		}

		response.JSON(w, http.StatusCreated, map[string]string{"status": "created"})
	}
}

func TrackerList(db *gorm.DB, context context.Context) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		query := r.URL.Query()

		lStr := query.Get("limit")
		if lStr == "" {
			lStr = "100"
		}
		limit, err := strconv.Atoi(lStr)
		if err != nil {
			slog.Error("invalid limit parameter", "value", lStr)
			response.BadRequest(w, "invalid limit parameter")
			return
		}

		oStr := query.Get("offset")
		if oStr == "" {
			oStr = "0"
		}
		offset, err := strconv.Atoi(oStr)
		if err != nil {
			slog.Error("invalid offset parameter", "value", oStr)
			response.BadRequest(w, "invalid offset parameter")
			return
		}

		var list []model.Tracker
		if err := db.WithContext(context).Limit(limit).Offset(offset).Find(&list).Error; err != nil {
			response.InternalError(w, "failed to list trackers", err)
			return
		}
		response.JSON(w, http.StatusOK, list)
	}
}

func TrackerUpdate(db *gorm.DB, context context.Context) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		var tracker model.Tracker
		if err := json.NewDecoder(r.Body).Decode(&tracker); err != nil {
			response.BadRequest(w, "invalid request body")
			return
		}
		if err := validation.Struct(&tracker); err != nil {
			response.BadRequest(w, err.Error())
			return
		}

		id := tracker.ID
		if err := db.WithContext(context).First(&model.Tracker{}, "id = ?", id).Error; err != nil {
			response.NotFound(w, "tracker not found")
			return
		}

		if err := db.WithContext(context).Save(&tracker).Error; err != nil {
			response.InternalError(w, "failed to update tracker", err)
			return
		}

		response.JSON(w, http.StatusOK, map[string]string{"status": "updated"})
	}
}

func TrackerDelete(db *gorm.DB, writer *kafka.Writer, context context.Context) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		id := mux.Vars(r)["id"]
		var tracker model.Tracker
		if err := db.WithContext(context).First(&tracker, "id = ?", id).Error; err != nil {
			response.NotFound(w, "tracker not found")
			return
		}

		res := db.WithContext(context).Delete(&model.Tracker{}, "id = ?", id)
		if res.RowsAffected == 0 {
			response.NotFound(w, "tracker not found")
			return
		}
		if res.Error != nil {
			response.InternalError(w, "failed to delete tracker", res.Error)
			return
		}

		apiUpdate := model.ApiUpdate{
			Method: "DELETE",
			MAC:    tracker.MAC,
		}
		slog.Info("sending DELETE tracker message", "id", id)

		if err := SendKafkaMessage(writer, &apiUpdate, context); err != nil {
			slog.Error("error sending Kafka DELETE message", "err", err)
			response.InternalError(w, "failed to publish tracker deletion", err)
			return
		}

		response.JSON(w, http.StatusOK, map[string]string{"status": "deleted"})
	}
}