feat: add total player count and total playtime logic

- Implemented TotalPlayerCountLogic to retrieve the total number of unique players within a specified time range.
- Implemented TotalPlayTimeLogic to calculate the total playtime of players within a specified time range.
- Created ServiceContext to manage database connections and initialize necessary tables.
- Added types for total player count and total playtime requests and responses.
- Set up the main server file to start the application with the necessary configurations.
- Updated go.mod and go.sum for new dependencies.

app/internal/config/config.go

@@ -0,0 +1,12 @@
+package config
+
+import "github.com/zeromicro/go-zero/rest"
+
+type Config struct {
+	rest.RestConf
+	Database DatabaseConfig
+}
+
+type DatabaseConfig struct {
+	DSN string // Data Source Name for database connection
+}

app/internal/handler/pinghandler.go

@@ -0,0 +1,29 @@
+package handler
+
+import (
+	"net/http"
+
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/logic"
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/svc"
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/types"
+	"github.com/zeromicro/go-zero/rest/httpx"
+)
+
+// Ping the server to check if it's alive
+func pingHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.PingReq
+		if err := httpx.Parse(r, &req); err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+			return
+		}
+
+		l := logic.NewPingLogic(r.Context(), svcCtx)
+		resp, err := l.Ping(&req)
+		if err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+		} else {
+			httpx.OkJsonCtx(r.Context(), w, resp)
+		}
+	}
+}

app/internal/handler/recentchatmessagehandler.go

@@ -0,0 +1,29 @@
+package handler
+
+import (
+	"net/http"
+
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/logic"
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/svc"
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/types"
+	"github.com/zeromicro/go-zero/rest/httpx"
+)
+
+// Get recent chat messages within a specified time range
+func recentChatMessageHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.RecentChatMessageReq
+		if err := httpx.Parse(r, &req); err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+			return
+		}
+
+		l := logic.NewRecentChatMessageLogic(r.Context(), svcCtx)
+		resp, err := l.RecentChatMessage(&req)
+		if err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+		} else {
+			httpx.OkJsonCtx(r.Context(), w, resp)
+		}
+	}
+}

app/internal/handler/recentjoinplayerhandler.go

@@ -0,0 +1,29 @@
+package handler
+
+import (
+	"net/http"
+
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/logic"
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/svc"
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/types"
+	"github.com/zeromicro/go-zero/rest/httpx"
+)
+
+// Get recent players who joined within a specified time range
+func recentJoinPlayerHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.RecentJoinPlayerReq
+		if err := httpx.Parse(r, &req); err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+			return
+		}
+
+		l := logic.NewRecentJoinPlayerLogic(r.Context(), svcCtx)
+		resp, err := l.RecentJoinPlayer(&req)
+		if err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+		} else {
+			httpx.OkJsonCtx(r.Context(), w, resp)
+		}
+	}
+}

app/internal/handler/recentplayerjoinhandler.go

@@ -0,0 +1,29 @@
+package handler
+
+import (
+	"net/http"
+
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/logic"
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/svc"
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/types"
+	"github.com/zeromicro/go-zero/rest/httpx"
+)
+
+// Get recent player joins within a specified time range
+func recentPlayerJoinHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.TotalPlayerJoinReq
+		if err := httpx.Parse(r, &req); err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+			return
+		}
+
+		l := logic.NewRecentPlayerJoinLogic(r.Context(), svcCtx)
+		resp, err := l.RecentPlayerJoin(&req)
+		if err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+		} else {
+			httpx.OkJsonCtx(r.Context(), w, resp)
+		}
+	}
+}

app/internal/handler/recentplayhandler.go

@@ -0,0 +1,29 @@
+package handler
+
+import (
+	"net/http"
+
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/logic"
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/svc"
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/types"
+	"github.com/zeromicro/go-zero/rest/httpx"
+)
+
+// Get recent players who played within a specified time range
+func recentPlayHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.RecentPlayReq
+		if err := httpx.Parse(r, &req); err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+			return
+		}
+
+		l := logic.NewRecentPlayLogic(r.Context(), svcCtx)
+		resp, err := l.RecentPlay(&req)
+		if err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+		} else {
+			httpx.OkJsonCtx(r.Context(), w, resp)
+		}
+	}
+}

app/internal/handler/routes.go

