TourIAm/TIAMWebApp/Server/Services/DevAdminSignalRhub.cs

using AyCode.Core.Extensions;
using AyCode.Core.Helpers;
using AyCode.Core.Loggers;
using AyCode.Services.SignalRs;
using Microsoft.AspNetCore.SignalR;
using TIAM.Database.DataLayers.Admins;
using MessagePack;
using MessagePack.Resolvers;
using AyCode.Services.Server.SignalRs;
using System.ServiceModel.Channels;
using TIAM.Services;
using TIAMWebApp.Server.Controllers;

namespace TIAMWebApp.Server.Services;

public class DevAdminSignalRHub(AdminDal adminDal, ServiceProviderAPIController serviceProviderAPIController, TransferDataAPIController transferDataAPIController, IEnumerable<IAcLogWriterBase> logWriters) : Hub<ISignalRHubItemServer>, IAcSignalRHubServer
{
    private readonly TIAM.Core.Loggers.Logger<DevAdminSignalRHub> _logger = new(logWriters.ToArray());

    // https://docs.microsoft.com/en-us/aspnet/core/signalr/hubs?view=aspnetcore-3.1#strongly-typed-hubs
    public override async Task OnConnectedAsync()
    {
        _logger.Debug($"Server OnConnectedAsync; ConnectionId: {Context.ConnectionId}; UserIdentifier: {Context.UserIdentifier}");

        //await Groups.AddToGroupAsync(Context.ConnectionId, "SignalR Users");
        await base.OnConnectedAsync();

        //Clients.Caller.ConnectionId = Context.ConnectionId;
        //Clients.Caller.UserIdentifier = Context.UserIdentifier;
    }

    public override async Task OnDisconnectedAsync(Exception? exception)
    {
        _logger.Error($"Server OnDisconnectedAsync; ConnectionId: {Context.ConnectionId}; UserIdentifier: {Context.UserIdentifier}", exception);

        //await Groups.RemoveFromGroupAsync(Context.ConnectionId, "SignalR Users");
        await base.OnDisconnectedAsync(exception);
    }

    //public async Task OnRequestMessage(int messageTag, int requestId)
    //{
    //    _logger.Info($"Server OnRequestMessage; {nameof(messageTag)}: {messageTag}; {nameof(requestId)}: {requestId}; ConnectionId: {Context.ConnectionId}; UserIdentifier: {Context.UserIdentifier}");

    //    if (messageTag == SignalRTags.GetTransfersAsync)
    //        await ResponseToCaller(SignalRTags.PostTransfersAsync, await adminDal.GetTransfersJsonAsync(), requestId);
    //}

    public async Task OnReceiveMessage(int messageTag, byte[]? message, int? requestId)
    {
        var logText = $"Server OnReceiveMessage; {nameof(messageTag)}: {messageTag}; {nameof(requestId)}: {requestId}; ConnectionId: {Context.ConnectionId}; UserIdentifier: {Context.UserIdentifier}";

        if (message is { Length: 0 }) _logger.Warning($"message.Length == 0! {logText}");
        else _logger.Info(logText);

        try
        {
            if (messageTag == SignalRTags.GetTransfersAsync)
            {
                await ResponseToCaller(messageTag, new SignalResponseMessage<string>(SignalResponseStatus.Success, await transferDataAPIController.GetTransfers()), requestId);
            }
            else if (messageTag == SignalRTags.GetPropertiesByOwnerIdAsync)
            {
                var ownerId = message.MessagePackTo<SignalRequestByIdMessage>().Id;
                var json = (await serviceProviderAPIController.GetServiceProvidersByOwnerId(ownerId)).ToJson();

                await ResponseToCaller(messageTag, new SignalResponseMessage<string>(SignalResponseStatus.Success, json), requestId);
            }

            return;
        }
        catch (Exception ex)
        {
            _logger.Error($"Server OnReceiveMessage; {ex.Message}", ex);
        }

        await ResponseToCaller(messageTag, new SignalResponseMessage<byte[]>(SignalResponseStatus.Error, null), requestId);
    }

    protected async Task ResponseToCaller(int messageTag, ISignalRMessage message, int? requestId)
        => await SendMessageToClient(Clients.Caller, messageTag, message, requestId);

    protected async Task SendMessageToClient(ISignalRHubItemServer sendTo, int messageTag, ISignalRMessage message, int? requestId = null)
    {
        _logger.Info($"Server SendMessageToClient; {nameof(messageTag)}: {messageTag}; {nameof(requestId)}: {requestId}; ConnectionId: {Context.ConnectionId}; UserIdentifier: {Context.UserIdentifier}");

        await sendTo.OnReceiveMessage(messageTag, message.ToMessagePack(ContractlessStandardResolver.Options), requestId);
    }

    //protected void SendRequestToClient(ISignalRHubItemServer sendTo, int messageTag, int requestId)
    //{
    //    _logger.Info($"Server SendRequestToClient; {nameof(messageTag)}: {messageTag}; {nameof(requestId)}: {requestId}; ConnectionId: {Context.ConnectionId}; UserIdentifier: {Context.UserIdentifier}");

    //    sendTo.OnRequestMessage(messageTag, requestId).Forget();
    //}

    public async Task SendMessageToGroup(string groupId, int messageTag, string message)
    {
        //await Clients.Group(groupId).Post("", messageTag, message);
    }
}