EVCB_OCPP.OCPPServer.16J/EVCB_OCPP.WSServer/Service/MapApiServce.cs

using EVCB_OCPP.WSServer.Service.WsService;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using NLog;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace EVCB_OCPP.WSServer.Service;

public static class MapApiServceExtention
{
    public static void MapApiServce(this WebApplication webApplication)
    {
        var pass = webApplication.Configuration["apipass"];

        var helpFunc = () =>
        {
            string sshaString = "";

            if (File.Exists("ssha"))
            {
                sshaString = File.ReadAllText("ssha");
            }

            return string.Join("\r\n", new[] {
                $"Git commit:{sshaString}",
                "Command help!!",
                "lcn : List Customer Name",
                "gc : GC Collect",
                "lc : List Clients",
                "silent : silent",
                "show : show log"
            });
        };
        webApplication.MapGet("/", helpFunc);
        webApplication.MapGet("/help", helpFunc);

        webApplication.MapPost("/stop", (ProtalServer server) =>
        {
            server.Stop();
            return "Command stop";
        }).AddAuthFilter(pass);

        webApplication.MapPost("/gc", () =>
        {
            GC.Collect();
            return "Command GC";
        }).AddAuthFilter(pass);

        webApplication.MapPost("/lc", (ProtalServer server) =>
        {
            List<string> toReturn = new List<string>() { "Command List Clients" };
            Dictionary<string, WsClientData> clientDic = server.GetClientDic();
            var list = clientDic.Select(c => c.Value).ToList();
            int i = 1;
            foreach (var c in list)
            {
                toReturn.Add(i + ":" + c.ChargeBoxId + " " + c.SessionID);
                i++;
            }
            return string.Join("\r\n", toReturn);
        }).AddAuthFilter(pass);

        webApplication.MapPost("/lcn", (ProtalServer server) =>
        {
            List<string> toReturn = new List<string> { "Command List Customer Name" };
            Dictionary<string, WsClientData> clientDic = server.GetClientDic();
            var lcn = clientDic.Select(c => c.Value.CustomerName).Distinct().ToList();
            int iLcn = 1;
            foreach (var c in lcn)
            {
                toReturn.Add(iLcn + ":" + c + ":" + clientDic.Where(z => z.Value.CustomerName == c).Count().ToString());
                iLcn++;
            }
            return string.Join("\r\n", toReturn);
        }).AddAuthFilter(pass);

        webApplication.MapPost("/silent", () =>
        {
            foreach (var rule in LogManager.Configuration.LoggingRules)
            {
                if (rule.RuleName != "ConsoleLog")
                {
                    continue;
                }

                var isTargetRule = rule.Targets.Any(x => x.Name.ToLower() == "console");

                if (isTargetRule)
                {
                    rule.SetLoggingLevels(NLog.LogLevel.Warn, NLog.LogLevel.Off);
                }
            }
            return "Command silent";
        }).AddAuthFilter(pass);

        webApplication.MapPost("/show", () =>
        {
            foreach (var rule in LogManager.Configuration.LoggingRules)
            {
                if (rule.RuleName != "ConsoleLog")
                {
                    continue;
                }

                var isTargetRule = rule.Targets.Any(x => x.Name.ToLower() == "console");

                if (isTargetRule)
                {
                    rule.SetLoggingLevels(NLog.LogLevel.Trace, NLog.LogLevel.Off);
                }
            }
            return "Command show";
        }).AddAuthFilter(pass);

        webApplication.MapGet("/threads", () =>
        {
            ThreadPool.GetMaxThreads(out var maxWorkerThread, out var maxCompletionPortThreads);
            ThreadPool.GetAvailableThreads(out var avaliableWorkerThread, out var avaliableCompletionPortThreads);
            return $"WorkerThread:{avaliableWorkerThread}/{maxWorkerThread} CompletionPortThreads{avaliableCompletionPortThreads}/{maxCompletionPortThreads}";
        }).AddAuthFilter(pass);

        webApplication.MapPost("/threads", (int min, int max) =>
        {
            ThreadPool.GetMaxThreads(out var maxWorkerThread, out var maxCompletionPortThreads);
            ThreadPool.GetAvailableThreads(out var avaliableWorkerThread, out var avaliableCompletionPortThreads);
            ThreadPool.SetMinThreads(min, 0);
            ThreadPool.SetMaxThreads(max, maxCompletionPortThreads);
            return $"WorkerThread:{avaliableWorkerThread}/{maxWorkerThread} CompletionPortThreads{avaliableCompletionPortThreads}/{maxCompletionPortThreads}";
        }).AddAuthFilter(pass);

        webApplication.MapGet("/blcn", (ProtalServer server) =>
        {
            int cnt = server.GetBootLockCnt();
            return $"boot lock cnt: {cnt}";
        });

        webApplication.MapGet("/lpcn", (ProtalServer server) =>
        {
            Dictionary<string, WsClientData> clientDic = server.GetClientDic();
            var acceptedCnt = clientDic.Values.Count(x => x.BootStatus == BootStatus.Accepted);
            var pendingCnt = clientDic.Values.Count(x => x.BootStatus == BootStatus.Pending);
            var initializingCnt = clientDic.Values.Count(x => x.BootStatus == BootStatus.Initializing);
            var startupCnt = clientDic.Values.Count(x => x.BootStatus == BootStatus.Startup);
            return $"IsCheckIn cnt: {startupCnt}/{initializingCnt}/{pendingCnt}/{acceptedCnt}";
        });
    }

    public static void AddAuthFilter(this RouteHandlerBuilder routeHandlerBuilder, string pass)
    {
        routeHandlerBuilder.AddEndpointFilter(async (context, next) =>
        {
            string key = context.HttpContext.Request.Headers["key"];
            if (!string.IsNullOrEmpty(pass) &&
                key != pass)
            {
                return Results.BadRequest();
            }
            return await next(context);
        });
    }
}