@@ -0,0 +1,104 @@
+// Code generated by goctl. DO NOT EDIT.
+// goctl 1.8.4
+
+package handler
+
+import (
+	"net/http"
+
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/svc"
+
+	"github.com/zeromicro/go-zero/rest"
+)
+
+func RegisterHandlers(server *rest.Server, serverCtx *svc.ServiceContext) {
+	server.AddRoutes(
+		[]rest.Route{
+			{
+				// Get the list of monitored game servers
+				Method:  http.MethodGet,
+				Path:    "/list",
+				Handler: ServerListHandler(serverCtx),
+			},
+			{
+				// Ping the server to check if it's alive
+				Method:  http.MethodGet,
+				Path:    "/ping",
+				Handler: pingHandler(serverCtx),
+			},
+			{
+				// Get recent chat messages within a specified time range
+				Method:  http.MethodPost,
+				Path:    "/recent-chat-message",
+				Handler: recentChatMessageHandler(serverCtx),
+			},
+			{
+				// Get recent players who joined within a specified time range
+				Method:  http.MethodPost,
+				Path:    "/recent-join-player",
+				Handler: recentJoinPlayerHandler(serverCtx),
+			},
+			{
+				// Get recent players who played within a specified time range
+				Method:  http.MethodPost,
+				Path:    "/recent-play",
+				Handler: recentPlayHandler(serverCtx),
+			},
+			{
+				// Get recent player joins within a specified time range
+				Method:  http.MethodPost,
+				Path:    "/recent-player-join",
+				Handler: recentPlayerJoinHandler(serverCtx),
+			},
+			{
+				// Get top players by kill count within a specified time range
+				Method:  http.MethodPost,
+				Path:    "/top-killer",
+				Handler: topKillerHandler(serverCtx),
+			},
+			{
+				// Get top players by playtime within a specified time range
+				Method:  http.MethodPost,
+				Path:    "/top-play-time",
+				Handler: topPlayTimeHandler(serverCtx),
+			},
+			{
+				// Get total chat message count within a specified time range
+				Method:  http.MethodPost,
+				Path:    "/total-chat-message-count",
+				Handler: totalChatMessageCountHandler(serverCtx),
+			},
+			{
+				// Get total connect count within a specified time range
+				Method:  http.MethodPost,
+				Path:    "/total-connect-count",
+				Handler: totalConnectCountHandler(serverCtx),
+			},
+			{
+				// Get total damage count within a specified time range
+				Method:  http.MethodPost,
+				Path:    "/total-damage-count",
+				Handler: totalDamageCountHandler(serverCtx),
+			},
+			{
+				// Get total kill count within a specified time range
+				Method:  http.MethodPost,
+				Path:    "/total-kill-count",
+				Handler: totalKillCountHandler(serverCtx),
+			},
+			{
+				// Get total playtime within a specified time range
+				Method:  http.MethodPost,
+				Path:    "/total-play-time",
+				Handler: totalPlayTimeHandler(serverCtx),
+			},
+			{
+				// Get total player count within a specified time range
+				Method:  http.MethodPost,
+				Path:    "/total-player-count",
+				Handler: totalPlayerCountHandler(serverCtx),
+			},
+		},
+		rest.WithPrefix("/api/server/statistics"),
+	)
+}

app/internal/handler/serverlisthandler.go

@@ -0,0 +1,29 @@
+package handler
+
+import (
+	"net/http"
+
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/logic"
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/svc"
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/types"
+	"github.com/zeromicro/go-zero/rest/httpx"
+)
+
+// Get the list of monitored game servers
+func ServerListHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.ServerListReq
+		if err := httpx.Parse(r, &req); err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+			return
+		}
+
+		l := logic.NewServerListLogic(r.Context(), svcCtx)
+		resp, err := l.ServerList(&req)
+		if err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+		} else {
+			httpx.OkJsonCtx(r.Context(), w, resp)
+		}
+	}
+}

app/internal/handler/topkillerhandler.go

@@ -0,0 +1,29 @@
+package handler
+
+import (
+	"net/http"
+
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/logic"
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/svc"
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/types"
+	"github.com/zeromicro/go-zero/rest/httpx"
+)
+
+// Get top players by kill count within a specified time range
+func topKillerHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.TopKillerReq
+		if err := httpx.Parse(r, &req); err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+			return
+		}
+
+		l := logic.NewTopKillerLogic(r.Context(), svcCtx)
+		resp, err := l.TopKiller(&req)
+		if err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+		} else {
+			httpx.OkJsonCtx(r.Context(), w, resp)
+		}
+	}
+}

app/internal/handler/topplaytimehandler.go

@@ -0,0 +1,29 @@
+package handler
+
+import (
+	"net/http"
+
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/logic"
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/svc"
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/types"
+	"github.com/zeromicro/go-zero/rest/httpx"
+)
+
+// Get top players by playtime within a specified time range
+func topPlayTimeHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.TopPlayTimeReq
+		if err := httpx.Parse(r, &req); err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+			return
+		}
+
+		l := logic.NewTopPlayTimeLogic(r.Context(), svcCtx)
+		resp, err := l.TopPlayTime(&req)
+		if err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+		} else {
+			httpx.OkJsonCtx(r.Context(), w, resp)
+		}
+	}
+}

app/internal/handler/totalchatmessagecounthandler.go

@@ -0,0 +1,29 @@
+package handler
+
+import (
+	"net/http"
+
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/logic"
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/svc"
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/types"
+	"github.com/zeromicro/go-zero/rest/httpx"
+)
+
+// Get total chat message count within a specified time range
+func totalChatMessageCountHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.TotalChatMessageCountReq
+		if err := httpx.Parse(r, &req); err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+			return
+		}
+
+		l := logic.NewTotalChatMessageCountLogic(r.Context(), svcCtx)
+		resp, err := l.TotalChatMessageCount(&req)
+		if err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+		} else {
+			httpx.OkJsonCtx(r.Context(), w, resp)
+		}
+	}
+}

app/internal/handler/totalconnectcounthandler.go

@@ -0,0 +1,29 @@
+package handler
+
+import (
+	"net/http"
+
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/logic"
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/svc"
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/types"
+	"github.com/zeromicro/go-zero/rest/httpx"
+)
+
+// Get total connect count within a specified time range
+func totalConnectCountHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.TotalConnectCountReq
+		if err := httpx.Parse(r, &req); err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+			return
+		}
+
+		l := logic.NewTotalConnectCountLogic(r.Context(), svcCtx)
+		resp, err := l.TotalConnectCount(&req)
+		if err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+		} else {
+			httpx.OkJsonCtx(r.Context(), w, resp)
+		}
+	}
+}

app/internal/handler/totaldamagecounthandler.go

@@ -0,0 +1,29 @@
+package handler
+
+import (
+	"net/http"
+
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/logic"
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/svc"
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/types"
+	"github.com/zeromicro/go-zero/rest/httpx"
+)
+
+// Get total damage count within a specified time range
+func totalDamageCountHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.TotalDamageCountReq
+		if err := httpx.Parse(r, &req); err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+			return
+		}
+
+		l := logic.NewTotalDamageCountLogic(r.Context(), svcCtx)
+		resp, err := l.TotalDamageCount(&req)
+		if err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+		} else {
+			httpx.OkJsonCtx(r.Context(), w, resp)
+		}
+	}
+}

app/internal/handler/totalkillcounthandler.go

