sledgemapper/Sledgemapper/CommunicationManager.cs

using Microsoft.AspNetCore.SignalR.Client;
using Polly;
using Refit;
using Sledgemapper.Shared.Entities;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Threading.Tasks;

namespace Sledgemapper
{
    public class CommunicationManager
    {
        public IMapApi Api { get; private set; }
        public HubConnection Connection { get; private set; }
        public Session SessionData;
        private ChannelsQueue Queue = new ChannelsQueue();
        private AuthenticateResponse _authenticateResponse;

        public CommunicationManager(Session sessionData)
        {
            SessionData = sessionData;
            Connection = new HubConnectionBuilder()
                                       .WithAutomaticReconnect()

                                       .WithUrl("http://localhost:5000/SledgemapperHub", options =>
    { 
        options.AccessTokenProvider = () => Task.FromResult(_authenticateResponse.Token);
    })

                                        //     .WithUrl("http://hub.michelescandura.com:5000/SledgemapperHub")
                                        .Build();



            var httpClientHandler = new HttpClientHandler();

            //if (myConfigurationService.VerifySslCertificate == false)
            //{
            httpClientHandler.ServerCertificateCustomValidationCallback =
                (message, certificate, chain, sslPolicyErrors) => true;
            //}

            Api = RestService.For<IMapApi>(
              new HttpClient(httpClientHandler)
              {
                  BaseAddress = new Uri("http://localhost:5000")
              }
          );

            Connection.On<Session>("UpdateMap", (map) =>
            {
                SessionData.Map = map.Map;
                SessionData.Walls = map.Walls;
                SessionData.Overlays = map.Overlays;
            });

            Connection.On<Player>("PlayerUpdate", (player) =>
            {
                var p = SessionData.Players.FirstOrDefault(m => m.ConnectionId == player.ConnectionId);
                if (p != null)
                {
                    p.Position = player.Position;
                }
            });

            Connection.On<Tile>("DeleteTile", (tile) =>
            {
                SessionData.Map.Remove(tile.ToString(), out var _);
            });

            Connection.On<Wall>("DeleteWall", (tile) =>
           {
               SessionData.Walls.Remove(tile.ToString(), out var _);
           });

            Connection.On<Overlay>("DeleteOverlay", (tile) =>
           {
               SessionData.Overlays.Remove(tile.ToString(), out var _);
           });

            Connection.On<Tile>("NewTile", (tile) =>
          {
              SessionData.Map.Remove(tile.ToString(), out var _);
              SessionData.Map.TryAdd(tile.ToString(), tile);
          });

            Connection.On<Wall>("NewWall", (tile) =>
           {
               SessionData.Walls.Remove(tile.ToString(), out var _);
               SessionData.Walls.TryAdd(tile.ToString(), tile);
           });

            Connection.On<Overlay>("NewOverlay", (tile) =>
           {
               SessionData.Overlays.Remove(tile.ToString(), out var _);
               SessionData.Overlays.TryAdd(tile.ToString(), tile);
           });

            Connection.On<Player>("NewPlayer", (player) =>
           {
               var p = SessionData.Players.FirstOrDefault(m => m.ConnectionId == player.ConnectionId);
               if (p is null)
               {
                   SessionData.Players.Add(player);
               }
               else
               {
                   p.Color = player.Color;
                   p.Position = player.Position;
               }
           });
        }

        public async Task<bool> Register(RegisterModel registerModel)
        {
            var result = await Api.Register(registerModel);
            return result.IsSuccessStatusCode;
        }

        public async Task<AuthenticateResponse> Login(AuthenticateModel authenticateModel)
        {
            _authenticateResponse = await Api.Authenticate(authenticateModel);
            return _authenticateResponse;
        }

        private async Task Execute(Func<Task> call)
        {
            await Policy
                      .Handle<ApiException>(ex => ex.StatusCode == HttpStatusCode.RequestTimeout)
                      .RetryForeverAsync()
                      //.RetryAsync(Polly.RetrySyntax., async (exception, retryCount) => await Task.Delay(500))
                      .ExecuteAsync(async () => await call().ConfigureAwait(false))
                      .ConfigureAwait(false);
        }

        public void Enqueue(BaseMapEntity entity, TileAction action)
        {
            switch (action)
            {
                case TileAction.Add:
                    switch (entity)
                    {
                        case Tile tile:
                            Queue.Enqueue(async () => await Execute(async () => await Api.NewTile(tile, SessionData.SessionName)));
                            break;
                        case Overlay overlay:
                            Queue.Enqueue(async () => await Execute(async () => await Api.NewOverlay(overlay, SessionData.SessionName)));
                            break;
                        case Wall wall:
                            Queue.Enqueue(async () => await Execute(async () => await Api.NewWall(wall, SessionData.SessionName)));
                            break;
                    }
                    break;

                case TileAction.Delete:
                    switch (entity)
                    {
                        case Tile tile:
                            Queue.Enqueue(async () => await Execute(async () => await Api.DeleteTile(tile, SessionData.SessionName)));
                            break;
                        case Overlay overlay:
                            Queue.Enqueue(async () => await Execute(async () => await Api.DeleteOverlay(overlay, SessionData.SessionName)));
                            break;
                        case Wall wall:
                            Queue.Enqueue(async () => await Execute(async () => await Api.DeleteWall(wall, SessionData.SessionName)));
                            break;
                    }
                    break;
            }

        }
    }
}