refactoring

Sledgemapper.Api/Controllers/SessionController.cs

@@ -19,10 +19,34 @@ namespace Sledgemapper.Api.Controllers
             await _mediator.Publish(new NewTileNotification(sessionName, tile));
         }
 
-        [HttpPost("session")]
+        [HttpPost("overlay")]
         public async Task Post(string sessionName, [FromBody]Overlay overlay)
         {
             await _mediator.Publish(new NewOverlayNotification(sessionName, overlay));
         }
+
+         [HttpPost("wall")]
+        public async Task Post(string sessionName, [FromBody]Wall wall)
+        {
+            await _mediator.Publish(new NewWallNotification(sessionName, wall));
+        }
+
+         [HttpDelete("tile")]
+        public async Task Delete(string sessionName, [FromBody]Tile tile)
+        {
+            await _mediator.Publish(new DeleteTileNotification(sessionName, tile));
+        }
+
+        [HttpDelete("overlay")]
+        public async Task Delete(string sessionName, [FromBody]Overlay overlay)
+        {
+            await _mediator.Publish(new DeleteOverlayNotification(sessionName, overlay));
+        }
+
+         [HttpDelete("wall")]
+        public async Task Delete(string sessionName, [FromBody]Wall wall)
+        {
+            await _mediator.Publish(new DeleteWallNotification(sessionName, wall));
+        }
     }
 }

Sledgemapper.Api/Handlers/NewTileHandler.cs

@@ -1,117 +0,0 @@
-using MediatR;
-using Microsoft.AspNetCore.Http.Features;
-using Microsoft.AspNetCore.SignalR;
-using SignalRChat.Hubs;
-using Sledgemapper.Api.Data;
-using Sledgemapper.Clients;
-using Sledgemapper.Shared.Entities;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text.Json;
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace Sledgemapper.Api.Handlers
-{
-    public abstract class BaseNotification : INotification
-    {
-        public double Timestamp { get; private set; }
-        public string SessionName { get; private set; }
-
-        public BaseNotification(string sessionName)
-        {
-            Timestamp = DateTimeOffset.Now.ToUnixTimeMilliseconds();
-            SessionName = sessionName;
-        }
-    }
-
-    public class NewTileNotification : BaseNotification
-    {
-        public Tile Tile { get; private set; }
-
-        public NewTileNotification(string sessionName, Tile tile) : base(sessionName)
-        {
-            Tile = tile;
-        }
-    }
-
-    public class NewOverlayNotification : BaseNotification
-    {
-        public Overlay Overlay { get; private set; }
-
-        public NewOverlayNotification(string sessionName, Overlay overlay) : base(sessionName)
-        {
-            Overlay = overlay;
-        }
-    }
-
-    public class SendNewTileMessage : INotificationHandler<NewTileNotification>
-    {
-        private readonly IHubContext<SledgemapperHub, ISledgemapperClient> _hub;
-
-        public SendNewTileMessage(IHubContext<SledgemapperHub, ISledgemapperClient> hub) => _hub = hub;
-
-        public async Task Handle(NewTileNotification notification, CancellationToken cancellationToken)
-        {
-            await _hub.Clients.Groups(notification.SessionName).NewTile(notification.Tile);
-        }
-    }
-
-    public class SaveNewTile : INotificationHandler<NewTileNotification>
-    {
-        private readonly MyDbContext _dbcontext;
-
-        public SaveNewTile(MyDbContext dbcontext) => _dbcontext = dbcontext;
-
-        public async Task Handle(NewTileNotification notification, CancellationToken cancellationToken)
-        {
-            var jsonString = JsonSerializer.Serialize<Tile>(notification.Tile);
-
-            _dbcontext.MapLogs.Add(new Sledgemapper.Api.Models.MapLog
-            {
-                Operation = "N",
-                SessionName = notification.SessionName,
-                Type = "T",
-                Timestamp = notification.Timestamp,
-                Object = jsonString
-            });
-            await _dbcontext.SaveChangesAsync();
-        }
-    }
-
-    public class SendNewOverlayMessage : INotificationHandler<NewOverlayNotification>
-    {
-        private readonly IHubContext<SledgemapperHub, ISledgemapperClient> _hub;
-
-        public SendNewOverlayMessage(IHubContext<SledgemapperHub, ISledgemapperClient> hub) => _hub = hub;
-
-        public async Task Handle(NewOverlayNotification notification, CancellationToken cancellationToken)
-        {
-            await _hub.Clients.Groups(notification.SessionName).NewOverlay(notification.Overlay);
-        }
-    }
-
-    public class SaveNewOverlay : INotificationHandler<NewOverlayNotification>
-    {
-        private readonly MyDbContext _dbcontext;
-
-        public SaveNewOverlay(MyDbContext dbcontext) => _dbcontext = dbcontext;
-
-        public async Task Handle(NewOverlayNotification notification, CancellationToken cancellationToken)
-        {
-            var jsonString = JsonSerializer.Serialize<Overlay>(notification.Overlay);
-
-            _dbcontext.MapLogs.Add(new Sledgemapper.Api.Models.MapLog
-            {
-                Operation = "N",
-                SessionName = notification.SessionName,
-                Type = "O",
-                Timestamp = notification.Timestamp,
-                Object = jsonString
-            });
-            
-            await _dbcontext.SaveChangesAsync();
-        }
-    }
-}

Sledgemapper.Api/Handlers/SaveDeleteOverlay.cs

@@ -0,0 +1,32 @@
+using MediatR;
+using Sledgemapper.Api.Data;
+using Sledgemapper.Shared.Entities;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Sledgemapper.Api.Handlers
+{
+    public class SaveDeleteOverlay : INotificationHandler<DeleteOverlayNotification>
+    {
+        private readonly MyDbContext _dbcontext;
+
+        public SaveDeleteOverlay(MyDbContext dbcontext) => _dbcontext = dbcontext;
+
+        public async Task Handle(DeleteOverlayNotification notification, CancellationToken cancellationToken)
+        {
+            var jsonString = JsonSerializer.Serialize<Overlay>(notification.Overlay);
+
+            _dbcontext.MapLogs.Add(new Sledgemapper.Api.Models.MapLog
+            {
+                Operation = "D",
+                SessionName = notification.SessionName,
+                Type = "O",
+                Timestamp = notification.Timestamp,
+                Object = jsonString
+            });
+
+            await _dbcontext.SaveChangesAsync();
+        }
+    }
+}

Sledgemapper.Api/Handlers/SaveDeleteTile.cs

@@ -0,0 +1,31 @@
+using MediatR;
+using Sledgemapper.Api.Data;
+using Sledgemapper.Shared.Entities;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Sledgemapper.Api.Handlers
+{
+    public class SaveDeleteTile : INotificationHandler<DeleteTileNotification>
+    {
+        private readonly MyDbContext _dbcontext;
+
+        public SaveDeleteTile(MyDbContext dbcontext) => _dbcontext = dbcontext;
+
+        public async Task Handle(DeleteTileNotification notification, CancellationToken cancellationToken)
+        {
+            var jsonString = JsonSerializer.Serialize<Tile>(notification.Tile);
+
+            _dbcontext.MapLogs.Add(new Sledgemapper.Api.Models.MapLog
+            {
+                Operation = "D",
+                SessionName = notification.SessionName,
+                Type = "T",
+                Timestamp = notification.Timestamp,
+                Object = jsonString
+            });
+            await _dbcontext.SaveChangesAsync();
+        }
+    }
+}

