EVCB_OCPP.OCPPServer.16J/EVCB_OCPP.WSServer/Service/WsService/WebsocketService.cs

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Primitives;
using System.Net;
using System.Net.WebSockets;
using System.Text;

namespace EVCB_OCPP.WSServer.Service.WsService;

public static class AppExtention
{
    public static void MapWsService(this WebApplication webApplication)
    {
        var protocals = new List<string>() { "", "ocpp1.6", "ocpp2.0" };

        webApplication.UseWebSockets(new WebSocketOptions()
        {
            KeepAliveInterval = TimeSpan.FromSeconds(10)
        });

        webApplication.Use(async (context, next) =>
        {

            if (!context.WebSockets.IsWebSocketRequest)
            {
                await next(context);
                return;
            }

            var matched = context.WebSockets.WebSocketRequestedProtocols.Intersect(protocals);
            if (matched is null || !matched.Any())
            {
                await context.Response.WriteAsync("Protocol not matched");
                return;
            }
            using WebSocket webSocket = await context.WebSockets.AcceptWebSocketAsync(matched.Last());
            var servcie = context.RequestServices.GetService<WebsocketService<WsClientData>>();
            await servcie.AddWebSocket(webSocket, context);
            return;
        });
    }
}

public class WebsocketService<T> where T : WsSession
{
    public WebsocketService() { }

    public Func<T, Task<bool>> ValidateHandshake;

    public event EventHandler<T> NewSessionConnected;

    public async Task AddWebSocket(WebSocket webSocket, HttpContext context)
    {
        T data = Activator.CreateInstance<T>();
        data.ClientWebSocket = webSocket;
        data.SessionID = context.TraceIdentifier;
        data.Path = context?.Request?.Path;
        //data.UriScheme = context?.Request?.Scheme;
        data.AuthHeader = context?.Request?.Headers?.Authorization;
        //data.Origin = context.Request.Scheme;

        var origin = context.Request.Headers.Origin.FirstOrDefault();
        try
        {
            data.UriScheme = new Uri(origin).Scheme;
        }
        catch
        {
            data.UriScheme = origin;
        }

        try
        {
            var ipaddress = context.Connection.RemoteIpAddress;
            var port = context.Connection.RemotePort;
            data.Endpoint = new IPEndPoint(ipaddress, port);
        }
        catch
        {
            data.Endpoint = null;
        }

        var validated = ValidateHandshake == null ? false : await ValidateHandshake(data);

        if (!validated)
        {
            return;
        }

        NewSessionConnected?.Invoke(this, data);
        await data.EndConnSemaphore.WaitAsync();
        return;
    }
}

public enum CloseReason
{
    ClientClosing,
    ServerShutdown
}