@@ -0,0 +1,29 @@
+package handler
+
+import (
+	"net/http"
+
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/logic"
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/svc"
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/types"
+	"github.com/zeromicro/go-zero/rest/httpx"
+)
+
+// Get total kill count within a specified time range
+func totalKillCountHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.TotalKillCountReq
+		if err := httpx.Parse(r, &req); err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+			return
+		}
+
+		l := logic.NewTotalKillCountLogic(r.Context(), svcCtx)
+		resp, err := l.TotalKillCount(&req)
+		if err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+		} else {
+			httpx.OkJsonCtx(r.Context(), w, resp)
+		}
+	}
+}

app/internal/handler/totalplayercounthandler.go

@@ -0,0 +1,29 @@
+package handler
+
+import (
+	"net/http"
+
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/logic"
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/svc"
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/types"
+	"github.com/zeromicro/go-zero/rest/httpx"
+)
+
+// Get total player count within a specified time range
+func totalPlayerCountHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.TotalPlayerCountReq
+		if err := httpx.Parse(r, &req); err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+			return
+		}
+
+		l := logic.NewTotalPlayerCountLogic(r.Context(), svcCtx)
+		resp, err := l.TotalPlayerCount(&req)
+		if err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+		} else {
+			httpx.OkJsonCtx(r.Context(), w, resp)
+		}
+	}
+}

app/internal/handler/totalplaytimehandler.go

@@ -0,0 +1,29 @@
+package handler
+
+import (
+	"net/http"
+
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/logic"
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/svc"
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/types"
+	"github.com/zeromicro/go-zero/rest/httpx"
+)
+
+// Get total playtime within a specified time range
+func totalPlayTimeHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.TotalPlayTimeReq
+		if err := httpx.Parse(r, &req); err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+			return
+		}
+
+		l := logic.NewTotalPlayTimeLogic(r.Context(), svcCtx)
+		resp, err := l.TotalPlayTime(&req)
+		if err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+		} else {
+			httpx.OkJsonCtx(r.Context(), w, resp)
+		}
+	}
+}

app/internal/logic/pinglogic.go

