add filtering and base repository

local/service/api.go

@@ -30,17 +30,6 @@ func (as *ApiService) SetServerService(serverService *ServerService) {
 	as.serverService = serverService
 }
 
-// GetFirst
-// Gets first row from API table.
-//
-//	   	Args:
-//	   		context.Context: Application context
-//		Returns:
-//			string: Application version
-func (as ApiService) GetFirst(ctx *fiber.Ctx) *model.ApiModel {
-	return as.repository.GetFirst(ctx.UserContext())
-}
-
 func (as ApiService) GetStatus(ctx *fiber.Ctx) (string, error) {
 	serviceName, err := as.GetServiceName(ctx)
 	if err != nil {
@@ -82,7 +71,7 @@ func (as ApiService) StatusServer(serviceName string) (string, error) {
 func (as ApiService) StartServer(serviceName string) (string, error) {
 	status, err := ManageService(serviceName, "start")
 
-	server := as.serverRepository.GetFirstByServiceName(context.Background(), serviceName)
+	server, err := as.serverRepository.GetFirstByServiceName(context.Background(), serviceName)
 	as.serverService.StartAccServerRuntime(server)
 	return status, err
 }
@@ -90,7 +79,7 @@ func (as ApiService) StartServer(serviceName string) (string, error) {
 func (as ApiService) StopServer(serviceName string) (string, error) {
 	status, err := ManageService(serviceName, "stop")
 
-	server := as.serverRepository.GetFirstByServiceName(context.Background(), serviceName)
+	server, err := as.serverRepository.GetFirstByServiceName(context.Background(), serviceName)
 	as.serverService.instances.Delete(server.ID)
 
 	return status, err
@@ -99,7 +88,7 @@ func (as ApiService) StopServer(serviceName string) (string, error) {
 func (as ApiService) RestartServer(serviceName string) (string, error) {
 	status, err := ManageService(serviceName, "restart")
 
-	server := as.serverRepository.GetFirstByServiceName(context.Background(), serviceName)
+	server, err := as.serverRepository.GetFirstByServiceName(context.Background(), serviceName)
 	as.serverService.StartAccServerRuntime(server)
 	return status, err
 }
@@ -115,18 +104,19 @@ func ManageService(serviceName string, action string) (string, error) {
 
 func (as ApiService) GetServiceName(ctx *fiber.Ctx) (string, error) {
 	var server *model.Server
+	var err error
 	serviceName, ok := ctx.Locals("service").(string)
 	if !ok || serviceName == "" {
 		serverId, ok2 := ctx.Locals("serverId").(int)
 		if !ok2 || serverId == 0 {
 			return "", errors.New("service name missing")
 		}
-		server = as.serverRepository.GetFirst(ctx.UserContext(), serverId)
+		server, err = as.serverRepository.GetByID(ctx.UserContext(), serverId)
 	} else {
-		server = as.serverRepository.GetFirstByServiceName(ctx.UserContext(), serviceName)
+		server, err = as.serverRepository.GetFirstByServiceName(ctx.UserContext(), serviceName)
 	}
-	if server == nil {
-		return "", fiber.NewError(404, "Server not found")
+	if err != nil {
+		return "", err
 	}
 	return server.ServiceName, nil
 }

local/service/config.go

@@ -89,10 +89,10 @@ func (as ConfigService) UpdateConfig(ctx *fiber.Ctx, body *map[string]interface{
 	configFile := ctx.Params("file")
 	override := ctx.QueryBool("override")
 
-	server := as.serverRepository.GetFirst(ctx.UserContext(), serverID)
+	server, err := as.serverRepository.GetByID(ctx.UserContext(), serverID)
 
-	if server == nil {
-		return nil, fiber.NewError(404, "Server not found")
+	if err != nil {
+		return nil, err
 	}
 
 	// Read existing config
@@ -159,9 +159,9 @@ func (as ConfigService) GetConfig(ctx *fiber.Ctx) (interface{}, error) {
 	serverID, _ := ctx.ParamsInt("id")
 	configFile := ctx.Params("file")
 
-	server := as.serverRepository.GetFirst(ctx.UserContext(), serverID)
+	server, err := as.serverRepository.GetByID(ctx.UserContext(), serverID)
 
-	if server == nil {
+	if err != nil {
 		log.Print("Server not found")
 		return nil, fiber.NewError(404, "Server not found")
 	}
@@ -184,9 +184,9 @@ func (as ConfigService) GetConfig(ctx *fiber.Ctx) (interface{}, error) {
 func (as ConfigService) GetConfigs(ctx *fiber.Ctx) (*model.Configurations, error) {
 	serverID, _ := ctx.ParamsInt("id")
 
-	server := as.serverRepository.GetFirst(ctx.UserContext(), serverID)
+	server, err := as.serverRepository.GetByID(ctx.UserContext(), serverID)
 
-	if server == nil {
+	if err != nil {
 		log.Print("Server not found")
 		return nil, fiber.NewError(404, "Server not found")
 	}

local/service/server.go

@@ -14,11 +14,18 @@ import (
 )
 
 type ServerService struct {
-	repository *repository.ServerRepository
+	repository       *repository.ServerRepository
 	stateHistoryRepo *repository.StateHistoryRepository
-	apiService *ApiService
-	instances sync.Map
-	configService *ConfigService
+	apiService       *ApiService
+	instances        sync.Map
+	configService    *ConfigService
+	lastInsertTimes  sync.Map // Track last insert time per server
+	debouncers       sync.Map // Track debounce timers per server
+}
+
+type pendingState struct {
+	timer *time.Timer
+	state *model.ServerState
 }
 
 func NewServerService(repository *repository.ServerRepository, stateHistoryRepo *repository.StateHistoryRepository, apiService *ApiService, configService *ConfigService) *ServerService {
@@ -28,7 +35,10 @@ func NewServerService(repository *repository.ServerRepository, stateHistoryRepo
 		configService: configService,
 		stateHistoryRepo: stateHistoryRepo,
 	}
-	servers := repository.GetAll(context.Background())
+	servers, err := repository.GetAll(context.Background(), &model.ServerFilter{})
+	if err != nil {
+		log.Print(err.Error())
+	}
 	for _, server := range *servers {
 		status, err := service.apiService.StatusServer(server.ServiceName)
 		if err != nil {
@@ -41,15 +51,69 @@ func NewServerService(repository *repository.ServerRepository, stateHistoryRepo
 	return service
 }
 
+func (s *ServerService) shouldInsertStateHistory(serverID uint) bool {
+	insertInterval := 5 * time.Minute // Configure this as needed
+	
+	lastInsertInterface, exists := s.lastInsertTimes.Load(serverID)
+	if !exists {
+		s.lastInsertTimes.Store(serverID, time.Now().UTC())
+		return true
+	}
+	
+	lastInsert := lastInsertInterface.(time.Time)
+	now := time.Now().UTC()
+	
+	if now.Sub(lastInsert) >= insertInterval {
+		s.lastInsertTimes.Store(serverID, now)
+		return true
+	}
+	
+	return false
+}
+
+func (s *ServerService) insertStateHistory(serverID uint, state *model.ServerState) {
+	s.stateHistoryRepo.Insert(context.Background(), &model.StateHistory{
+		ServerID:    serverID,
+		Session:     state.Session,
+		PlayerCount: state.PlayerCount,
+		DateCreated: time.Now().UTC(),
+	})
+}
+
+func (s *ServerService) handleStateChange(server *model.Server, state *model.ServerState) {
+	// Cancel existing timer if any
+	if debouncer, exists := s.debouncers.Load(server.ID); exists {
+		pending := debouncer.(*pendingState)
+		pending.timer.Stop()
+	}
+
+	// Create new timer
+	timer := time.NewTimer(5 * time.Minute)
+	s.debouncers.Store(server.ID, &pendingState{
+		timer: timer,
+		state: state,
+	})
+
+	// Start goroutine to handle the delayed insert
+	go func() {
+		<-timer.C
+		if debouncer, exists := s.debouncers.Load(server.ID); exists {
+			pending := debouncer.(*pendingState)
+			s.insertStateHistory(server.ID, pending.state)
+			s.debouncers.Delete(server.ID)
+		}
+	}()
+
+	// If enough time has passed since last insert, insert immediately
+	if s.shouldInsertStateHistory(server.ID) {
+		s.insertStateHistory(server.ID, state)
+	}
+}
+
 func (s *ServerService) StartAccServerRuntime(server *model.Server) {
 	s.instances.Delete(server.ID)
     instance := tracking.NewAccServerInstance(server, func(state *model.ServerState, states ...tracking.StateChange) {
-		s.stateHistoryRepo.Insert(context.Background(), &model.StateHistory{
-			ServerID: server.ID,
-			Session: state.Session,
-			PlayerCount: state.PlayerCount,
-			DateCreated: time.Now().UTC(),
-		})
+		s.handleStateChange(server, state)
 	})
 	config, _  := DecodeFileName(ConfigurationJson)(server.ConfigPath)
 	cfg := config.(model.Configuration)
@@ -70,8 +134,11 @@ func (s *ServerService) StartAccServerRuntime(server *model.Server) {
 //	   		context.Context: Application context
 //		Returns:
 //			string: Application version
-func (as ServerService) GetAll(ctx *fiber.Ctx) *[]model.Server {
-	servers := as.repository.GetAll(ctx.UserContext())
+func (as ServerService) GetAll(ctx *fiber.Ctx, filter *model.ServerFilter) (*[]model.Server, error) {
+	servers, err := as.repository.GetAll(ctx.UserContext(), filter)
+	if err != nil {
+		return nil, err
+	}
 
 	for i, server := range *servers {
 		status, err := as.apiService.StatusServer(server.ServiceName)
@@ -90,7 +157,7 @@ func (as ServerService) GetAll(ctx *fiber.Ctx) *[]model.Server {
 		}
 	}
 
-	return servers
+	return servers, nil
 }
 
 // GetById
@@ -100,8 +167,11 @@ func (as ServerService) GetAll(ctx *fiber.Ctx) *[]model.Server {
 //	   		context.Context: Application context
 //		Returns:
 //			string: Application version
-func (as ServerService) GetById(ctx *fiber.Ctx, serverID int) *model.Server {
-	server := as.repository.GetFirst(ctx.UserContext(), serverID)
+func (as ServerService) GetById(ctx *fiber.Ctx, serverID int) (*model.Server, error) {
+	server, err := as.repository.GetByID(ctx.UserContext(), serverID)
+	if err != nil {
+		return nil, err
+	}
 	status, err := as.apiService.StatusServer(server.ServiceName)
 	if err != nil {
 		log.Print(err.Error())
@@ -117,5 +187,5 @@ func (as ServerService) GetById(ctx *fiber.Ctx, serverID int) *model.Server {
 		}
 	}
 
-	return server
+	return server, nil
 }

local/service/stateHistory.go

@@ -3,6 +3,7 @@ package service
 import (
 	"acc-server-manager/local/model"
 	"acc-server-manager/local/repository"
+	"log"
 
 	"github.com/gofiber/fiber/v2"
 )
@@ -24,6 +25,19 @@ func NewStateHistoryService(repository *repository.StateHistoryRepository) *Stat
 //	   		context.Context: Application context
 //		Returns:
 //			string: Application version
-func (as StateHistoryService) GetAll(ctx *fiber.Ctx, id int) *[]model.StateHistory {
-	return as.repository.GetAll(ctx.UserContext(), id)
+func (s *StateHistoryService) GetAll(ctx *fiber.Ctx, filter *model.StateHistoryFilter) (*[]model.StateHistory, error) {
+	result, err := s.repository.GetAll(ctx.UserContext(), filter)
+	if err != nil {
+		log.Printf("Error getting state history: %v", err)
+		return nil, err
+	}
+	return result, nil
+}
+
+func (s *StateHistoryService) Insert(ctx *fiber.Ctx, model *model.StateHistory) error {
+	if err := s.repository.Insert(ctx.UserContext(), model); err != nil {
+		log.Printf("Error inserting state history: %v", err)
+		return err
+	}
+	return nil
 }