add statistics retrieve method

local/model/cache.go

@@ -117,4 +117,145 @@ func (c *LookupCache) Clear() {
 	defer c.Unlock()
 	
 	c.data = make(map[string]interface{})
+}
+
+// ConfigEntry represents a cached configuration entry with its update time
+type ConfigEntry[T any] struct {
+	Data      T
+	UpdatedAt time.Time
+}
+
+// getConfigFromCache is a generic helper function to retrieve cached configs
+func getConfigFromCache[T any](cache map[string]*ConfigEntry[T], serverID string, expirationTime time.Duration) (*T, bool) {
+	if entry, ok := cache[serverID]; ok {
+		if time.Since(entry.UpdatedAt) < expirationTime {
+			return &entry.Data, true
+		}
+	}
+	return nil, false
+}
+
+// updateConfigInCache is a generic helper function to update cached configs
+func updateConfigInCache[T any](cache map[string]*ConfigEntry[T], serverID string, data T) {
+	cache[serverID] = &ConfigEntry[T]{
+		Data:      data,
+		UpdatedAt: time.Now(),
+	}
+}
+
+// ServerConfigCache manages cached server configurations
+type ServerConfigCache struct {
+	sync.RWMutex
+	configuration map[string]*ConfigEntry[Configuration]
+	assistRules   map[string]*ConfigEntry[AssistRules]
+	event         map[string]*ConfigEntry[EventConfig]
+	eventRules    map[string]*ConfigEntry[EventRules]
+	settings      map[string]*ConfigEntry[ServerSettings]
+	config        CacheConfig
+}
+
+// NewServerConfigCache creates a new server configuration cache
+func NewServerConfigCache(config CacheConfig) *ServerConfigCache {
+	return &ServerConfigCache{
+		configuration: make(map[string]*ConfigEntry[Configuration]),
+		assistRules:   make(map[string]*ConfigEntry[AssistRules]),
+		event:         make(map[string]*ConfigEntry[EventConfig]),
+		eventRules:    make(map[string]*ConfigEntry[EventRules]),
+		settings:      make(map[string]*ConfigEntry[ServerSettings]),
+		config:        config,
+	}
+}
+
+// GetConfiguration retrieves a cached configuration
+func (c *ServerConfigCache) GetConfiguration(serverID string) (*Configuration, bool) {
+	c.RLock()
+	defer c.RUnlock()
+	return getConfigFromCache(c.configuration, serverID, c.config.ExpirationTime)
+}
+
+// GetAssistRules retrieves cached assist rules
+func (c *ServerConfigCache) GetAssistRules(serverID string) (*AssistRules, bool) {
+	c.RLock()
+	defer c.RUnlock()
+	return getConfigFromCache(c.assistRules, serverID, c.config.ExpirationTime)
+}
+
+// GetEvent retrieves cached event configuration
+func (c *ServerConfigCache) GetEvent(serverID string) (*EventConfig, bool) {
+	c.RLock()
+	defer c.RUnlock()
+	return getConfigFromCache(c.event, serverID, c.config.ExpirationTime)
+}
+
+// GetEventRules retrieves cached event rules
+func (c *ServerConfigCache) GetEventRules(serverID string) (*EventRules, bool) {
+	c.RLock()
+	defer c.RUnlock()
+	return getConfigFromCache(c.eventRules, serverID, c.config.ExpirationTime)
+}
+
+// GetSettings retrieves cached server settings
+func (c *ServerConfigCache) GetSettings(serverID string) (*ServerSettings, bool) {
+	c.RLock()
+	defer c.RUnlock()
+	return getConfigFromCache(c.settings, serverID, c.config.ExpirationTime)
+}
+
+// UpdateConfiguration updates the configuration cache
+func (c *ServerConfigCache) UpdateConfiguration(serverID string, config Configuration) {
+	c.Lock()
+	defer c.Unlock()
+	updateConfigInCache(c.configuration, serverID, config)
+}
+
+// UpdateAssistRules updates the assist rules cache
+func (c *ServerConfigCache) UpdateAssistRules(serverID string, rules AssistRules) {
+	c.Lock()
+	defer c.Unlock()
+	updateConfigInCache(c.assistRules, serverID, rules)
+}
+
+// UpdateEvent updates the event configuration cache
+func (c *ServerConfigCache) UpdateEvent(serverID string, event EventConfig) {
+	c.Lock()
+	defer c.Unlock()
+	updateConfigInCache(c.event, serverID, event)
+}
+
+// UpdateEventRules updates the event rules cache
+func (c *ServerConfigCache) UpdateEventRules(serverID string, rules EventRules) {
+	c.Lock()
+	defer c.Unlock()
+	updateConfigInCache(c.eventRules, serverID, rules)
+}
+
+// UpdateSettings updates the server settings cache
+func (c *ServerConfigCache) UpdateSettings(serverID string, settings ServerSettings) {
+	c.Lock()
+	defer c.Unlock()
+	updateConfigInCache(c.settings, serverID, settings)
+}
+
+// InvalidateServerCache removes all cached configurations for a specific server
+func (c *ServerConfigCache) InvalidateServerCache(serverID string) {
+	c.Lock()
+	defer c.Unlock()
+
+	delete(c.configuration, serverID)
+	delete(c.assistRules, serverID)
+	delete(c.event, serverID)
+	delete(c.eventRules, serverID)
+	delete(c.settings, serverID)
+}
+
+// Clear removes all entries from the cache
+func (c *ServerConfigCache) Clear() {
+	c.Lock()
+	defer c.Unlock()
+
+	c.configuration = make(map[string]*ConfigEntry[Configuration])
+	c.assistRules = make(map[string]*ConfigEntry[AssistRules])
+	c.event = make(map[string]*ConfigEntry[EventConfig])
+	c.eventRules = make(map[string]*ConfigEntry[EventRules])
+	c.settings = make(map[string]*ConfigEntry[ServerSettings])
 } 

