网站首页 网站源码
website
站点相关全部源代码，隐藏了一些关于服务器的信息
using System.Net.Http;
using System.Text.Json.Nodes;
using Dpz.Core.Public.Entity.Steam;
using Dpz.Core.Public.ViewModel.Steam;
using Microsoft.AspNetCore.WebUtilities;

namespace Dpz.Core.Service.RepositoryServiceImpl;

public class SteamGameService(
    IRepository<SteamGame> repository,
    IMapper mapper,
    HttpClient httpClient,
    IConfiguration configuration,
    ILogger<SteamGameService> logger,
    IFusionCache fusionCache
) : AbstractCacheService(fusionCache), ISteamGameService
{
    protected override string CachePrefixKey =>
        "Dpz.Core.Service.RepositoryServiceImpl.SteamGameService";
    protected override TimeSpan CacheDefaultExpiration => TimeSpan.FromDays(1);

    private record SteamConfig(string AppKey = "", string SteamId = "");

    private record CdnConfig
    {
        public string BaseUrl { get; init; } = "https://cdn.dpangzi.com";
        public string LogoUrlTemplate { get; init; } =
            "https://shared.akamai.steamstatic.com/store_item_assets/steam/apps/{0}/header.jpg";
    }

    private readonly SteamConfig _steamConfig =
        configuration.GetSection("Steam").Get<SteamConfig>()
        ?? throw new InvalidConfigurationException(
            "Steam 配置缺失：请检查 AppKey 和 SteamId 是否配置。"
        );

    private readonly CdnConfig _cdnConfig =
        configuration.GetSection("Cdn").Get<CdnConfig>() ?? new CdnConfig();

    // API请求延迟时间，防止请求过于频繁
    private const int ApiDelayMs = 500;

    /// <summary>
    /// 当前实例ID，用于区分不同的实例
    /// </summary>
    private readonly Lazy<string> _instanceId = new(() => Guid.NewGuid().ToString("D"));

    private readonly IFusionCache _fusionCache = fusionCache;

    /// <summary>
    /// 当前实例ID的缓存键
    /// </summary>
    private const string RunningInstanceIdKey = "SteamGameService.Running.InstanceId";

    public event LogoDownload? OnLogoDownloadComplete;
    public event AchievementIconGrayDownload? OnAchievementIconGrayDownloadComplete;
    public event AchievementIconDownload? OnAchievementIconDownloadComplete;

    public async Task UpdateGamesAsync()
    {
        var runningInstanceId = await _fusionCache.TryGetAsync<string>(RunningInstanceIdKey);
        if (runningInstanceId.HasValue && runningInstanceId.Value != _instanceId.Value)
        {
            logger.LogInformation(
                "当前已有实例正在运行，跳过此次更新，实例ID：{RunningInstanceId}，当前实例ID：{CurrentInstanceId}",
                runningInstanceId.Value,
                _instanceId.Value
            );
            return;
        }

        await _fusionCache.SetAsync(RunningInstanceIdKey, _instanceId.Value, TimeSpan.FromHours(3));

        try
        {
            logger.LogInformation("开始更新Steam游戏数据，实例ID：{InstanceId}", _instanceId.Value);
            var dbGames = await repository.SearchFor(x => true).ToListAsync();
            var games = await FetchGamesAsync(dbGames);

            // 安全检查：如果获取到空列表，直接返回，避免误删数据
            if (games.Count == 0)
            {
                logger.LogWarning("获取到的Steam游戏数量为0，跳过此次更新以防止误删数据");
                return;
            }

            // 新增游戏
            var newGames = games.ExceptBy(dbGames.Select(x => x.Id), x => x.Id).ToList();
            if (newGames.Count > 0)
            {
                logger.LogInformation("发现{Count}个新游戏，准备添加", newGames.Count);
                await repository.InsertAsync(newGames);
                // var batchSize =
                //     newGames.Count % 10 > 0 ? newGames.Count / 10 + 1 : newGames.Count / 10;
                //
                // for (var i = 0; i < batchSize; i++)
                // {
                //     var startIndex = i * 10;
                //     var count = Math.Min(10, newGames.Count - startIndex);
                //     var batch = newGames.GetRange(startIndex, count);
                //     logger.LogInformation(
                //         "批量添加游戏，开始索引：{StartIndex}，数量：{Count}",
                //         startIndex,
                //         count
                //     );
                //     await repository.InsertAsync(batch);
                //     await Task.Delay(1000);
                // }
            }

            // DB已有游戏，待更新
            var updateGames = games.IntersectBy(dbGames.Select(x => x.Id), x => x.Id).ToList();
            if (updateGames.Count > 0)
            {
                logger.LogInformation("开始更新{Count}个已有游戏", updateGames.Count);
                await Parallel.ForEachAsync(
                    updateGames,
                    async (game, _) => await UpdateGameAsync(dbGames, game)
                );
            }

            // 删除已删除的游戏
            var deletedGames = dbGames.ExceptBy(games.Select(x => x.Id), x => x.Id).ToList();
            if (deletedGames.Count > 0)
            {
                logger.LogInformation("发现{Count}个已删除游戏，准备删除", deletedGames.Count);

                var filter = Builders<SteamGame>.Filter.In(
                    x => x.Id,
                    deletedGames.Select(x => x.Id)
                );
                await repository.DeleteAsync(filter);
            }

            await RemoveByPrefixAfterAsync();
            logger.LogInformation(
                "Steam游戏数据更新完成，新增：{NewCount}，更新：{UpdateCount}，删除：{DeletedCount}，实例ID：{InstanceId}",
                newGames.Count,
                updateGames.Count,
                deletedGames.Count,
                _instanceId.Value
            );
        }
        catch (Exception ex)
        {
            logger.LogError(
                ex,
                "更新Steam游戏数据时发生异常，实例ID：{InstanceId}",
                _instanceId.Value
            );
            throw;
        }
        finally
        {
            // 确保在任何情况下都释放锁
            try
            {
                await _fusionCache.RemoveAsync(RunningInstanceIdKey);
                logger.LogDebug("已释放Steam游戏更新锁，实例ID：{InstanceId}", _instanceId.Value);
            }
            catch (Exception ex)
            {
                logger.LogError(
                    ex,
                    "释放Steam游戏更新锁时发生异常，实例ID：{InstanceId}",
                    _instanceId.Value
                );
            }
        }
    }

    private async Task UpdateGameAsync(List<SteamGame> dbGames, SteamGame updateGame)
    {
        var dbGame = dbGames.Find(x => x.Id == updateGame.Id);
        if (dbGame != null)
        {
            var dic = dbGame.UpdateContent(updateGame);
            if (dic.Count > 0)
            {
                logger.LogInformation(
                    "更新游戏 {GameId}/{GameName} 的数据，更新细节：{@UpdateContent}",
                    updateGame.Id,
                    updateGame.Name,
                    dic
                );
            }
        }
        await repository.UpdateAsync(updateGame);
    }

    private async Task<List<AchievementDetail>> FetchAchievementsAsync(
        int id,
        List<SteamGame> dbGames
    )
    {
        var queryString = new Dictionary<string, string?>
        {
            { "steamid", _steamConfig.SteamId },
            { "key", _steamConfig.AppKey },
            { "format", "json" },
            { "appid", id.ToString() },
            { "l", "schinese" },
        };

        // 添加API请求延迟
        await Task.Delay(ApiDelayMs);

        logger.LogDebug("获取游戏 {GameId} 的成就数据", id);
        var achievements =
            await ExecuteHttpRequestAsync<List<AchievementDetail>>(
                "/ISteamUserStats/GetSchemaForGame/v2/",
                queryString,
                root => root?["game"]?["availableGameStats"]?["achievements"]
            ) ?? [];

        var unlockAchievements = await FetchUnlockAchievementAsync(queryString);
#if DEBUG
        var options = new ParallelOptions { MaxDegreeOfParallelism = 1 };
#endif
        await Parallel.ForEachAsync(
            achievements,
#if DEBUG
            options,
#endif
            async (achievement, _) =>
            {
                if (
                    unlockAchievements.TryGetValue(achievement.Name, out var unlockTime)
                    && unlockTime > 0
                )
                {
                    achievement.UnlockTime = unlockTime.ToDateTime();
                }

                await DownloadAchievementAsync(dbGames, id, achievement);
                await DownloadAchievementGrayAsync(dbGames, id, achievement);
            }
        );

        logger.LogDebug("游戏 {GameId} 共获取到 {Count} 个成就", id, achievements.Count);
        return achievements;
    }

    private async Task<Dictionary<string, long>> FetchUnlockAchievementAsync(
        Dictionary<string, string?> queryString
    )
    {
        logger.LogDebug("获取已解锁的成就数据");

        // 添加API请求延迟
        await Task.Delay(ApiDelayMs);

        return await ExecuteHttpRequestAsync<Dictionary<string, long>>(
                "/ISteamUserStats/GetPlayerAchievements/v0001/",
                queryString,
                root =>
                {
                    var achievements = root
                        ?["playerstats"]?["achievements"]?.AsArray()
                        .Select(x =>
                        {
                            var name = x?["apiname"]?.GetValue<string>();
                            if (name == null)
                            {
                                logger.LogError(
                                    "Achievement name is null for {SteamId}",
                                    _steamConfig.SteamId
                                );
                                return (KeyValuePair<string, long>?)null;
                            }
                            var unlockTime = x?["unlocktime"]?.GetValue<long>() ?? 0;
                            return x?["achieved"]?.GetValue<int>() == 1
                                ? KeyValuePair.Create(name, unlockTime)
                                : KeyValuePair.Create(name, 0L);
                        })
                        .Where(x => x != null)
                        .Select(x => x!.Value)
                        .ToDictionary(x => x.Key, x => x.Value);
                    return JsonValue.Create(achievements);
                }
            ) ?? [];
    }

    private async Task<List<SteamGame>> FetchGamesAsync(List<SteamGame> dbGames)
    {
        logger.LogInformation("开始获取Steam游戏列表");

        var games = await ApplicationTools.RetryAsync(
            async () =>
            {
                var queryString = new Dictionary<string, string?>
                {
                    { "steamid", _steamConfig.SteamId },
                    { "key", _steamConfig.AppKey },
                    { "include_appinfo", "1" },
                    { "format", "json" },
                };

                // 添加API请求延迟
                await Task.Delay(ApiDelayMs);

                var result = await ExecuteHttpRequestAsync<List<SteamGame>>(
                    "/IPlayerService/GetOwnedGames/v0001/",
                    queryString,
                    root => root?["response"]?["games"]?.AsArray()
                );

                // 如果返回null，抛出异常以触发重试
                if (result == null)
                {
                    throw new InvalidOperationException("Steam API返回null，触发重试");
                }

                return result;
            },
            retryInterval: TimeSpan.FromMilliseconds(ApiDelayMs),
            maxAttemptCount: 3,
            specificExceptionTypes: [typeof(JsonException)] // JSON错误不重试
        );

        logger.LogInformation("获取到 {Count} 个Steam游戏", games.Count);

#if DEBUG
        var options = new ParallelOptions { MaxDegreeOfParallelism = 1 };
#endif
        await Parallel.ForEachAsync(
            games,
#if DEBUG
            options,
#endif
            async (game, _) => await UpdateGame(dbGames, game)
        );

        return games;
    }

    private async Task UpdateGame(List<SteamGame> dbGames, SteamGame game)
    {
        logger.LogDebug("更新游戏 {GameId}/{GameName} 的基本信息", game.Id, game.Name);
        var achievements = await FetchAchievementsAsync(game.Id, dbGames);

        var originGame = dbGames.Find(x => x.Id == game.Id);

        if (achievements is { Count: > 0 })
        {
            game.Achievements = achievements;
            game.LastUpdateTime = DateTime.Now;
        }
        else if (originGame != null)
        {
            game.Achievements = originGame.Achievements ?? [];
        }
        else
        {
            game.Achievements = [];
            game.LastUpdateTime = DateTime.Now;
        }

        if (!AreAssetsDownloaded(originGame))
        {
            logger.LogDebug("下载游戏 {GameId} 的Logo", game.Id);

            // 添加API请求延迟
            await Task.Delay(ApiDelayMs);

            await using var stream = await HttpDownloadAsync(
                string.Format(_cdnConfig.LogoUrlTemplate, game.Id)
            );
            if (stream != null && OnLogoDownloadComplete != null)
            {
                var url = await OnLogoDownloadComplete(stream, game.Id);
                if (!string.IsNullOrWhiteSpace(url))
                {
                    game.ImageLogo = url;
                    game.ImageIcon = url;
                    game.LastUpdateTime = DateTime.Now;
                }
            }
        }
        else
        {
            game.ImageLogo = originGame?.ImageLogo;
            game.ImageIcon = originGame?.ImageIcon;
            logger.LogDebug("游戏 {GameId} Logo 无需更新", game.Id);
        }
    }

    private async Task<Stream?> HttpDownloadAsync(string uri)
    {
        try
        {
            var response = await httpClient.GetAsync(uri);
            response.EnsureSuccessStatusCode();
            var memoryStream = new MemoryStream();
            await response.Content.CopyToAsync(memoryStream);
            memoryStream.Position = 0;
            return memoryStream;
        }
        catch (Exception e)
        {
            logger.LogError(e, "Download failed for {Uri}", uri);
            return null;
        }
    }

    private bool AreAssetsDownloaded(SteamGame? originGame)
    {
        return originGame != null
            && originGame.ImageIcon?.StartsWith(
                _cdnConfig.BaseUrl,
                StringComparison.OrdinalIgnoreCase
            ) == true
            && originGame.ImageLogo?.StartsWith(
                _cdnConfig.BaseUrl,
                StringComparison.OrdinalIgnoreCase
            ) == true;
    }

    private async Task DownloadAchievementAsync(
        List<SteamGame> dbGames,
        int id,
        AchievementDetail achievement
    )
    {
        var dbAchievement = dbGames
            .FirstOrDefault(x => x.Id == id)
            ?.Achievements?.FirstOrDefault(x => x.Name == achievement.Name);

        if (
            dbAchievement?.Icon.StartsWith(_cdnConfig.BaseUrl, StringComparison.OrdinalIgnoreCase)
            ?? false
        )
        {
            achievement.Icon = dbAchievement.Icon;
            return;
        }

        logger.LogDebug("下载游戏 {GameId} 成就 {AchievementName} 的图标", id, achievement.Name);

        // 添加API请求延迟
        await Task.Delay(ApiDelayMs);

        await using var icon = await HttpDownloadAsync(achievement.Icon);
        var handler = OnAchievementIconDownloadComplete;
        if (icon != null && handler != null)
        {
            var url = await handler.Invoke(icon, id, achievement.Name);
            if (!string.IsNullOrWhiteSpace(url))
            {
                achievement.Icon = url;
            }
        }
    }

    private async Task DownloadAchievementGrayAsync(
        IEnumerable<SteamGame> dbGames,
        int id,
        AchievementDetail achievement
    )
    {
        var dbAchievement = dbGames
            .FirstOrDefault(x => x.Id == id)
            ?.Achievements?.FirstOrDefault(x => x.Name == achievement.Name);

        if (
            dbAchievement?.IconGray.StartsWith(
                _cdnConfig.BaseUrl,
                StringComparison.OrdinalIgnoreCase
            ) ?? false
        )
        {
            achievement.IconGray = dbAchievement.IconGray;
            return;
        }

        logger.LogDebug(
            "下载游戏 {GameId} 成就 {AchievementName} 的灰色图标",
            id,
            achievement.Name
        );

        // 添加API请求延迟
        await Task.Delay(ApiDelayMs);

        await using var icon = await HttpDownloadAsync(achievement.IconGray);
        var handler = OnAchievementIconGrayDownloadComplete;
        if (icon != null && handler != null)
        {
            var url = await handler.Invoke(icon, id, achievement.Name);
            if (!string.IsNullOrWhiteSpace(url))
            {
                achievement.IconGray = url;
            }
        }
    }

    public async Task<List<VmSteamGame>> GetGamesAsync()
    {
        return await GetOrSetCacheAsync<List<VmSteamGame>>(
            nameof(GetGamesAsync),
            async (_, cancellationToken) =>
            {
                var list = await repository.SearchFor(x => true).ToListAsync(cancellationToken);
                var result = mapper.Map<List<VmSteamGame>>(list);
                return result;
            }
        );
    }

    public async Task<VmSteamGame?> GetGameAsync(int id)
    {
        return await GetOrSetCacheAsync<VmSteamGame?>(
            nameof(GetGameAsync),
            async (_, cancellationToken) =>
            {
                var game = await repository
                    .SearchFor(x => x.Id == id)
                    .FirstOrDefaultAsync(cancellationToken);
                if (game == null)
                {
                    logger.LogWarning("未找到游戏 {GameId} 的信息", id);
                    return null;
                }
                var result = mapper.Map<VmSteamGame>(game);
                return result;
            },
            new { id }
        );
    }

    private async Task<T?> ExecuteHttpRequestAsync<T>(
        string endpoint,
        Dictionary<string, string?> queryParams,
        Func<JsonNode?, JsonNode?>? dataSelector = null
    )
    {
        var requestUri = QueryHelpers.AddQueryString(endpoint, queryParams);
        var jsonContent = "";
        try
        {
            var response = await httpClient.GetAsync(requestUri);
            response.EnsureSuccessStatusCode();
            jsonContent = await response.Content.ReadAsStringAsync();

            if (string.IsNullOrWhiteSpace(jsonContent))
            {
                logger.LogWarning("Steam API返回空内容，请求地址：{RequestUri}", requestUri);
                return default;
            }

            var jsonNode = JsonNode.Parse(jsonContent);
            if (jsonNode == null)
            {
                logger.LogWarning(
                    "Steam API返回的JSON无法解析，请求地址：{RequestUri}，内容：{Content}",
                    requestUri,
                    jsonContent
                );
                return default;
            }

            var data = dataSelector?.Invoke(jsonNode) ?? jsonNode;

            var result = data.Deserialize<T>();
            if (result == null)
            {
                logger.LogWarning(
                    "Steam API数据反序列化失败，请求地址：{RequestUri}，数据：{Data}",
                    requestUri,
                    data.ToString()
                );
            }

            return result;
        }
        catch (JsonException e)
        {
            logger.LogError(
                e,
                "Steam API数据解析失败，请求地址：{RequestUri}，内容：{Content}",
                requestUri,
                jsonContent
            );
            return default;
        }
        catch (Exception e)
        {
            logger.LogError(e, "Steam API请求失败，请求地址：{RequestUri}", requestUri);
            return default;
        }
    }
}
⚠⚠    以下内容为AI分析的结果，请根据实际情况进行判断。

