AiDOPWarehouse/Admin.NET/Admin.NET.Core/Service/Common/SysCommonService.cs

// Admin.NET 项目的版权、商标、专利和其他相关权利均受相应法律法规的保护。使用本项目应遵守相关法律法规和许可证的要求。
//
// 本项目主要遵循 MIT 许可证和 Apache 许可证（版本 2.0）进行分发和使用。许可证位于源代码树根目录中的 LICENSE-MIT 和 LICENSE-APACHE 文件。
//
// 不得利用本项目从事危害国家安全、扰乱社会秩序、侵犯他人合法权益等法律法规禁止的活动！任何基于本项目二次开发而产生的一切法律纠纷和责任，我们不承担任何责任！

using Microsoft.AspNetCore.Mvc.ApiExplorer;
using Org.BouncyCastle.Crypto.Parameters;
using Org.BouncyCastle.Utilities.Encoders;
using Swashbuckle.AspNetCore.SwaggerGen;

namespace Admin.NET.Core.Service;

/// <summary>
/// 系统通用服务 🧩
/// </summary>
[ApiDescriptionSettings(Order = 101)]
[AllowAnonymous]
public class SysCommonService : IDynamicApiController, ITransient
{
    private readonly IApiDescriptionGroupCollectionProvider _apiProvider;
    private readonly SqlSugarRepository<SysUser> _sysUserRep;
    private readonly CDConfigOptions _cdConfigOptions;
    private readonly UserManager _userManager;
    private readonly HttpClient _httpClient;

    public SysCommonService(IApiDescriptionGroupCollectionProvider apiProvider,
        SqlSugarRepository<SysUser> sysUserRep,
        IOptions<CDConfigOptions> giteeOptions,
        IHttpClientFactory httpClientFactory,
        UserManager userManager)
    {
        _sysUserRep = sysUserRep;
        _apiProvider = apiProvider;
        _userManager = userManager;
        _cdConfigOptions = giteeOptions.Value;
        _httpClient = httpClientFactory.CreateClient();
    }

    /// <summary>
    /// 获取国密公钥私钥对 🏆
    /// </summary>
    /// <returns></returns>
    [DisplayName("获取国密公钥私钥对")]
    public SmKeyPairOutput GetSmKeyPair()
    {
        var kp = GM.GenerateKeyPair();
        var privateKey = Hex.ToHexString(((ECPrivateKeyParameters)kp.Private).D.ToByteArray()).ToUpper();
        var publicKey = Hex.ToHexString(((ECPublicKeyParameters)kp.Public).Q.GetEncoded()).ToUpper();

        return new SmKeyPairOutput
        {
            PrivateKey = privateKey,
            PublicKey = publicKey,
        };
    }

    /// <summary>
    /// 获取所有接口/动态API 🔖
    /// </summary>
    /// <returns></returns>
    [DisplayName("获取所有接口/动态API")]
    public List<ApiOutput> GetApiList()
    {
        var apiList = new List<ApiOutput>();
        foreach (var item in _apiProvider.ApiDescriptionGroups.Items)
        {
            foreach (var apiDescription in item.Items)
            {
                var displayName = apiDescription.TryGetMethodInfo(out MethodInfo apiMethodInfo) ? apiMethodInfo.GetCustomAttribute<DisplayNameAttribute>(true)?.DisplayName : "";

                apiList.Add(new ApiOutput
                {
                    GroupName = item.GroupName,
                    DisplayName = displayName,
                    RouteName = apiDescription.RelativePath
                });
            }
        }
        return apiList;
    }

    /// <summary>
    /// 下载标记错误的临时Excel（全局）
    /// </summary>
    /// <returns></returns>
    [DisplayName("下载标记错误的临时Excel（全局）")]
    public async Task<IActionResult> DownloadErrorExcelTemp([FromQuery] string fileName = null)
    {
        var userId = App.User?.FindFirst(ClaimConst.UserId)?.Value;
        var resultStream = App.GetRequiredService<SysCacheService>().Get<MemoryStream>(CacheConst.KeyExcelTemp + userId);

        if (resultStream == null) throw Oops.Oh("错误标记文件已过期。");

        return await Task.FromResult(new FileStreamResult(resultStream, "application/octet-stream")
        {
            FileDownloadName = $"{(string.IsNullOrEmpty(fileName) ? "错误标记＿" + DateTime.Now.ToString("yyyyMMddhhmmss") : fileName)}.xlsx"
        });
    }

    /// <summary>
    /// 加密字符串 🔖
    /// </summary>
    /// <returns></returns>
    [SuppressMonitor]
    [DisplayName("加密字符串")]
    public dynamic EncryptPlainText([Required] string plainText)
    {
        return CryptogramUtil.Encrypt(plainText);
    }