Sledgemapper.Api/Handlers/SaveDeleteWall.cs

@@ -0,0 +1,35 @@
+using MediatR;
+using Microsoft.AspNetCore.Http.Features;
+using Sledgemapper.Api.Data;
+using Sledgemapper.Shared.Entities;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Sledgemapper.Api.Handlers
+{
+
+    public class SaveDeleteWall : INotificationHandler<DeleteWallNotification>
+    {
+        private readonly MyDbContext _dbcontext;
+
+        public SaveDeleteWall(MyDbContext dbcontext) => _dbcontext = dbcontext;
+
+        public async Task Handle(DeleteWallNotification notification, CancellationToken cancellationToken)
+        {
+            var jsonString = JsonSerializer.Serialize<Wall>(notification.Wall);
+
+            _dbcontext.MapLogs.Add(new Sledgemapper.Api.Models.MapLog
+            {
+                Operation = "D",
+                SessionName = notification.SessionName,
+                Type = "W",
+                Timestamp = notification.Timestamp,
+                Object = jsonString
+            });
+            await _dbcontext.SaveChangesAsync();
+        }
+    }
+}

Sledgemapper.Api/Handlers/SaveNewOverlay.cs

@@ -0,0 +1,32 @@
+using MediatR;
+using Sledgemapper.Api.Data;
+using Sledgemapper.Shared.Entities;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Sledgemapper.Api.Handlers
+{
+    public class SaveNewOverlay : INotificationHandler<NewOverlayNotification>
+    {
+        private readonly MyDbContext _dbcontext;
+
+        public SaveNewOverlay(MyDbContext dbcontext) => _dbcontext = dbcontext;
+
+        public async Task Handle(NewOverlayNotification notification, CancellationToken cancellationToken)
+        {
+            var jsonString = JsonSerializer.Serialize<Overlay>(notification.Overlay);
+
+            _dbcontext.MapLogs.Add(new Sledgemapper.Api.Models.MapLog
+            {
+                Operation = "N",
+                SessionName = notification.SessionName,
+                Type = "O",
+                Timestamp = notification.Timestamp,
+                Object = jsonString
+            });
+
+            await _dbcontext.SaveChangesAsync();
+        }
+    }
+}

Sledgemapper.Api/Handlers/SaveNewTile.cs

@@ -0,0 +1,31 @@
+using MediatR;
+using Sledgemapper.Api.Data;
+using Sledgemapper.Shared.Entities;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Sledgemapper.Api.Handlers
+{
+    public class SaveNewTile : INotificationHandler<NewTileNotification>
+    {
+        private readonly MyDbContext _dbcontext;
+
+        public SaveNewTile(MyDbContext dbcontext) => _dbcontext = dbcontext;
+
+        public async Task Handle(NewTileNotification notification, CancellationToken cancellationToken)
+        {
+            var jsonString = JsonSerializer.Serialize<Tile>(notification.Tile);
+
+            _dbcontext.MapLogs.Add(new Sledgemapper.Api.Models.MapLog
+            {
+                Operation = "N",
+                SessionName = notification.SessionName,
+                Type = "T",
+                Timestamp = notification.Timestamp,
+                Object = jsonString
+            });
+            await _dbcontext.SaveChangesAsync();
+        }
+    }
+}

Sledgemapper.Api/Handlers/SaveNewWall.cs

@@ -0,0 +1,31 @@
+using MediatR;
+using Sledgemapper.Api.Data;
+using Sledgemapper.Shared.Entities;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Sledgemapper.Api.Handlers
+{
+    public class SaveNewWall : INotificationHandler<NewWallNotification>
+    {
+        private readonly MyDbContext _dbcontext;
+
+        public SaveNewWall(MyDbContext dbcontext) => _dbcontext = dbcontext;
+
+        public async Task Handle(NewWallNotification notification, CancellationToken cancellationToken)
+        {
+            var jsonString = JsonSerializer.Serialize<Wall>(notification.Wall);
+
+            _dbcontext.MapLogs.Add(new Sledgemapper.Api.Models.MapLog
+            {
+                Operation = "N",
+                SessionName = notification.SessionName,
+                Type = "W",
+                Timestamp = notification.Timestamp,
+                Object = jsonString
+            });
+            await _dbcontext.SaveChangesAsync();
+        }
+    }
+}

Sledgemapper.Api/Handlers/SendDeleteOverlayMessage.cs

@@ -0,0 +1,21 @@
+using MediatR;
+using Microsoft.AspNetCore.SignalR;
+using SignalRChat.Hubs;
+using Sledgemapper.Clients;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Sledgemapper.Api.Handlers
+{
+    public class SendDeleteOverlayMessage : INotificationHandler<DeleteOverlayNotification>
+    {
+        private readonly IHubContext<SledgemapperHub, ISledgemapperClient> _hub;
+
+        public SendDeleteOverlayMessage(IHubContext<SledgemapperHub, ISledgemapperClient> hub) => _hub = hub;
+
+        public async Task Handle(DeleteOverlayNotification notification, CancellationToken cancellationToken)
+        {
+            await _hub.Clients.Groups(notification.SessionName).DeleteOverlay(notification.Overlay);
+        }
+    }
+}

Sledgemapper.Api/Handlers/SendDeleteTileMessage.cs

@@ -0,0 +1,21 @@
+using MediatR;
+using Microsoft.AspNetCore.SignalR;
+using SignalRChat.Hubs;
+using Sledgemapper.Clients;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Sledgemapper.Api.Handlers
+{
+    public class SendDeleteTileMessage : INotificationHandler<DeleteTileNotification>
+    {
+        private readonly IHubContext<SledgemapperHub, ISledgemapperClient> _hub;
+
+        public SendDeleteTileMessage(IHubContext<SledgemapperHub, ISledgemapperClient> hub) => _hub = hub;
+
+        public async Task Handle(DeleteTileNotification notification, CancellationToken cancellationToken)
+        {
+            await _hub.Clients.Groups(notification.SessionName).DeleteTile(notification.Tile);
+        }
+    }
+}

Sledgemapper.Api/Handlers/SendDeleteWallMessage.cs

@@ -0,0 +1,21 @@
+using MediatR;
+using Microsoft.AspNetCore.SignalR;
+using SignalRChat.Hubs;
+using Sledgemapper.Clients;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Sledgemapper.Api.Handlers
+{
+    public class SendDeleteWallMessage : INotificationHandler<DeleteWallNotification>
+    {
+        private readonly IHubContext<SledgemapperHub, ISledgemapperClient> _hub;
+
+        public SendDeleteWallMessage(IHubContext<SledgemapperHub, ISledgemapperClient> hub) => _hub = hub;
+
+        public async Task Handle(DeleteWallNotification notification, CancellationToken cancellationToken)
+        {
+            await _hub.Clients.Groups(notification.SessionName).DeleteWall(notification.Wall);
+        }
+    }
+}