local/model/stateHistory.go

@@ -53,7 +53,19 @@ type StateHistory struct {
 	ID          uint      `gorm:"primaryKey" json:"id"`
 	ServerID    uint      `json:"serverId" gorm:"not null"`
 	Session     string    `json:"session"`
+	Track       string    `json:"track"`
 	PlayerCount int       `json:"playerCount"`
 	DateCreated time.Time `json:"dateCreated"`
+	SessionStart time.Time `json:"sessionStart"`
 	SessionDurationMinutes int `json:"sessionDurationMinutes"`
+	SessionID   uint      `json:"sessionId" gorm:"not null"` // Unique identifier for each session/event
+}
+
+type RecentSession struct {
+	ID       uint      `json:"id"`
+	Date     time.Time `json:"date"`
+	Type     string    `json:"type"`
+	Track    string    `json:"track"`
+	Duration int       `json:"duration"`
+	Players  int       `json:"players"`
 }

local/model/stateHistoryStats.go

@@ -0,0 +1,38 @@
+package model
+
+import "time"
+
+type SessionCount struct {
+	Name  string `json:"name"`
+	Count int    `json:"count"`
+}
+
+type DailyActivity struct {
+	Date          time.Time `json:"date"`
+	SessionsCount int       `json:"sessionsCount"`
+}
+
+type PlayerCountPoint struct {
+	Timestamp time.Time `json:"timestamp"`
+	Count     int       `json:"count"`
+}
+
+type StateHistoryStats struct {
+	AveragePlayers      float64           `json:"averagePlayers"`
+	PeakPlayers         int               `json:"peakPlayers"`
+	TotalSessions       int               `json:"totalSessions"`
+	TotalPlaytime       int               `json:"totalPlaytime"` // in minutes
+	PlayerCountOverTime []PlayerCountPoint `json:"playerCountOverTime"`
+	SessionTypes        []SessionCount     `json:"sessionTypes"`
+	DailyActivity       []DailyActivity    `json:"dailyActivity"`
+	RecentSessions      []RecentSession    `json:"recentSessions"`
+} 
+
+type RecentSession struct {
+	ID       uint      `json:"id"`
+	Date     time.Time `json:"date"`
+	Type     string    `json:"type"`
+	Track    string    `json:"track"`
+	Duration int       `json:"duration"`
+	Players  int       `json:"players"`
+}