    /// <summary>
    /// 接口压测 🔖
    /// </summary>
    /// <returns></returns>
    [DisplayName("接口压测")]
    public async Task<StressTestOutput> StressTest(StressTestInput input)
    {
        // 限制仅超管用户才能使用此功能
        if (!_userManager.SuperAdmin) throw Oops.Oh(ErrorCodeEnum.SA001);

        var stopwatch = new Stopwatch();
        var responseTimes = new List<double>();
        long totalRequests = 0, successfulRequests = 0, failedRequests = 0;

        stopwatch.Start();
        var semaphore = new SemaphoreSlim(input.MaxDegreeOfParallelism!.Value > 0 ? input.MaxDegreeOfParallelism.Value : Environment.ProcessorCount);

        var tasks = Enumerable.Range(0, input.NumberOfRounds!.Value * input.NumberOfRequests!.Value).Select(async _ =>
        {
            await semaphore.WaitAsync();
            try
            {
                var requestStopwatch = new Stopwatch();
                requestStopwatch.Start();

                // 构建完整的请求URI，包括路径参数和查询参数
                var uriBuilder = new UriBuilder(input.RequestUri);
                var queryString = HttpUtility.ParseQueryString(uriBuilder.Query);

                foreach (var param in input.PathParameters)
                {
                    uriBuilder.Path = uriBuilder.Path.Replace($"{{{param.Key}}}", param.Value, StringComparison.OrdinalIgnoreCase);
                }

                foreach (var param in input.QueryParameters)
                {
                    queryString[param.Key] = param.Value;
                }

                uriBuilder.Query = queryString.ToString() ?? string.Empty;
                var fullUri = uriBuilder.Uri.ToString();

                HttpRequestMessage request = new(input.RequestMethod!, fullUri);

                // 设置请求头
                foreach (var header in input.Headers)
                {
                    request.Headers.Add(header.Key, header.Value);
                }

                if (input.RequestMethod != HttpMethod.Get && input.RequestParameters.Any())
                {
                    var content = new FormUrlEncodedContent(input.RequestParameters);
                    request.Content = content;
                }

                var response = await _httpClient.SendAsync(request);
                response.EnsureSuccessStatusCode(); // 抛出错误状态码异常

                requestStopwatch.Stop();
                responseTimes.Add(requestStopwatch.Elapsed.TotalMilliseconds);
                Interlocked.Increment(ref successfulRequests);
            }
            catch
            {
                Interlocked.Increment(ref failedRequests);
            }
            finally
            {
                Interlocked.Increment(ref totalRequests);
                semaphore.Release();
            }
        });

        await Task.WhenAll(tasks);
        stopwatch.Stop();

        var totalTimeInSeconds = stopwatch.Elapsed.TotalSeconds;
        var qps = totalTimeInSeconds > 0 ? totalRequests / totalTimeInSeconds : 0;
        var averageResponseTime = responseTimes.Any() ? responseTimes.Average() : 0;
        var minResponseTime = responseTimes.Any() ? responseTimes.Min() : 0;
        var maxResponseTime = responseTimes.Any() ? responseTimes.Max() : 0;

        return new StressTestOutput
        {
            TotalRequests = totalRequests,
            TotalTimeInSeconds = totalTimeInSeconds,
            SuccessfulRequests = successfulRequests,
            FailedRequests = failedRequests,
            QueriesPerSecond = qps,
            MinResponseTime = minResponseTime,
            MaxResponseTime = maxResponseTime,
            AverageResponseTime = averageResponseTime,
            Percentile10ResponseTime = CalculatePercentile(responseTimes, 0.1),
            Percentile25ResponseTime = CalculatePercentile(responseTimes, 0.25),
            Percentile50ResponseTime = CalculatePercentile(responseTimes, 0.5),
            Percentile75ResponseTime = CalculatePercentile(responseTimes, 0.75),
            Percentile90ResponseTime = CalculatePercentile(responseTimes, 0.9),
            Percentile99ResponseTime = CalculatePercentile(responseTimes, 0.99),
            Percentile999ResponseTime = CalculatePercentile(responseTimes, 0.999)
        };
    }

    /// <summary>
    /// 计算百分位请求耗时
    /// </summary>
    /// <param name="times">请求耗时列表</param>
    /// <param name="percentile">百分位</param>
    /// <returns></returns>
    private double CalculatePercentile(List<double> times, double percentile)
    {
        if (!times.Any()) return 0;
        var sortedTimes = times.OrderBy(t => t).ToList();
        var index = (int)Math.Ceiling(percentile * sortedTimes.Count) - 1;
        return sortedTimes[index < sortedTimes.Count ? index : sortedTimes.Count - 1];
    }
}