Sledgemapper.Api/Handlers/SendNewOverlayMessage.cs

@@ -0,0 +1,21 @@
+using MediatR;
+using Microsoft.AspNetCore.SignalR;
+using SignalRChat.Hubs;
+using Sledgemapper.Clients;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Sledgemapper.Api.Handlers
+{
+    public class SendNewOverlayMessage : INotificationHandler<NewOverlayNotification>
+    {
+        private readonly IHubContext<SledgemapperHub, ISledgemapperClient> _hub;
+
+        public SendNewOverlayMessage(IHubContext<SledgemapperHub, ISledgemapperClient> hub) => _hub = hub;
+
+        public async Task Handle(NewOverlayNotification notification, CancellationToken cancellationToken)
+        {
+            await _hub.Clients.Groups(notification.SessionName).NewOverlay(notification.Overlay);
+        }
+    }
+}

Sledgemapper.Api/Handlers/SendNewTileMessage.cs

@@ -0,0 +1,21 @@
+using MediatR;
+using Microsoft.AspNetCore.SignalR;
+using SignalRChat.Hubs;
+using Sledgemapper.Clients;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Sledgemapper.Api.Handlers
+{
+    public class SendNewTileMessage : INotificationHandler<NewTileNotification>
+    {
+        private readonly IHubContext<SledgemapperHub, ISledgemapperClient> _hub;
+
+        public SendNewTileMessage(IHubContext<SledgemapperHub, ISledgemapperClient> hub) => _hub = hub;
+
+        public async Task Handle(NewTileNotification notification, CancellationToken cancellationToken)
+        {
+            await _hub.Clients.Groups(notification.SessionName).NewTile(notification.Tile);
+        }
+    }
+}

Sledgemapper.Api/Handlers/SendNewWallMessage.cs

@@ -0,0 +1,21 @@
+using MediatR;
+using Microsoft.AspNetCore.SignalR;
+using SignalRChat.Hubs;
+using Sledgemapper.Clients;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Sledgemapper.Api.Handlers
+{
+    public class SendNewWallMessage : INotificationHandler<NewWallNotification>
+    {
+        private readonly IHubContext<SledgemapperHub, ISledgemapperClient> _hub;
+
+        public SendNewWallMessage(IHubContext<SledgemapperHub, ISledgemapperClient> hub) => _hub = hub;
+
+        public async Task Handle(NewWallNotification notification, CancellationToken cancellationToken)
+        {
+            await _hub.Clients.Groups(notification.SessionName).NewWall(notification.Wall);
+        }
+    }
+}

Sledgemapper.Api/Hubs/SledgemapperHub.cs

@@ -19,7 +19,7 @@ namespace SignalRChat.Hubs
         private readonly MyDbContext _dbcontext;
 
         // public SledgemapperHub(IMediator mediator) => _mediator = mediator;
-        public SledgemapperHub(MyDbContext dbcontext, IMediator mediator) { _dbcontext = dbcontext; _mediator=mediator;}
+        public SledgemapperHub(MyDbContext dbcontext, IMediator mediator) { _dbcontext = dbcontext; _mediator = mediator; }
         private static Dictionary<string, SessionData> _sessions = new Dictionary<string, SessionData>();
         public List<string> Colors = new List<string>{"CC0000",
             "CC3300",
@@ -45,10 +45,15 @@ namespace SignalRChat.Hubs
 
             var jsonString = JsonSerializer.Serialize<Tile>(tile);
 
-_dbcontext.MapLogs.Add(new Sledgemapper.Api.Models.MapLog{
-    Operation="N", SessionName=sessionName, Type="T", Timestamp=timestamp, Object=jsonString
-});
-await _dbcontext.SaveChangesAsync();
+            _dbcontext.MapLogs.Add(new Sledgemapper.Api.Models.MapLog
+            {
+                Operation = "N",
+                SessionName = sessionName,
+                Type = "T",
+                Timestamp = timestamp,
+                Object = jsonString
+            });
+            await _dbcontext.SaveChangesAsync();
 
             await Clients.Group(sessionName).NewTile(tile);
         }
@@ -73,12 +78,17 @@ await _dbcontext.SaveChangesAsync();
                 _sessions[sessionName].Overlays.TryRemove(t.ToString(), out var rtile);
             }
             _sessions[sessionName].Overlays.TryAdd(tile.ToString(), tile);
-   var jsonString = JsonSerializer.Serialize<Overlay>(tile);
+            var jsonString = JsonSerializer.Serialize<Overlay>(tile);
 
-_dbcontext.MapLogs.Add(new Sledgemapper.Api.Models.MapLog{
-    Operation="N", SessionName=sessionName, Type="O", Timestamp=timestamp, Object=jsonString
-});
-await _dbcontext.SaveChangesAsync();
+            _dbcontext.MapLogs.Add(new Sledgemapper.Api.Models.MapLog
+            {
+                Operation = "N",
+                SessionName = sessionName,
+                Type = "O",
+                Timestamp = timestamp,
+                Object = jsonString
+            });
+            await _dbcontext.SaveChangesAsync();
             await Clients.Group(sessionName).NewOverlay(tile);
         }
 

Sledgemapper.Api/Notifications/BaseNotification.cs

@@ -0,0 +1,17 @@
+using MediatR;
+using System;
+
+namespace Sledgemapper.Api.Handlers
+{
+    public abstract class BaseNotification : INotification
+    {
+        public double Timestamp { get; private set; }
+        public string SessionName { get; private set; }
+
+        public BaseNotification(string sessionName)
+        {
+            Timestamp = DateTimeOffset.Now.ToUnixTimeMilliseconds();
+            SessionName = sessionName;
+        }
+    }
+}

Sledgemapper.Api/Notifications/DeleteOverlayNotification.cs

@@ -0,0 +1,14 @@
+using Sledgemapper.Shared.Entities;
+
+namespace Sledgemapper.Api.Handlers
+{
+    public class DeleteOverlayNotification : BaseNotification
+    {
+        public Overlay Overlay { get; private set; }
+
+        public DeleteOverlayNotification(string sessionName, Overlay overlay) : base(sessionName)
+        {
+            Overlay = overlay;
+        }
+    }
+}

Sledgemapper.Api/Notifications/DeleteTileNotification.cs

@@ -0,0 +1,14 @@
+using Sledgemapper.Shared.Entities;
+
+namespace Sledgemapper.Api.Handlers
+{
+    public class DeleteTileNotification : BaseNotification
+    {
+        public Tile Tile { get; private set; }
+
+        public DeleteTileNotification(string sessionName, Tile tile) : base(sessionName)
+        {
+            Tile = tile;
+        }
+    }
+}

Sledgemapper.Api/Notifications/DeleteWallNotification.cs