@@ -0,0 +1,31 @@
+package logic
+
+import (
+	"context"
+
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/svc"
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type PingLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Ping the server to check if it's alive
+func NewPingLogic(ctx context.Context, svcCtx *svc.ServiceContext) *PingLogic {
+	return &PingLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *PingLogic) Ping(req *types.PingReq) (resp *types.PingResp, err error) {
+	return &types.PingResp{
+		Ok: true,
+	}, nil
+}

app/internal/logic/recentchatmessagelogic.go

@@ -0,0 +1,60 @@
+package logic
+
+import (
+	"context"
+
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/svc"
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type RecentChatMessageLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Get recent chat messages within a specified time range
+func NewRecentChatMessageLogic(ctx context.Context, svcCtx *svc.ServiceContext) *RecentChatMessageLogic {
+	return &RecentChatMessageLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *RecentChatMessageLogic) RecentChatMessage(req *types.RecentChatMessageReq) (resp *types.RecentChatMessageResp, err error) {
+	query := `
+		SELECT steamid64, player_name, message, 
+			EXTRACT(EPOCH FROM message_time)::BIGINT * 1000 as timestamp,
+			server_name, mapname, server_ip, server_port
+		FROM steam_union.chat_log
+		WHERE message_time >= TO_TIMESTAMP($1 / 1000.0) 
+			AND message_time <= TO_TIMESTAMP($2 / 1000.0)
+		ORDER BY message_time DESC
+		LIMIT $3
+	`
+
+	rows, err := l.svcCtx.DB.QueryContext(l.ctx, query, req.TimeRangeStart, req.TimeRangeEnd, req.Limit)
+	if err != nil {
+		l.Errorf("Failed to query recent chat messages: %v", err)
+		return nil, err
+	}
+	defer rows.Close()
+
+	var messages []types.RecentChatMessageRespMessage
+	for rows.Next() {
+		var msg types.RecentChatMessageRespMessage
+		if err := rows.Scan(&msg.SteamID64, &msg.UserName, &msg.Message, &msg.TimeStamp,
+			&msg.ServerName, &msg.MapName, &msg.ServerIP, &msg.ServerPort); err != nil {
+			l.Errorf("Failed to scan chat message: %v", err)
+			continue
+		}
+		messages = append(messages, msg)
+	}
+
+	return &types.RecentChatMessageResp{
+		Messages: messages,
+	}, nil
+}

app/internal/logic/recentjoinplayerlogic.go

@@ -0,0 +1,63 @@
+package logic
+
+import (
+	"context"
+
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/svc"
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type RecentJoinPlayerLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Get recent players who joined within a specified time range
+func NewRecentJoinPlayerLogic(ctx context.Context, svcCtx *svc.ServiceContext) *RecentJoinPlayerLogic {
+	return &RecentJoinPlayerLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *RecentJoinPlayerLogic) RecentJoinPlayer(req *types.RecentJoinPlayerReq) (resp *types.RecentJoinPlayerResp, err error) {
+	query := `
+		SELECT c.steamid64, 
+			EXTRACT(EPOCH FROM c.log_time)::BIGINT * 1000 as join_time,
+			c.player_name as username,
+			COALESCE(s.playtime, 0) as playtime
+		FROM steam_union.connection_log c
+		LEFT JOIN steam_union.steam_user s ON c.steamid64 = s.steamid64
+		WHERE c.connection_type = 1
+			AND c.log_time >= TO_TIMESTAMP($1 / 1000.0)
+			AND c.log_time <= TO_TIMESTAMP($2 / 1000.0)
+			AND c.steamid64 > 1
+		ORDER BY c.log_time DESC
+		LIMIT $3
+	`
+
+	rows, err := l.svcCtx.DB.QueryContext(l.ctx, query, req.TimeRangeStart, req.TimeRangeEnd, req.Limit)
+	if err != nil {
+		l.Errorf("Failed to query recent join players: %v", err)
+		return nil, err
+	}
+	defer rows.Close()
+
+	var players []types.RecentJoinPlayerRespPlayer
+	for rows.Next() {
+		var player types.RecentJoinPlayerRespPlayer
+		if err := rows.Scan(&player.SteamID64, &player.JoinTime, &player.UserName, &player.PlayTime); err != nil {
+			l.Errorf("Failed to scan join player: %v", err)
+			continue
+		}
+		players = append(players, player)
+	}
+
+	return &types.RecentJoinPlayerResp{
+		Players: players,
+	}, nil
+}

app/internal/logic/recentplayerjoinlogic.go

@@ -0,0 +1,47 @@
+package logic
+
+import (
+	"context"
+
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/svc"
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type RecentPlayerJoinLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Get recent player joins within a specified time range
+func NewRecentPlayerJoinLogic(ctx context.Context, svcCtx *svc.ServiceContext) *RecentPlayerJoinLogic {
+	return &RecentPlayerJoinLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *RecentPlayerJoinLogic) RecentPlayerJoin(req *types.TotalPlayerJoinReq) (resp *types.TotalPlayerJoinResp, err error) {
+	query := `
+		SELECT COUNT(*)
+		FROM steam_union.connection_log
+		WHERE connection_type = 1
+			AND log_time >= TO_TIMESTAMP($1 / 1000.0)
+			AND log_time <= TO_TIMESTAMP($2 / 1000.0)
+			AND steamid64 > 1
+	`
+
+	var count int64
+	err = l.svcCtx.DB.QueryRowContext(l.ctx, query, req.TimeRangeStart, req.TimeRangeEnd).Scan(&count)
+	if err != nil {
+		l.Errorf("Failed to query recent player joins: %v", err)
+		return nil, err
+	}
+
+	return &types.TotalPlayerJoinResp{
+		Count: count,
+	}, nil
+}

app/internal/logic/recentplaylogic.go

@@ -0,0 +1,60 @@
+package logic
+
+import (
+	"context"
+
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/svc"
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type RecentPlayLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Get recent players who played within a specified time range
+func NewRecentPlayLogic(ctx context.Context, svcCtx *svc.ServiceContext) *RecentPlayLogic {
+	return &RecentPlayLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *RecentPlayLogic) RecentPlay(req *types.RecentPlayReq) (resp *types.RecentPlayResp, err error) {
+	query := `
+		SELECT steamid64, player_name, mapname, duration
+		FROM steam_union.connection_log
+		WHERE connection_type = 2
+			AND log_time >= TO_TIMESTAMP($1 / 1000.0)
+			AND log_time <= TO_TIMESTAMP($2 / 1000.0)
+			AND duration >= $3
+			AND steamid64 > 1
+		ORDER BY duration DESC
+		LIMIT $4
+	`
+
+	rows, err := l.svcCtx.DB.QueryContext(l.ctx, query, req.TimeRangeStart, req.TimeRangeEnd, req.LeastPlayTime, req.Limit)
+	if err != nil {
+		l.Errorf("Failed to query recent play: %v", err)
+		return nil, err
+	}
+	defer rows.Close()
+
+	var players []types.RecentPlayRespPlayer
+	for rows.Next() {
+		var player types.RecentPlayRespPlayer
+		if err := rows.Scan(&player.SteamID64, &player.UserName, &player.MapName, &player.PlayTime); err != nil {
+			l.Errorf("Failed to scan recent play: %v", err)
+			continue
+		}
+		players = append(players, player)
+	}
+
+	return &types.RecentPlayResp{
+		Players: players,
+	}, nil
+}

app/internal/logic/serverlistlogic.go

@@ -0,0 +1,64 @@
+package logic
+
+import (
+	"context"
+
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/svc"
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type ServerListLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Get the list of monitored game servers
+func NewServerListLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ServerListLogic {
+	return &ServerListLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *ServerListLogic) ServerList(req *types.ServerListReq) (resp []types.ServerListResp, err error) {
+	// Query to select all servers from the database
+	query := `SELECT name, ip, port, category, bot_count, human_count, mapname FROM server ORDER BY id`
+
+	rows, err := l.svcCtx.DB.Query(query)
+	if err != nil {
+		l.Logger.Errorf("Failed to query servers: %v", err)
+		return nil, err
+	}
+	defer rows.Close()
+
+	// Iterate through the results and build the response
+	for rows.Next() {
+		var server types.ServerListResp
+		err = rows.Scan(
+			&server.ServerName,
+			&server.ServerIP,
+			&server.ServerPort,
+			&server.Category,
+			&server.BotCount,
+			&server.HumanCount,
+			&server.MapName,
+		)
+		if err != nil {
+			l.Logger.Errorf("Failed to scan server row: %v", err)
+			return nil, err
+		}
+		resp = append(resp, server)
+	}
+
+	// Check for any error that occurred during iteration
+	if err = rows.Err(); err != nil {
+		l.Logger.Errorf("Error iterating through server rows: %v", err)
+		return nil, err
+	}
+
+	return resp, nil
+}

app/internal/logic/topkillerlogic.go

@@ -0,0 +1,60 @@
+package logic
+
+import (
+	"context"
+
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/svc"
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type TopKillerLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Get top players by kill count within a specified time range
+func NewTopKillerLogic(ctx context.Context, svcCtx *svc.ServiceContext) *TopKillerLogic {
+	return &TopKillerLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *TopKillerLogic) TopKiller(req *types.TopKillerReq) (resp *types.TopKillerResp, err error) {
+	query := `
+		SELECT attacker_steamid64, attacker_name,
+			COUNT(*) as kill_count
+		FROM steam_union.event_player_death_log
+		WHERE event_player_death_time >= TO_TIMESTAMP($1 / 1000.0)
+			AND event_player_death_time <= TO_TIMESTAMP($2 / 1000.0)
+			AND attacker_steamid64 > 1
+		GROUP BY attacker_steamid64, attacker_name
+		ORDER BY kill_count DESC
+		LIMIT $3
+	`
+
+	rows, err := l.svcCtx.DB.QueryContext(l.ctx, query, req.TimeRangeStart, req.TimeRangeEnd, req.Limit)
+	if err != nil {
+		l.Errorf("Failed to query top killers: %v", err)
+		return nil, err
+	}
+	defer rows.Close()
+
+	var players []types.TopKillerRespPlayer
+	for rows.Next() {
+		var player types.TopKillerRespPlayer
+		if err := rows.Scan(&player.SteamID64, &player.UserName, &player.KillCount); err != nil {
+			l.Errorf("Failed to scan top killer: %v", err)
+			continue
+		}
+		players = append(players, player)
+	}
+
+	return &types.TopKillerResp{
+		Players: players,
+	}, nil
+}

app/internal/logic/topplaytimelogic.go

@@ -0,0 +1,61 @@
+package logic
+
+import (
+	"context"
+
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/svc"
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type TopPlayTimeLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Get top players by playtime within a specified time range
+func NewTopPlayTimeLogic(ctx context.Context, svcCtx *svc.ServiceContext) *TopPlayTimeLogic {
+	return &TopPlayTimeLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *TopPlayTimeLogic) TopPlayTime(req *types.TopPlayTimeReq) (resp *types.TopPlayTimeResp, err error) {
+	query := `
+		SELECT c.steamid64, c.player_name,
+			SUM(c.duration) as total_playtime
+		FROM steam_union.connection_log c
+		WHERE c.connection_type = 2
+			AND c.log_time >= TO_TIMESTAMP($1 / 1000.0)
+			AND c.log_time <= TO_TIMESTAMP($2 / 1000.0)
+			AND c.steamid64 > 1
+		GROUP BY c.steamid64, c.player_name
+		ORDER BY total_playtime DESC
+		LIMIT $3
+	`
+
+	rows, err := l.svcCtx.DB.QueryContext(l.ctx, query, req.TimeRangeStart, req.TimeRangeEnd, req.Limit)
+	if err != nil {
+		l.Errorf("Failed to query top playtime: %v", err)
+		return nil, err
+	}
+	defer rows.Close()
+
+	var players []types.TopPlayTimeRespPlayer
+	for rows.Next() {
+		var player types.TopPlayTimeRespPlayer
+		if err := rows.Scan(&player.SteamID64, &player.UserName, &player.PlayTime); err != nil {
+			l.Errorf("Failed to scan top playtime: %v", err)
+			continue
+		}
+		players = append(players, player)
+	}
+
+	return &types.TopPlayTimeResp{
+		Players: players,
+	}, nil
+}

app/internal/logic/totalchatmessagecountlogic.go

@@ -0,0 +1,59 @@
+package logic
+
+import (
+	"context"
+	"fmt"
+
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/svc"
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type TotalChatMessageCountLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Get total chat message count within a specified time range
+func NewTotalChatMessageCountLogic(ctx context.Context, svcCtx *svc.ServiceContext) *TotalChatMessageCountLogic {
+	return &TotalChatMessageCountLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *TotalChatMessageCountLogic) TotalChatMessageCount(req *types.TotalChatMessageCountReq) (resp *types.TotalChatMessageCountResp, err error) {
+	query := `
+		SELECT COUNT(*)
+		FROM steam_union.chat_log
+		WHERE message_time >= TO_TIMESTAMP($1 / 1000.0)
+			AND message_time <= TO_TIMESTAMP($2 / 1000.0)
+	`
+
+	args := []interface{}{req.TimeRangeStart, req.TimeRangeEnd}
+
+	// Add player filter if provided
+	if len(req.PlayerFilter) > 0 {
+		query += ` AND steamid64 = ANY($3)`
+		// Convert []string to []int64 for steamid64
+		steamIDs := make([]int64, len(req.PlayerFilter))
+		for i, id := range req.PlayerFilter {
+			fmt.Sscanf(id, "%d", &steamIDs[i])
+		}
+		args = append(args, steamIDs)
+	}
+
+	var count int64
+	err = l.svcCtx.DB.QueryRowContext(l.ctx, query, args...).Scan(&count)
+	if err != nil {
+		l.Errorf("Failed to query total chat message count: %v", err)
+		return nil, err
+	}
+
+	return &types.TotalChatMessageCountResp{
+		TotalChatMessageCount: count,
+	}, nil
+}

app/internal/logic/totalconnectcountlogic.go

@@ -0,0 +1,47 @@
+package logic
+
+import (
+	"context"
+
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/svc"
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type TotalConnectCountLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Get total connect count within a specified time range
+func NewTotalConnectCountLogic(ctx context.Context, svcCtx *svc.ServiceContext) *TotalConnectCountLogic {
+	return &TotalConnectCountLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *TotalConnectCountLogic) TotalConnectCount(req *types.TotalConnectCountReq) (resp *types.TotalConnectCountResp, err error) {
+	query := `
+		SELECT COUNT(*)
+		FROM steam_union.connection_log
+		WHERE connection_type = 1
+			AND log_time >= TO_TIMESTAMP($1 / 1000.0)
+			AND log_time <= TO_TIMESTAMP($2 / 1000.0)
+			AND steamid64 > 1
+	`
+
+	var count int64
+	err = l.svcCtx.DB.QueryRowContext(l.ctx, query, req.TimeRangeStart, req.TimeRangeEnd).Scan(&count)
+	if err != nil {
+		l.Errorf("Failed to query total connect count: %v", err)
+		return nil, err
+	}
+
+	return &types.TotalConnectCountResp{
+		TotalConnectCount: count,
+	}, nil
+}

app/internal/logic/totaldamagecountlogic.go

@@ -0,0 +1,68 @@
+package logic
+
+import (
+	"context"
+	"fmt"
+
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/svc"
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type TotalDamageCountLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Get total damage count within a specified time range
+func NewTotalDamageCountLogic(ctx context.Context, svcCtx *svc.ServiceContext) *TotalDamageCountLogic {
+	return &TotalDamageCountLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *TotalDamageCountLogic) TotalDamageCount(req *types.TotalDamageCountReq) (resp *types.TotalDamageCountResp, err error) {
+	query := `
+		SELECT COALESCE(SUM(dmg_health), 0)
+		FROM steam_union.event_player_hurt_log
+		WHERE event_player_hurt_time >= TO_TIMESTAMP($1 / 1000.0)
+			AND event_player_hurt_time <= TO_TIMESTAMP($2 / 1000.0)
+			AND attacker_steamid64 > 1
+	`
+
+	args := []interface{}{req.TimeRangeStart, req.TimeRangeEnd}
+	argIndex := 3
+
+	// Add weapon filter if provided
+	if len(req.WeaponFilter) > 0 {
+		query += fmt.Sprintf(` AND weapon = ANY($%d)`, argIndex)
+		args = append(args, req.WeaponFilter)
+		argIndex++
+	}
+
+	// Add player filter if provided
+	if len(req.PlayerFilter) > 0 {
+		// Convert []string to []int64 for steamid64
+		steamIDs := make([]int64, len(req.PlayerFilter))
+		for i, id := range req.PlayerFilter {
+			fmt.Sscanf(id, "%d", &steamIDs[i])
+		}
+		query += fmt.Sprintf(` AND attacker_steamid64 = ANY($%d)`, argIndex)
+		args = append(args, steamIDs)
+	}
+
+	var count int64
+	err = l.svcCtx.DB.QueryRowContext(l.ctx, query, args...).Scan(&count)
+	if err != nil {
+		l.Errorf("Failed to query total damage count: %v", err)
+		return nil, err
+	}
+
+	return &types.TotalDamageCountResp{
+		TotalDamageCount: count,
+	}, nil
+}

app/internal/logic/totalkillcountlogic.go

@@ -0,0 +1,73 @@
+package logic
+
+import (
+	"context"
+	"fmt"
+
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/svc"
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type TotalKillCountLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Get total kill count within a specified time range
+func NewTotalKillCountLogic(ctx context.Context, svcCtx *svc.ServiceContext) *TotalKillCountLogic {
+	return &TotalKillCountLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *TotalKillCountLogic) TotalKillCount(req *types.TotalKillCountReq) (resp *types.TotalKillCountResp, err error) {
+	query := `
+		SELECT COUNT(*)
+		FROM steam_union.event_player_death_log
+		WHERE event_player_death_time >= TO_TIMESTAMP($1 / 1000.0)
+			AND event_player_death_time <= TO_TIMESTAMP($2 / 1000.0)
+			AND attacker_steamid64 > 1
+	`
+
+	args := []interface{}{req.TimeRangeStart, req.TimeRangeEnd}
+	argIndex := 3
+
+	// Add headshot filter if requested
+	if req.HeadshotOnly {
+		query += ` AND headshot = true`
+	}
+
+	// Add weapon filter if provided
+	if len(req.WeaponFilter) > 0 {
+		query += fmt.Sprintf(` AND weapon = ANY($%d)`, argIndex)
+		args = append(args, req.WeaponFilter)
+		argIndex++
+	}
+
+	// Add player filter if provided
+	if len(req.PlayerFilter) > 0 {
+		// Convert []string to []int64 for steamid64
+		steamIDs := make([]int64, len(req.PlayerFilter))
+		for i, id := range req.PlayerFilter {
+			fmt.Sscanf(id, "%d", &steamIDs[i])
+		}
+		query += fmt.Sprintf(` AND attacker_steamid64 = ANY($%d)`, argIndex)
+		args = append(args, steamIDs)
+	}
+
+	var count int64
+	err = l.svcCtx.DB.QueryRowContext(l.ctx, query, args...).Scan(&count)
+	if err != nil {
+		l.Errorf("Failed to query total kill count: %v", err)
+		return nil, err
+	}
+
+	return &types.TotalKillCountResp{
+		TotalKillCount: count,
+	}, nil
+}

app/internal/logic/totalplayercountlogic.go

@@ -0,0 +1,46 @@
+package logic
+
+import (
+	"context"
+
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/svc"
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type TotalPlayerCountLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Get total player count within a specified time range
+func NewTotalPlayerCountLogic(ctx context.Context, svcCtx *svc.ServiceContext) *TotalPlayerCountLogic {
+	return &TotalPlayerCountLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *TotalPlayerCountLogic) TotalPlayerCount(req *types.TotalPlayerCountReq) (resp *types.TotalPlayerCountResp, err error) {
+	query := `
+		SELECT COUNT(DISTINCT steamid64)
+		FROM steam_user
+		WHERE jointime >= TO_TIMESTAMP($1 / 1000.0) 
+			AND jointime <= TO_TIMESTAMP($2 / 1000.0)
+			AND steamid64 > 1
+	`
+
+	var count int64
+	err = l.svcCtx.DB.QueryRowContext(l.ctx, query, req.TimeRangeStart, req.TimeRangeEnd).Scan(&count)
+	if err != nil {
+		l.Errorf("Failed to query total player count: %v", err)
+		return nil, err
+	}
+
+	return &types.TotalPlayerCountResp{
+		Count: count,
+	}, nil
+}

app/internal/logic/totalplaytimelogic.go

@@ -0,0 +1,47 @@
+package logic
+
+import (
+	"context"
+
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/svc"
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type TotalPlayTimeLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Get total playtime within a specified time range
+func NewTotalPlayTimeLogic(ctx context.Context, svcCtx *svc.ServiceContext) *TotalPlayTimeLogic {
+	return &TotalPlayTimeLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *TotalPlayTimeLogic) TotalPlayTime(req *types.TotalPlayTimeReq) (resp *types.TotalPlayTimeResp, err error) {
+	query := `
+		SELECT COALESCE(SUM(duration), 0)
+		FROM steam_union.connection_log
+		WHERE connection_type = 2
+			AND log_time >= TO_TIMESTAMP($1 / 1000.0)
+			AND log_time <= TO_TIMESTAMP($2 / 1000.0)
+			AND steamid64 > 1
+	`
+
+	var totalTime int64
+	err = l.svcCtx.DB.QueryRowContext(l.ctx, query, req.TimeRangeStart, req.TimeRangeEnd).Scan(&totalTime)
+	if err != nil {
+		l.Errorf("Failed to query total playtime: %v", err)
+		return nil, err
+	}
+
+	return &types.TotalPlayTimeResp{
+		TotalPlayTime: totalTime,
+	}, nil
+}

app/internal/svc/servicecontext.go

@@ -0,0 +1,64 @@
+package svc
+
+import (
+	"database/sql"
+	"log"
+
+	"git.cialloo.com/CiallooWeb/ServerStatistics/app/internal/config"
+
+	_ "github.com/lib/pq" // PostgreSQL driver
+)
+
+type ServiceContext struct {
+	Config config.Config
+	DB     *sql.DB
+}
+
+func NewServiceContext(c config.Config) *ServiceContext {
+	// Initialize database connection
+	db, err := sql.Open("postgres", c.Database.DSN)
+	if err != nil {
+		log.Fatalf("Failed to connect to database: %v", err)
+	}
+
+	// Test the connection
+	if err := db.Ping(); err != nil {
+		log.Fatalf("Failed to ping database: %v", err)
+	}
+
+	log.Println("Database connection established successfully")
+
+	// Create tables if they don't exist
+	if err := createTables(db); err != nil {
+		log.Fatalf("Failed to create tables: %v", err)
+	}
+
+	return &ServiceContext{
+		Config: c,
+		DB:     db,
+	}
+}
+
+func createTables(db *sql.DB) error {
+	// Create server table
+	serverTableQuery := `
+	CREATE TABLE IF NOT EXISTS server (
+		id SERIAL PRIMARY KEY,
+		name VARCHAR(64) NOT NULL,
+		ip VARCHAR(64) NOT NULL,
+		port INTEGER NOT NULL,
+		category VARCHAR(64) NOT NULL,
+		bot_count INTEGER NOT NULL,
+		human_count INTEGER NOT NULL,
+		mapname VARCHAR(64) NOT NULL,
+		last_update TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+		UNIQUE (ip, port)
+	);`
+
+	if _, err := db.Exec(serverTableQuery); err != nil {
+		return err
+	}
+
+	log.Println("Database tables created successfully")
+	return nil
+}

app/internal/types/types.go

@@ -0,0 +1,181 @@
+// Code generated by goctl. DO NOT EDIT.
+// goctl 1.8.4
+
+package types
+
+type PingReq struct {
+}
+
+type PingResp struct {
+	Ok bool `json:"ok"`
+}
+
+type RecentChatMessageReq struct {
+	TimeRangeStart int64 `json:"timeRangeStart"`                           // Unix timestamp in milliseconds
+	TimeRangeEnd   int64 `json:"timeRangeEnd"`                             // Unix timestamp in milliseconds
+	Limit          int   `json:"limit,range=[1:10],example=10,default=10"` // Maximum number of messages to return
+}
+
+type RecentChatMessageResp struct {
+	Messages []RecentChatMessageRespMessage `json:"messages"` // List of recent chat messages
+}
+
+type RecentChatMessageRespMessage struct {
+	SteamID64  string `json:"steamID64"`  // Player's SteamID64
+	UserName   string `json:"userName"`   // Player's username at the time of message
+	Message    string `json:"message"`    // Chat message content
+	TimeStamp  int64  `json:"timeStamp"`  // Message timestamp as Unix timestamp in milliseconds
+	ServerName string `json:"serverName"` // Server name where the message was sent
+	MapName    string `json:"mapName"`    // Map name where the message was sent
+	ServerIP   string `json:"serverIP"`   // Server IP where the message was sent
+	ServerPort int    `json:"serverPort"` // Server port where the message was sent
+}
+
+type RecentJoinPlayerReq struct {
+	TimeRangeStart int64 `json:"timeRangeStart"`                           // Unix timestamp in milliseconds
+	TimeRangeEnd   int64 `json:"timeRangeEnd"`                             // Unix timestamp in milliseconds
+	Limit          int   `json:"limit,range=[1:10],example=10,default=10"` // Maximum number of players to return
+}
+
+type RecentJoinPlayerResp struct {
+	Players []RecentJoinPlayerRespPlayer `json:"players"` // List of player SteamID64s who joined in the time range
+}
+
+type RecentJoinPlayerRespPlayer struct {
+	SteamID64 string `json:"steamID64"` // Player's SteamID64
+	JoinTime  int64  `json:"joinTime"`  // Join time as Unix timestamp in milliseconds
+	UserName  string `json:"userName"`  // Player's username at the time of joining
+	PlayTime  int64  `json:"playTime"`  // Playtime in seconds since joining
+}
+
+type RecentPlayReq struct {
+	TimeRangeStart int64 `json:"timeRangeStart"`                           // Unix timestamp in milliseconds
+	TimeRangeEnd   int64 `json:"timeRangeEnd"`                             // Unix timestamp in milliseconds
+	LeastPlayTime  int64 `json:"leastPlayTime"`                            // Least playtime in seconds to filter by
+	Limit          int   `json:"limit,range=[1:10],example=10,default=10"` // Maximum number of players to return
+}
+
+type RecentPlayResp struct {
+	Players []RecentPlayRespPlayer `json:"players"` // List of players who played in the time range
+}
+
+type RecentPlayRespPlayer struct {
+	SteamID64 string `json:"steamID64"` // Player's SteamID64
+	UserName  string `json:"userName"`  // Player's username at the time of playing
+	MapName   string `json:"mapName"`   // Map name where the player played
+	PlayTime  int64  `json:"playTime"`  // Playtime in seconds during the time range
+}
+
+type ServerListReq struct {
+}
+
+type ServerListResp struct {
+	ServerName string `json:"serverName"` // Server name
+	ServerIP   string `json:"serverIP"`   // Server IP address
+	ServerPort int    `json:"serverPort"` // Server port
+	Category   string `json:"category"`   // Server category
+	MapName    string `json:"mapName"`    // Current map name
+	HumanCount int    `json:"humanCount"` // Current human player count
+	BotCount   int    `json:"botCount"`   // Bot count
+}
+
+type TopKillerReq struct {
+	TimeRangeStart int64 `json:"timeRangeStart"`                           // Unix timestamp in milliseconds
+	TimeRangeEnd   int64 `json:"timeRangeEnd"`                             // Unix timestamp in milliseconds
+	Limit          int   `json:"limit,range=[1:10],example=10,default=10"` // Maximum number of players to return
+}
+
+type TopKillerResp struct {
+	Players []TopKillerRespPlayer `json:"players"` // List of top players by kill count
+}
+
+type TopKillerRespPlayer struct {
+	SteamID64 string `json:"steamID64"` // Player's SteamID64
+	UserName  string `json:"userName"`  // Player's username at the time of playing
+	KillCount int64  `json:"killCount"` // Kill count during the time range
+}
+
+type TopPlayTimeReq struct {
+	TimeRangeStart int64 `json:"timeRangeStart"`                           // Unix timestamp in milliseconds
+	TimeRangeEnd   int64 `json:"timeRangeEnd"`                             // Unix timestamp in milliseconds
+	Limit          int   `json:"limit,range=[1:10],example=10,default=10"` // Maximum number of players to return
+}
+
+type TopPlayTimeResp struct {
+	Players []TopPlayTimeRespPlayer `json:"players"` // List of top players by playtime
+}
+
+type TopPlayTimeRespPlayer struct {
+	SteamID64 string `json:"steamID64"` // Player's SteamID64
+	UserName  string `json:"userName"`  // Player's username at the time of playing
+	PlayTime  int64  `json:"playTime"`  // Playtime in seconds during the time range
+}
+
+type TotalChatMessageCountReq struct {
+	TimeRangeStart int64    `json:"timeRangeStart"` // Unix timestamp in milliseconds
+	TimeRangeEnd   int64    `json:"timeRangeEnd"`   // Unix timestamp in milliseconds
+	PlayerFilter   []string `json:"playerFilter"`   // List of player SteamID64s to filter by (optional)
+}
+
+type TotalChatMessageCountResp struct {
+	TotalChatMessageCount int64 `json:"totalChatMessageCount"` // Total chat message count
+}
+
+type TotalConnectCountReq struct {
+	TimeRangeStart int64 `json:"timeRangeStart"` // Unix timestamp in milliseconds
+	TimeRangeEnd   int64 `json:"timeRangeEnd"`   // Unix timestamp in milliseconds
+}
+
+type TotalConnectCountResp struct {
+	TotalConnectCount int64 `json:"totalConnectCount"` // Total connect count
+}
+
+type TotalDamageCountReq struct {
+	TimeRangeStart int64    `json:"timeRangeStart"` // Unix timestamp in milliseconds
+	TimeRangeEnd   int64    `json:"timeRangeEnd"`   // Unix timestamp in milliseconds
+	WeaponFilter   []string `json:"weaponFilter"`   // List of weapon names to filter by (optional)
+	PlayerFilter   []string `json:"playerFilter"`   // List of player SteamID64s to filter by (optional)
+}
+
+type TotalDamageCountResp struct {
+	TotalDamageCount int64 `json:"totalDamageCount"` // Total damage count
+}
+
+type TotalKillCountReq struct {
+	TimeRangeStart int64    `json:"timeRangeStart"` // Unix timestamp in milliseconds
+	TimeRangeEnd   int64    `json:"timeRangeEnd"`   // Unix timestamp in milliseconds
+	HeadshotOnly   bool     `json:"headshotOnly"`   // If true, count only headshot kills
+	WeaponFilter   []string `json:"weaponFilter"`   // List of weapon names to filter by (optional)
+	PlayerFilter   []string `json:"playerFilter"`   // List of player SteamID64s to filter by (optional)
+}
+
+type TotalKillCountResp struct {
+	TotalKillCount int64 `json:"totalKillCount"` // Total kill count
+}
+
+type TotalPlayTimeReq struct {
+	TimeRangeStart int64 `json:"timeRangeStart"` // Unix timestamp in milliseconds
+	TimeRangeEnd   int64 `json:"timeRangeEnd"`   // Unix timestamp in milliseconds
+}
+
+type TotalPlayTimeResp struct {
+	TotalPlayTime int64 `json:"totalPlayTime"` // Total playtime in seconds
+}
+
+type TotalPlayerCountReq struct {
+	TimeRangeStart int64 `json:"timeRangeStart"` // Unix timestamp in milliseconds
+	TimeRangeEnd   int64 `json:"timeRangeEnd"`   // Unix timestamp in milliseconds
+}
+
+type TotalPlayerCountResp struct {
+	Count int64 `json:"count"`
+}
+
+type TotalPlayerJoinReq struct {
+	TimeRangeStart int64 `json:"timeRangeStart"` // Unix timestamp in milliseconds
+	TimeRangeEnd   int64 `json:"timeRangeEnd"`   // Unix timestamp in milliseconds
+}
+
+type TotalPlayerJoinResp struct {
+	Count int64 `json:"count"`
+}