上述代码是一个 C# 类 SteamGameService 的实现，主要用于与 Steam API 交互，管理和更新 Steam 游戏的信息。以下是该类的主要功能和结构的详细解释：

主要功能

  1. 游戏信息更新：

    • UpdateGamesAsync 方法用于更新数据库中的游戏信息。它首先从数据库中获取所有游戏，然后通过 Steam API 获取最新的游戏数据。
    • 新增的游戏会被插入到数据库中，而已有的游戏则会根据最新的游戏时长和成就进行更新。

  2. 游戏成就获取：

    • FetchAchievementsAsync 方法用于获取特定游戏的成就信息。它会调用 Steam API 获取成就数据，并下载成就图标。
    • FetchUnlockAchievementAsync 方法用于获取玩家已解锁的成就。

  3. 游戏库获取：

    • FetchGamesAsync 方法从 Steam API 获取用户的游戏库列表，并为每个游戏获取成就信息和下载游戏的图标。

  4. 图像下载：

    • HttpDownloadAsync 方法用于下载游戏或成就的图像。
    • DownloadAchievementAsync 和 DownloadAchievementGrayAsync 方法用于下载成就的图标和灰色图标。

  5. 缓存管理：

    • 使用 IHybridCachingProvider 进行缓存管理，以提高性能，避免频繁访问数据库和 Steam API。
    • GetGamesAsync 和 GetGameAsync 方法从缓存中获取游戏信息，如果缓存不存在，则从数据库中获取并更新缓存。

  6. 事件处理：

    • 类中定义了多个事件（如 OnLogoDownloadComplete 和 OnAchievementIconDownloadComplete），用于在下载完成后执行特定操作。

  7. 测试方法：

    • Test 方法用于测试 MongoDB 更新操作的序列化，输出更新操作的渲染结果。

代码结构

  • 构造函数：使用 ActivatorUtilitiesConstructor 特性，允许依赖注入。
  • 私有字段：如 _prefixKey 用于缓存键的前缀。
  • 异步方法：大部分方法都是异步的，使用 async 和 await 关键字，以支持非阻塞的 I/O 操作。
  • LINQ 查询：使用 LINQ 进行集合操作，如 ExceptBy 和 IntersectBy，以便于处理游戏的新增和更新。

总结

SteamGameService 类是一个功能丰富的服务类，主要用于管理 Steam 游戏的信息，包括获取、更新和缓存游戏及其成就数据。它通过与 Steam API 的交互，提供了一个完整的游戏信息管理解决方案，并通过事件和缓存机制提高了性能和可扩展性。

loading