@@ -0,0 +1,14 @@
+using Sledgemapper.Shared.Entities;
+
+namespace Sledgemapper.Api.Handlers
+{
+    public class DeleteWallNotification : BaseNotification
+    {
+        public Wall Wall { get; private set; }
+
+        public DeleteWallNotification(string sessionName, Wall wall) : base(sessionName)
+        {
+            Wall = wall;
+        }
+    }
+}

Sledgemapper.Api/Notifications/NewOverlayNotification.cs

@@ -0,0 +1,14 @@
+using Sledgemapper.Shared.Entities;
+
+namespace Sledgemapper.Api.Handlers
+{
+    public class NewOverlayNotification : BaseNotification
+    {
+        public Overlay Overlay { get; private set; }
+
+        public NewOverlayNotification(string sessionName, Overlay overlay) : base(sessionName)
+        {
+            Overlay = overlay;
+        }
+    }
+}

Sledgemapper.Api/Notifications/NewTileNotification.cs

@@ -0,0 +1,14 @@
+using Sledgemapper.Shared.Entities;
+
+namespace Sledgemapper.Api.Handlers
+{
+    public class NewTileNotification : BaseNotification
+    {
+        public Tile Tile { get; private set; }
+
+        public NewTileNotification(string sessionName, Tile tile) : base(sessionName)
+        {
+            Tile = tile;
+        }
+    }
+}

Sledgemapper.Api/Notifications/NewWallNotification.cs

@@ -0,0 +1,14 @@
+using Sledgemapper.Shared.Entities;
+
+namespace Sledgemapper.Api.Handlers
+{
+    public class NewWallNotification : BaseNotification
+    {
+        public Wall Wall { get; private set; }
+
+        public NewWallNotification(string sessionName, Wall wall) : base(sessionName)
+        {
+            Wall = wall;
+        }
+    }
+}

Sledgemapper.Shared/Entities/SessionData.cs

@@ -10,16 +10,44 @@ namespace Sledgemapper.Shared.Entities
         public TileAddedEventArgs(Tile tile) => Tile = tile;
     }
 
-     public class OverlayAddedEventArgs : EventArgs
+    public class OverlayAddedEventArgs : EventArgs
     {
         public Overlay Overlay { get; set; }
         public OverlayAddedEventArgs(Overlay overlay) => Overlay = overlay;
     }
 
+    public class WallAddedEventArgs : EventArgs
+    {
+        public Wall Wall { get; set; }
+        public WallAddedEventArgs(Wall wall) => Wall = wall;
+    }
+
+    public class WallDeletedEventArgs : EventArgs
+    {
+        public Wall Wall { get; set; }
+        public WallDeletedEventArgs(Wall wall) => Wall = wall;
+    }
+
+    public class OverlayDeletedEventArgs : EventArgs
+    {
+        public Overlay Overlay { get; set; }
+        public OverlayDeletedEventArgs(Overlay overlay) => Overlay = overlay;
+    }
+
+    public class TileDeletedEventArgs : EventArgs
+    {
+        public Tile Tile { get; set; }
+        public TileDeletedEventArgs(Tile tile) => Tile = tile;
+    }
+
     public class SessionData
     {
-        public event EventHandler<TileAddedEventArgs> RaiseTileAddedEvent;
-        public event EventHandler<OverlayAddedEventArgs> RaiseOverlayAddedEvent;
+        public event EventHandler<TileAddedEventArgs> TileAdded;
+        public event EventHandler<OverlayAddedEventArgs> OverlayAdded;
+        public event EventHandler<WallAddedEventArgs> WallAdded;
+        public event EventHandler<WallDeletedEventArgs> WallDeleted;
+        public event EventHandler<OverlayDeletedEventArgs> OverlayDeleted;
+        public event EventHandler<TileDeletedEventArgs> TileDeleted;
 
         public SessionData()
         {
@@ -39,82 +67,151 @@ namespace Sledgemapper.Shared.Entities
 
         public void NewTile(Tile selectedTile, string tileId)
         {
+            if (selectedTile is null || string.IsNullOrWhiteSpace(tileId))
+            {
+                return;
+            }
+
             var tileExist = Map.TryGetValue(selectedTile.ToString(), out var tile);
-            Tile newTile;
+            var newTile = new Tile { X = selectedTile.X, Y = selectedTile.Y, ID = tileId };
             if (tileExist)
             {
                 Map.TryRemove(tile.ToString(), out var _);
                 if (tile.ID == tileId)
                 {
-                    newTile = new Tile { X = selectedTile.X, Y = selectedTile.Y, ID = tileId, Rotation = (tile.Rotation + 1) % 4 };
+                    newTile.Rotation = (tile.Rotation + 1) % 4;
                 }
-                else
-                {
-                    newTile = new Tile { X = selectedTile.X, Y = selectedTile.Y, ID = tileId };
-                }
-            }
-            else
-            {
-                newTile = new Tile { X = selectedTile.X, Y = selectedTile.Y, ID = tileId };
             }
 
             Map.TryAdd(newTile.ToString(), newTile);
-
             OnRaiseTileAddedEvent(new TileAddedEventArgs(newTile));
         }
 
-        public void NewOverlay(Overlay selectedOverlay, string tileId)
+        public void NewOverlay(Overlay selectedOverlay, string overlayId)
         {
+            if (selectedOverlay is null || string.IsNullOrWhiteSpace(overlayId))
+            {
+                return;
+            }
             var overlayExist = Overlays.TryGetValue(selectedOverlay.ToString(), out var overlay);
-            Overlay newOverlay;
+            var newOverlay = new Overlay { X = selectedOverlay.X, Y = selectedOverlay.Y, ID = overlayId, Intersection = selectedOverlay.Intersection }; ;
             if (overlayExist)
             {
                 Overlays.TryRemove(overlay.ToString(), out var rrtile);
-                if (overlay.ID == tileId)
+                if (overlay.ID == overlayId)
                 {
-                    newOverlay = new Overlay { X = overlay.X, Y = overlay.Y, ID = tileId, Intersection = overlay.Intersection, Rotation = (overlay.Rotation + 1) % 4 };
+                    newOverlay.Rotation = (overlay.Rotation + 1) % 4;
                 }
-                else
-                {
-                    newOverlay = new Overlay { X = selectedOverlay.X, Y = selectedOverlay.Y, ID = tileId, Intersection = selectedOverlay.Intersection };
-                }
-            }
-            else
-            {
-                newOverlay = new Overlay { X = selectedOverlay.X, Y = selectedOverlay.Y, ID = tileId, Intersection = selectedOverlay.Intersection };
             }
 
             Overlays.TryAdd(newOverlay.ToString(), newOverlay);
             OnRaiseOverlayAddedEvent(new OverlayAddedEventArgs(newOverlay));
+        }
 
+        public void NewWall(Wall selectedWall, string wallId)
+        {
+            if (selectedWall is null || string.IsNullOrWhiteSpace(wallId))
+            {
+                return;
+            }
+            var tileExist = Walls.TryGetValue(selectedWall.ToString(), out var wall);
+            var newWall = new Wall { X = selectedWall.X, Y = selectedWall.Y, ID = wallId, Rotation = selectedWall.Rotation };
+            if (tileExist)
+            {
+                Walls.TryRemove(wall.ToString(), out var _);
+            }
+
+            Walls.TryAdd(newWall.ToString(), newWall);
+            OnRaiseWallAddedEvent(new WallAddedEventArgs(newWall));
+        }
+
+        public void DeleteWall(Wall wall)
+        {
+            if (wall is null)
+            {
+                return;
+            }
+            var removed = Walls.TryRemove(wall.ToString(), out var _);
+            if (removed)
+            {
+                OnRaiseWallDeletedEvent(new WallDeletedEventArgs(wall));
+            }
+        }
+
+        public void DeleteOverlay(Overlay overlay)
+        {
+              if (overlay is null)
+            {
+                return;
+            }
+            var removed = Overlays.TryRemove(overlay.ToString(), out var _);
+            if (removed)
+            {
+                OnRaiseOverlayDeletedEvent(new OverlayDeletedEventArgs(overlay));
+            }
+        }
+
+        public void DeleteTile(Tile tile)
+        {
+              if (tile is null)
+            {
+                return;
+            }
+            var removed = Map.TryRemove(tile.ToString(), out var _);
+            if (removed)
+            {
+                OnRaiseTileDeletedEvent(new TileDeletedEventArgs(tile));
+            }
         }
 
         protected virtual void OnRaiseTileAddedEvent(TileAddedEventArgs e)
         {
-            // Make a temporary copy of the event to avoid possibility of
-            // a race condition if the last subscriber unsubscribes
-            // immediately after the null check and before the event is raised.
-            EventHandler<TileAddedEventArgs> raiseEvent = RaiseTileAddedEvent;
-
-            // Event will be null if there are no subscribers
+            var raiseEvent = TileAdded;
             if (raiseEvent != null)
             {
-                // Call to raise the event.
                 raiseEvent(this, e);
             }
         }
 
         protected virtual void OnRaiseOverlayAddedEvent(OverlayAddedEventArgs e)
         {
-            // Make a temporary copy of the event to avoid possibility of
-            // a race condition if the last subscriber unsubscribes
-            // immediately after the null check and before the event is raised.
-            EventHandler<OverlayAddedEventArgs> raiseEvent = RaiseOverlayAddedEvent;
-
-            // Event will be null if there are no subscribers
+            var raiseEvent = OverlayAdded;
+            if (raiseEvent != null)
+            {
+                raiseEvent(this, e);
+            }
+        }
+
+        protected virtual void OnRaiseWallAddedEvent(WallAddedEventArgs e)
+        {
+            var raiseEvent = WallAdded
+            ;
+            if (raiseEvent != null)
+            {
+                raiseEvent(this, e);
+            }
+        }
+        protected virtual void OnRaiseWallDeletedEvent(WallDeletedEventArgs e)
+        {
+            var raiseEvent = WallDeleted;
+            if (raiseEvent != null)
+            {
+                raiseEvent(this, e);
+            }
+        }
+        protected virtual void OnRaiseOverlayDeletedEvent(OverlayDeletedEventArgs e)
+        {
+            var raiseEvent = OverlayDeleted;
+            if (raiseEvent != null)
+            {
+                raiseEvent(this, e);
+            }
+        }
+        protected virtual void OnRaiseTileDeletedEvent(TileDeletedEventArgs e)
+        {
+            var raiseEvent = TileDeleted;
             if (raiseEvent != null)
             {
-                // Call to raise the event.
                 raiseEvent(this, e);
             }
         }

Sledgemapper/IMapApi.cs

@@ -15,5 +15,17 @@ namespace Sledgemapper
 
         [Post("/session/{sessionName}/overlay")]
         Task NewOverlay([Body] Overlay overlay, string sessionName);
+
+        [Post("/session/{sessionName}/wall")]
+        Task NewWall([Body] Wall overlay, string sessionName);
+
+        [Delete("/session/{sessionName}/wall")]
+        Task DeleteWall([Body] Wall wall, string sessionName);
+
+        [Delete("/session/{sessionName}/tile")]
+        Task DeleteTile([Body] Tile tile, string sessionName);
+
+        [Delete("/session/{sessionName}/overlay")]
+        Task DeleteOverlay([Body] Overlay overlay, string sessionName);
     }
-}
+}

