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/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
+}