Sledgemapper/Sledgemapper.cs

@@ -37,7 +37,6 @@ namespace Sledgemapper
         private string _session;
         private KeyboardState oldState;
         private MouseState oldMouseState;
-
         private Vector3 _viewportCenter = new Vector3(0, 0, 0);
         private SpriteFont font;
         private Dictionary<string, SpriteFont> _fonts;
@@ -61,7 +60,7 @@ namespace Sledgemapper
             Window.AllowUserResizing = true;
             Players = new List<Player>();
             connection = new HubConnectionBuilder()
-                                // .WithAutomaticReconnect()
+                                .WithAutomaticReconnect()
 
                                 .WithUrl("http://localhost:5000/SledgemapperHub")
 
@@ -72,25 +71,22 @@ namespace Sledgemapper
 
             //if (myConfigurationService.VerifySslCertificate == false)
             //{
-                httpClientHandler.ServerCertificateCustomValidationCallback =
-                    (message, certificate, chain, sslPolicyErrors) => true;
+            httpClientHandler.ServerCertificateCustomValidationCallback =
+                (message, certificate, chain, sslPolicyErrors) => true;
             //}
 
-              _api = RestService.For<IMapApi>(
-                new HttpClient(httpClientHandler)
-                {
-                    BaseAddress = new Uri  ("http://localhost:5000")
-                }
-            );
-
-          
+            _api = RestService.For<IMapApi>(
+              new HttpClient(httpClientHandler)
+              {
+                  BaseAddress = new Uri("http://localhost:5000")
+              }
+          );
 
             connection.On<SessionData>("UpdateMap", (map) =>
             {
                 _sessionData.Map = map.Map;
                 _sessionData.Walls = map.Walls;
                 _sessionData.Overlays = map.Overlays;
-
             });
 
             connection.On<Player>("PlayerUpdate", (player) =>
@@ -104,38 +100,37 @@ namespace Sledgemapper
 
             connection.On<Tile>("DeleteTile", (tile) =>
             {
-                _sessionData.Map.Remove(tile.ToString(), out var rtile);
+                _sessionData.Map.Remove(tile.ToString(), out var _);
             });
 
             connection.On<Wall>("DeleteWall", (tile) =>
            {
-               _sessionData.Walls.Remove(tile.ToString(), out var rtile);
+               _sessionData.Walls.Remove(tile.ToString(), out var _);
            });
 
             connection.On<Overlay>("DeleteOverlay", (tile) =>
            {
-               _sessionData.Overlays.Remove(tile.ToString(), out var rtile);
+               _sessionData.Overlays.Remove(tile.ToString(), out var _);
            });
 
             connection.On<Tile>("NewTile", (tile) =>
           {
-              _sessionData.Map.Remove(tile.ToString(), out var rtile);
+              _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 rtile);
+               _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 rtile);
+               _sessionData.Overlays.Remove(tile.ToString(), out var _);
                _sessionData.Overlays.TryAdd(tile.ToString(), tile);
            });
 
-
             connection.On<Player>("NewPlayer", (player) =>
            {
                var p = Players.FirstOrDefault(m => m.ConnectionId == player.ConnectionId);
@@ -166,229 +161,11 @@ namespace Sledgemapper
             var menuConnectJoin = new MenuItem("_connect_join", "Join");
             var menuConnectSync = new MenuItem("_connect_sync", "Sync");
 
-            menuConnectSync.Selected += async (s, e) =>
-            {
-                await connection?.InvokeAsync("Sync", _session, _sessionData);
-            };
-
-            menuFileLoad.Selected += (s, e) =>
-            {
-                FileDialog dialog = new FileDialog(FileDialogMode.OpenFile)
-                {
-                    Filter = "*.map"
-                    //Folder = @"D:\Temp"
-                };
-
-                dialog.Closed += (s, a) =>
-                {
-                    if (!dialog.Result)
-                    {
-                        // "Cancel" or Escape
-                        return;
-                    }
-                    using (StreamReader file = File.OpenText(dialog.FilePath))
-                    {
-                        JsonSerializer serializer = new JsonSerializer();
-                        _sessionData = (SessionData)serializer.Deserialize(file, typeof(SessionData));
-                    }
-                    // "Ok" or Enter
-                    // ...
-                };
-
-                dialog.ShowModal(_desktop);
-            };
-
-            menuFileSave.Selected += (s, e) =>
-            {
-                FileDialog dialog = new FileDialog(FileDialogMode.SaveFile)
-                {
-                    Filter = "*.map"
-                    //Folder = @"D:\Temp"
-                };
-
-                dialog.Closed += (s, a) =>
-                {
-                    if (!dialog.Result)
-                    {
-                        // "Cancel" or Escape
-                        return;
-                    }
-
-                    using (StreamWriter file = File.CreateText(dialog.FilePath))
-                    {
-                        JsonSerializer serializer = new JsonSerializer();
-                        serializer.Serialize(file, _sessionData);
-                    }
-                    // "Ok" or Enter
-                    // ...
-                };
-
-                dialog.ShowModal(_desktop);
-            };
-
-            menuConnectNew.Selected += (s, e) =>
-            {
-                Window window = new Window
-                {
-                    Title = "New mapping session"
-                };
-                var content = new VerticalStackPanel();
-                var grid = new Grid
-                {
-                    Width = 200,
-                    ShowGridLines = false,
-                    ColumnSpacing = 8,
-                    RowSpacing = 3,
-                };
-
-                // Set partitioning configuration
-                grid.ColumnsProportions.Add(new Proportion(ProportionType.Auto));
-                grid.ColumnsProportions.Add(new Proportion(ProportionType.Fill));
-                grid.RowsProportions.Add(new Proportion(ProportionType.Auto));
-                grid.RowsProportions.Add(new Proportion(ProportionType.Auto));
-                var sessionNameLabel = new Label { Text = "Session Name:" };
-                var initialsLabel = new Label { Text = "Initials:", GridRow = 1 };
-                var textbox = new TextBox { GridColumn = 1 };
-                var initialsTextbox = new TextBox { GridColumn = 1, GridRow = 1 };
-                TextButton button = new TextButton
-                {
-                    Text = "Start",
-                    HorizontalAlignment = HorizontalAlignment.Center
-                };
-                grid.Widgets.Add(textbox);
-                grid.Widgets.Add(initialsTextbox);
-                grid.Widgets.Add(sessionNameLabel);
-                grid.Widgets.Add(initialsLabel);
-
-                content.Widgets.Add(grid);
-
-                button.Click += async (s, e) =>
-                {
-                    if (string.IsNullOrWhiteSpace(textbox.Text))
-                    {
-                        return;
-                    }
-                    if (connection.State != HubConnectionState.Connected)
-                    { await connection.StartAsync(); }
-                    var successful = false;
-                    try
-                    {
-                        var session = await connection?.InvokeAsync<SessionData>("NewSession", textbox.Text, initialsTextbox.Text);
-                        if (session != null)
-                        {
-                            session.RaiseTileAddedEvent += TileAddedEvent;
-                            session.RaiseOverlayAddedEvent += OverlayAddedEvent;
-                            Players = session.Players;
-
-                        }
-                        successful = session != null;
-                    }
-                    catch (Exception ex)
-
-                    {
-
-                    }
-                    if (successful)
-                    {
-                        _session = textbox.Text;
-                        window.Close();
-                    }
-                };
-
-
-                content.Widgets.Add(button);
-                window.Content = content;
-
-                window.Closed += (s, a) =>
-                {
-                        // Called when window is closed
-                    };
-
-                window.ShowModal(_desktop);
-            };
-
-            menuConnectJoin.Selected += (s, e) =>
-                        {
-                            Window window = new Window
-                            {
-                                Title = "Join mapping session"
-                            };
-                            var content = new VerticalStackPanel();
-                            var grid = new Grid
-                            {
-                                Width = 200,
-                                ShowGridLines = false,
-                                ColumnSpacing = 8,
-                                RowSpacing = 3,
-                            };
-
-                                // Set partitioning configuration
-                                grid.ColumnsProportions.Add(new Proportion(ProportionType.Auto));
-                            grid.ColumnsProportions.Add(new Proportion(ProportionType.Fill));
-                            grid.RowsProportions.Add(new Proportion(ProportionType.Auto));
-                            grid.RowsProportions.Add(new Proportion(ProportionType.Auto));
-                            var sessionNameLabel = new Label { Text = "Session Name:" };
-                            var initialsLabel = new Label { Text = "Initials:", GridRow = 1 };
-                            var textbox = new TextBox { GridColumn = 1 };
-                            var initialsTextbox = new TextBox { GridColumn = 1, GridRow = 1 };
-                            TextButton button = new TextButton
-                            {
-                                Text = "Start",
-                                HorizontalAlignment = HorizontalAlignment.Center
-                            };
-                            grid.Widgets.Add(textbox);
-                            grid.Widgets.Add(initialsTextbox);
-                            grid.Widgets.Add(sessionNameLabel);
-                            grid.Widgets.Add(initialsLabel);
-
-                            content.Widgets.Add(grid);
-
-                                // var content = new VerticalStackPanel();
-                                // var textbox = new TextBox();
-                                // TextButton button = new TextButton
-                                // {
-                                //     Text = "Start",
-                                //     HorizontalAlignment = HorizontalAlignment.Center
-                                // };
-                                button.Click += async (s, e) =>
-                         {
-                     if (string.IsNullOrWhiteSpace(textbox.Text))
-                     {
-                         return;
-                     }
-                     if (connection.State != HubConnectionState.Connected)
-                     { await connection.StartAsync(); }
-                     var successful = false;
-                     try
-                     {
-                         var result = await connection?.InvokeAsync<SessionData>("JoinSession", textbox.Text, initialsTextbox.Text);
-                         if (result != null)
-                         {
-                             _sessionData.Map = result.Map;
-                             _sessionData.Walls = result.Walls;
-                             _sessionData.Overlays = result.Overlays;
-                             Players = result.Players;
-                         }
-                         successful = result != null; ;
-                     }
-                     catch { }
-                     if (successful)
-                     {
-                         _session = textbox.Text;
-                         window.Close();
-                     }
-                 };
-                                //content.Widgets.Add(textbox);
-                                content.Widgets.Add(button);
-                            window.Content = content;
-
-                            window.Closed += (s, a) =>
-                            {
-                                    // Called when window is closed
-                                };
-
-                            window.ShowModal(_desktop);
-                        };
+            menuConnectSync.Selected += OnMenuConnectSyncSelected;
+            menuFileLoad.Selected += OnMenuFileLoadSelected;
+            menuFileSave.Selected += OnMenuFileSaveSelected;
+            menuConnectNew.Selected += OnMenuConnectNewSelected;
+            menuConnectJoin.Selected += OnMenuConnectJoinSelected;
 
             menuConnect.Items.Add(menuConnectNew);
             menuConnect.Items.Add(menuConnectJoin);
@@ -402,7 +179,214 @@ namespace Sledgemapper
             return menu;
         }
 
+        private void OnMenuConnectJoinSelected(object sender, EventArgs e)
+        {
+            Window window = new Window
+            {
+                Title = "Join mapping session"
+            };
+            var content = new VerticalStackPanel();
+            var grid = new Grid
+            {
+                Width = 200,
+                ShowGridLines = false,
+                ColumnSpacing = 8,
+                RowSpacing = 3,
+            };
 
+            // Set partitioning configuration
+            grid.ColumnsProportions.Add(new Proportion(ProportionType.Auto));
+            grid.ColumnsProportions.Add(new Proportion(ProportionType.Fill));
+            grid.RowsProportions.Add(new Proportion(ProportionType.Auto));
+            grid.RowsProportions.Add(new Proportion(ProportionType.Auto));
+            var sessionNameLabel = new Label { Text = "Session Name:" };
+            var initialsLabel = new Label { Text = "Initials:", GridRow = 1 };
+            var textbox = new TextBox { GridColumn = 1 };
+            var initialsTextbox = new TextBox { GridColumn = 1, GridRow = 1 };
+            TextButton button = new TextButton
+            {
+                Text = "Start",
+                HorizontalAlignment = HorizontalAlignment.Center
+            };
+            grid.Widgets.Add(textbox);
+            grid.Widgets.Add(initialsTextbox);
+            grid.Widgets.Add(sessionNameLabel);
+            grid.Widgets.Add(initialsLabel);
+
+            content.Widgets.Add(grid);
+
+            button.Click += async (s, e) =>
+     {
+         if (string.IsNullOrWhiteSpace(textbox.Text))
+         {
+             return;
+         }
+         if (connection.State != HubConnectionState.Connected)
+         { await connection.StartAsync(); }
+         var successful = false;
+         try
+         {
+             var result = await connection?.InvokeAsync<SessionData>("JoinSession", textbox.Text, initialsTextbox.Text);
+             if (result != null)
+             {
+                 _sessionData.Map = result.Map;
+                 _sessionData.Walls = result.Walls;
+                 _sessionData.Overlays = result.Overlays;
+                 Players = result.Players;
+             }
+             successful = result != null; ;
+         }
+         catch { }
+         if (successful)
+         {
+             _session = textbox.Text;
+             window.Close();
+         }
+     };
+
+            content.Widgets.Add(button);
+            window.Content = content;
+
+            window.ShowModal(_desktop);
+        }
+
+        private void OnMenuConnectNewSelected(object sender, EventArgs e)
+        {
+            Window window = new Window
+            {
+                Title = "New mapping session"
+            };
+            var content = new VerticalStackPanel();
+            var grid = new Grid
+            {
+                Width = 200,
+                ShowGridLines = false,
+                ColumnSpacing = 8,
+                RowSpacing = 3,
+            };
+
+            // Set partitioning configuration
+            grid.ColumnsProportions.Add(new Proportion(ProportionType.Auto));
+            grid.ColumnsProportions.Add(new Proportion(ProportionType.Fill));
+            grid.RowsProportions.Add(new Proportion(ProportionType.Auto));
+            grid.RowsProportions.Add(new Proportion(ProportionType.Auto));
+            var sessionNameLabel = new Label { Text = "Session Name:" };
+            var initialsLabel = new Label { Text = "Initials:", GridRow = 1 };
+            var textbox = new TextBox { GridColumn = 1 };
+            var initialsTextbox = new TextBox { GridColumn = 1, GridRow = 1 };
+            TextButton button = new TextButton
+            {
+                Text = "Start",
+                HorizontalAlignment = HorizontalAlignment.Center
+            };
+            grid.Widgets.Add(textbox);
+            grid.Widgets.Add(initialsTextbox);
+            grid.Widgets.Add(sessionNameLabel);
+            grid.Widgets.Add(initialsLabel);
+
+            content.Widgets.Add(grid);
+
+            button.Click += async (s, e) =>
+            {
+                if (string.IsNullOrWhiteSpace(textbox.Text))
+                {
+                    return;
+                }
+                if (connection.State != HubConnectionState.Connected)
+                { await connection.StartAsync(); }
+                var successful = false;
+                try
+                {
+                    var session = await connection?.InvokeAsync<SessionData>("NewSession", textbox.Text, initialsTextbox.Text);
+                    if (session != null)
+                    {
+                        _sessionData = session;
+                        session.TileAdded += OnTileAdded;
+                        session.OverlayAdded += OnOverlayAdded;
+                        session.WallAdded += OnWallAdded;
+                        session.TileDeleted += OnTileDeleted;
+                        session.WallDeleted += OnWallDeleted;
+                        session.OverlayDeleted += OnOverlayDeleted;
+                        Players = session.Players;
+
+                    }
+                    successful = session != null;
+                }
+                catch (Exception ex)
+
+                {
+
+                }
+                if (successful)
+                {
+                    _session = textbox.Text;
+                    window.Close();
+                }
+            };
+
+
+            content.Widgets.Add(button);
+            window.Content = content;
+
+            window.Closed += (s, a) =>
+            {
+                    // Called when window is closed
+                };
+
+            window.ShowModal(_desktop);
+        }
+
+        private void OnMenuFileSaveSelected(object sender, EventArgs e)
+        {
+            FileDialog dialog = new FileDialog(FileDialogMode.SaveFile)
+            {
+                Filter = "*.map"
+            };
+
+            dialog.Closed += (s, a) =>
+            {
+                if (!dialog.Result)
+                {
+                    return;
+                }
+
+                using (StreamWriter file = File.CreateText(dialog.FilePath))
+                {
+                    JsonSerializer serializer = new JsonSerializer();
+                    serializer.Serialize(file, _sessionData);
+                }
+            };
+
+            dialog.ShowModal(_desktop);
+        }
+
+        private void OnMenuFileLoadSelected(object sender, EventArgs e)
+        {
+            FileDialog dialog = new FileDialog(FileDialogMode.OpenFile)
+            {
+                Filter = "*.map"
+            };
+
+            dialog.Closed += (s, a) =>
+            {
+                if (!dialog.Result)
+                {
+                    return;
+                }
+                using (StreamReader file = File.OpenText(dialog.FilePath))
+                {
+                    JsonSerializer serializer = new JsonSerializer();
+                    _sessionData = (SessionData)serializer.Deserialize(file, typeof(SessionData));
+                }
+            };
+
+            dialog.ShowModal(_desktop);
+        }
+
+        private async void OnMenuConnectSyncSelected(object sender, EventArgs e)
+        {
+            await connection?.InvokeAsync("Sync", _session, _sessionData);
+        }
 
         protected override void LoadContent()
         {
@@ -521,7 +505,6 @@ namespace Sledgemapper
 
             _fonts = Content.LoadContentFolder<SpriteFont>("fonts");
 
-
             // Add it to the desktop
             // _desktop = new Desktop();
             _desktop.Root = mainPanel;
@@ -580,15 +563,15 @@ namespace Sledgemapper
                             _selectedTile.Y = _hoveredTile.Y;
                             connection?.SendAsync("UpdatePosition", _session, _selectedTile);
 
-                            SetTile(_currentTileId);
+                            _sessionData.NewTile(_selectedTile, _currentTileId);
                             break;
 
                         case InsertMode.Wall:
+                            _sessionData.NewWall(_selectedWall, _currentWallId);
 
-                            SetWall(_currentWallId);
                             break;
                         case InsertMode.Overlay:
-                            SetOverlay(_currentOverlayId);
+                            _sessionData.NewOverlay(_selectedOverlay, _currentOverlayId);
                             break;
                     }
                 }
@@ -622,25 +605,19 @@ namespace Sledgemapper
                     case InsertMode.Tile:
                         _selectedTile.X = _hoveredTile.X;
                         _selectedTile.Y = _hoveredTile.Y;
-                        DeleteTile();
+                        _sessionData.DeleteTile(_selectedTile);
                         break;
-
                     case InsertMode.Wall:
-
-                        DeleteWall();
+                        _sessionData.DeleteWall(_selectedWall);
                         break;
-
                     case InsertMode.Overlay:
-
-                        DeleteOverlay();
+                        _sessionData.DeleteOverlay(_selectedOverlay);
                         break;
                 }
-
             }
 
             foreach (var key in newState.GetPressedKeys())
             {
-
                 switch (key)
                 {
                     case Keys.Left:
@@ -932,83 +909,30 @@ namespace Sledgemapper
             _selectedOverlay.Intersection = false;
         }
 
-        private void SetTile(string tileId)
-        {
-            _sessionData.NewTile(_selectedTile, tileId);
-        }
 
-        private void TileAddedEvent(object sender, TileAddedEventArgs e)
-        {
-            _api.NewTile(e.Tile, _session);
-        }
-
-        private void SetOverlay(string tileId)
-        {
-          _sessionData.NewOverlay(_selectedOverlay, tileId);
-        }
-
-         private void OverlayAddedEvent(object sender, OverlayAddedEventArgs e)
+        private void OnOverlayAdded(object sender, OverlayAddedEventArgs e)
         {
             _api.NewOverlay(e.Overlay, _session);
         }
-
-        private void DeleteWall()
+        private void OnTileAdded(object sender, TileAddedEventArgs e)
         {
-            var tileExist = _sessionData.Walls.TryGetValue(_selectedWall.ToString(), out var wall);
-            if (tileExist)
-            {
-                //var wall = _sessionData.Walls.First(m => m.X == _selectedWall.X && m.Y == _selectedWall.Y && m.Rotation == _selectedWall.Rotation);
-                //var index = _sessionData.Walls.IndexOf(wall);
-                _sessionData.Walls.TryRemove(wall.ToString(), out var rwall);
-                connection?.InvokeAsync("DeleteWall", _session, wall);
-            }
+            _api.NewTile(e.Tile, _session);
         }
-
-        private void DeleteOverlay()
+        private void OnWallAdded(object sender, WallAddedEventArgs e)
         {
-            var tileExist = _sessionData.Overlays.TryGetValue(_selectedOverlay.ToString(), out var overlay);
-            if (tileExist)
-            {
-                //var wall = _sessionData.Overlays.First(m => m.X == _selectedOverlay.X && m.Y == _selectedOverlay.Y && m.Intersection == _selectedOverlay.Intersection);
-                //var index = _sessionData.Overlays.IndexOf(wall);
-                _sessionData.Overlays.TryRemove(overlay.ToString(), out var roverlay);
-                connection?.InvokeAsync("DeleteOverlay", _session, overlay);
-            }
+            _api.NewWall(e.Wall, _session);
         }
-
-        private void DeleteTile()
+        private void OnOverlayDeleted(object sender, OverlayDeletedEventArgs e)
         {
-            var tileExist = _sessionData.Map.TryGetValue(_selectedTile.ToString(), out var tile);
-            if (tileExist)
-            {
-                // var tile = _sessionData.Map.First(m => m.X == _selectedTile.X && m.Y == _selectedTile.Y);
-                // var index = _sessionData.Map.IndexOf(tile);
-                _sessionData.Map.TryRemove(tile.ToString(), out var rtile);
-                connection?.InvokeAsync("DeleteTile", _session, tile);
-            }
+            _api.DeleteOverlay(e.Overlay, _session);
         }
-
-        private void SetWall(string wallId)
+        private void OnTileDeleted(object sender, TileDeletedEventArgs e)
         {
-            var tileExist = _sessionData.Walls.TryGetValue(_selectedWall.ToString(), out var wall);
-            if (tileExist)
-            {
-                // var wall = _sessionData.Walls.First(m => m.X == _selectedWall.X && m.Y == _selectedWall.Y && m.Rotation == _selectedWall.Rotation);
-                // var index = _sessionData.Walls.IndexOf(wall);
-                _sessionData.Walls.TryRemove(wall.ToString(), out var rwall);
-                var newWall = new Wall { X = _selectedWall.X, Y = _selectedWall.Y, ID = wallId, Rotation = _selectedWall.Rotation };
-                _sessionData.Walls.TryAdd(newWall.ToString(), newWall);
-                connection?.InvokeAsync("NewWall", _session, newWall);
-
-            }
-            else
-            {
-                var newWall = new Wall { X = _selectedWall.X, Y = _selectedWall.Y, ID = wallId, Rotation = _selectedWall.Rotation };
-                _sessionData.Walls.TryAdd(newWall.ToString(), newWall);
-                connection?.InvokeAsync("NewWall", _session, newWall);
-
-                //connection?.InvokeAsync("SendMessage", $"{_selectedTile.X}:{_selectedTile.Y}", tileId.ToString(), _session);
-            }
+            _api.DeleteTile(e.Tile, _session);
+        }
+        private void OnWallDeleted(object sender, WallDeletedEventArgs e)
+        {
+            _api.DeleteWall(e.Wall, _session);
         }
     }
 }