Send position and overlay

Sledgemapper.Api/Core/Entities/SessionUser.cs

@@ -12,6 +12,6 @@ namespace Sledgemapper.Api.Models
         public Guid SessionId { get; set; }
 
         [Required]
-        public int UserId { get; set; }
+        public Guid UserId { get; set; }
     }
 }

Sledgemapper.Api/Core/Entities/UserConnection.cs

@@ -1,3 +1,4 @@
+using System;
 using System.ComponentModel.DataAnnotations;
 
 namespace Sledgemapper.Api.Models
@@ -7,7 +8,7 @@ namespace Sledgemapper.Api.Models
         [Key]
         public int UserConnectionId { get; set; }
         [Required]
-        public int UserId { get; set; }
+        public Guid UserId { get; set; }
 
         [Required]
         public string ConnectionId{get;set;}

Sledgemapper.Api/Handlers/SendNewOverlayMessage.cs

@@ -16,7 +16,7 @@ namespace Sledgemapper.Api.Handlers
 
         public async Task Handle(NewOverlayNotification notification, CancellationToken cancellationToken)
         {
-            await _hub.Clients.Groups(notification.Session.SessionName).NewOverlay(notification.Overlay);
+            await _hub.Clients.Groups(notification.Session.SessionId.ToString()).NewOverlay(notification.Overlay);
         }
     }
 }

Sledgemapper.Api/Hubs/SledgemapperHub.cs

@@ -15,7 +15,7 @@ namespace Sledgemapper.Api.Hubs
     [Authorize]
     public class SledgemapperHub : Hub<ISledgemapperClient>
     {
-        private static readonly ConcurrentDictionary<int, string> UserColors = new();
+        private static readonly ConcurrentDictionary<Guid, string> UserColors = new();
         private readonly SledgemapperDbContext _dbContext;
         // private readonly DataContext _datacontext;
 
@@ -60,9 +60,9 @@ namespace Sledgemapper.Api.Hubs
             await Clients.Group(sessionName).NewWall(tile);
         }
 
-        public async Task NewOverlay(string sessionName, Overlay tile)
+        public async Task NewOverlay(Guid mapId, Overlay tile)
         {
-            await Clients.Group(sessionName).NewOverlay(tile);
+            await Clients.Group(mapId.ToString()).NewOverlay(tile);
         }
 
         public async Task NewNote(string sessionName, Note note)
@@ -87,42 +87,40 @@ namespace Sledgemapper.Api.Hubs
 
         public async Task Ping(string sessionName, Tile location)
         {
-            var userId = int.Parse(Context.User.Identity.Name);
+            var userId = new Guid(  Context.User.Claims.FirstOrDefault(m => m.Type == "Id").Value);
-            var user = _dbContext.Users.First(u => u.Id == Context.User.Identity.Name);
+
+            var user = _dbContext.Users.First(u => u.Id == userId.ToString());
 
             var player = new Player { UserId = userId, Initials = user.Initials, Position = new Tile { X = 0, Y = 0 }, Color = UserColors[userId] };
             await Clients.Group(sessionName).Ping(new Ping{X=location.X, Y=location.Y, Player=player});
         }
 
-        public async Task<Shared.Entities.Session> JoinSession(string sessionName)
+        public async Task<bool> JoinSession(Guid mapId)
         {
-            var session = _dbContext.Sessions.FirstOrDefault(s => s.SessionName == sessionName);
+            var session = _dbContext.Sessions.FirstOrDefault(s => s.SessionId == mapId);
-            var userId = int.Parse(Context.User.Identity.Name);
+
+            var userId = new Guid(Context.User.Claims.FirstOrDefault(m => m.Type == "Id").Value);
 
             if (session != null)
             {
                 var userSession = new SessionUser { SessionId = session.SessionId, UserId = userId };
                 _dbContext.SessionUsers.Add(userSession);
                 await _dbContext.SaveChangesAsync();
-                await Groups.AddToGroupAsync(Context.ConnectionId, session.SessionName);
+                await Groups.AddToGroupAsync(Context.ConnectionId, session.SessionId.ToString());
-                var user = _dbContext.Users.First(u => u.Id == Context.User.Identity.Name);
+                var user = _dbContext.Users.First(u => u.Id == userId.ToString());
 
                 var player = new Player { UserId = userId, Initials = user.Initials, Position = new Tile { X = 0, Y = 0 }, Color = UserColors[userId] };
 
-                await Clients.Group(session.SessionName).NewPlayer(player);
+                await Clients.Group(session.SessionId.ToString()).NewPlayer(player);
-                await Clients.Group(session.SessionName).RefreshPlayers();
+                await Clients.Group(session.SessionId.ToString()).RefreshPlayers();
 
-                var newSession = new Shared.Entities.Session
+                
-                {
-                    SessionName = session.SessionName,
-                    SessionId = session.SessionId
-                };
 
-                return newSession;
+                return true;
             }
             else
             {
-                return null;
+                return false;
             }
         }
 
@@ -137,16 +135,16 @@ namespace Sledgemapper.Api.Hubs
 
         public async Task UpdatePosition(string sessionName, Guid sessionId, Tile tile)
         {
-            var userId = int.Parse(Context.User.Identity.Name);
+            var userId = new Guid(Context.User.Claims.FirstOrDefault(m => m.Type == "Id").Value);
             var SessionUsers = _dbContext.SessionUsers.Where(m => m.SessionId == sessionId).OrderBy(m => m.UserId).ToList();
-            var user = _dbContext.Users.First(u => u.Id == Context.User.Identity.Name);
+            var user = _dbContext.Users.First(u => u.Id == userId.ToString());
             var player = new Player { UserId = userId, Initials = user.Initials, Position = tile, Color = UserColors[userId] };
-            await Clients.Group(sessionName).PlayerUpdate(player);
+            await Clients.Group(sessionId.ToString()).PlayerUpdate(player);
         }
 
         public override async Task OnConnectedAsync()
         {
-            var userId = int.Parse(Context.User.Identity.Name);
+            var userId = new Guid(Context.User.Claims.FirstOrDefault(m => m.Type == "Id").Value);
             var userConnection = new UserConnection { ConnectionId = Context.ConnectionId, UserId = userId };
             _dbContext.UserConnections.Add(userConnection);
             await _dbContext.SaveChangesAsync();

Sledgemapper.Api/Migrations/20210917112525_UserIdGuid.Designer.cs

@@ -0,0 +1,508 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Sledgemapper.Api.Infrastructure.Data;
+
+namespace Sledgemapper.Api.Migrations
+{
+    [DbContext(typeof(SledgemapperDbContext))]
+    [Migration("20210917112525_UserIdGuid")]
+    partial class UserIdGuid
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "5.0.6");
+
+            modelBuilder.Entity("CampaignUser", b =>
+                {
+                    b.Property<Guid>("CampaignsCampaignId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("InvitedUsersId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("CampaignsCampaignId", "InvitedUsersId");
+
+                    b.HasIndex("InvitedUsersId");
+
+                    b.ToTable("CampaignUser");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("NormalizedName")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique()
+                        .HasDatabaseName("RoleNameIndex");
+
+                    b.ToTable("AspNetRoles");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("RoleId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetRoleClaims");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUser", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("AccessFailedCount")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("EmailConfirmed")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("LockoutEnabled")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset?>("LockoutEnd")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("NormalizedEmail")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("NormalizedUserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PasswordHash")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("PhoneNumberConfirmed")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("SecurityStamp")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("TwoFactorEnabled")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("UserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedEmail")
+                        .HasDatabaseName("EmailIndex");
+
+                    b.HasIndex("NormalizedUserName")
+                        .IsUnique()
+                        .HasDatabaseName("UserNameIndex");
+
+                    b.ToTable("AspNetUsers");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserClaims");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.Property<string>("LoginProvider")
+                        .HasMaxLength(128)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ProviderKey")
+                        .HasMaxLength(128)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ProviderDisplayName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("LoginProvider", "ProviderKey");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserLogins");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("RoleId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("UserId", "RoleId");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetUserRoles");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("LoginProvider")
+                        .HasMaxLength(128)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(128)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("UserId", "LoginProvider", "Name");
+
+                    b.ToTable("AspNetUserTokens");
+                });
+
+            modelBuilder.Entity("Sledgemapper.Api.Core.Entities.Campaign", b =>
+                {
+                    b.Property<Guid>("CampaignId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CampaignName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("OwnerId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("CampaignId");
+
+                    b.HasIndex("OwnerId");
+
+                    b.HasIndex("CampaignName", "OwnerId")
+                        .IsUnique();
+
+                    b.ToTable("Campaigns");
+                });
+
+            modelBuilder.Entity("Sledgemapper.Api.Core.Entities.Map", b =>
+                {
+                    b.Property<int>("MapId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("CampaignId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("MapName")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("MapId");
+
+                    b.ToTable("Maps");
+                });
+
+            modelBuilder.Entity("Sledgemapper.Api.Models.MapLog", b =>
+                {
+                    b.Property<int>("MapLogId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Object")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Operation")
+                        .IsRequired()
+                        .HasMaxLength(1)
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("SessionId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<double>("Timestamp")
+                        .HasColumnType("REAL");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("MapLogId");
+
+                    b.ToTable("MapLogs");
+                });
+
+            modelBuilder.Entity("Sledgemapper.Api.Models.Session", b =>
+                {
+                    b.Property<Guid>("SessionId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("CampaignId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("OwnerUserId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SessionName")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("SessionId");
+
+                    b.HasIndex("CampaignId", "SessionName")
+                        .IsUnique();
+
+                    b.ToTable("Sessions");
+                });
+
+            modelBuilder.Entity("Sledgemapper.Api.Models.SessionUser", b =>
+                {
+                    b.Property<int>("SessionUserId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid>("SessionId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("SessionUserId");
+
+                    b.ToTable("SessionUsers");
+                });
+
+            modelBuilder.Entity("Sledgemapper.Api.Models.Snapshot", b =>
+                {
+                    b.Property<int>("SnapshotId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Object")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("SessionId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<double>("Timestamp")
+                        .HasColumnType("REAL");
+
+                    b.HasKey("SnapshotId");
+
+                    b.ToTable("Snapshots");
+                });
+
+            modelBuilder.Entity("Sledgemapper.Api.Models.UserConnection", b =>
+                {
+                    b.Property<int>("UserConnectionId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ConnectionId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("UserConnectionId");
+
+                    b.ToTable("UserConnections");
+                });
+
+            modelBuilder.Entity("Sledgemapper.Entities.User", b =>
+                {
+                    b.HasBaseType("Microsoft.AspNetCore.Identity.IdentityUser");
+
+                    b.Property<string>("FirstName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Initials")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("LastName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<byte[]>("PasswordSalt")
+                        .HasColumnType("BLOB");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("CampaignUser", b =>
+                {
+                    b.HasOne("Sledgemapper.Api.Core.Entities.Campaign", null)
+                        .WithMany()
+                        .HasForeignKey("CampaignsCampaignId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Sledgemapper.Entities.User", null)
+                        .WithMany()
+                        .HasForeignKey("InvitedUsersId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Sledgemapper.Api.Core.Entities.Campaign", b =>
+                {
+                    b.HasOne("Sledgemapper.Entities.User", "Owner")
+                        .WithMany()
+                        .HasForeignKey("OwnerId");
+
+                    b.Navigation("Owner");
+                });
+
+            modelBuilder.Entity("Sledgemapper.Api.Models.Session", b =>
+                {
+                    b.HasOne("Sledgemapper.Api.Core.Entities.Campaign", null)
+                        .WithMany("Maps")
+                        .HasForeignKey("CampaignId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Sledgemapper.Entities.User", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityUser", null)
+                        .WithOne()
+                        .HasForeignKey("Sledgemapper.Entities.User", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Sledgemapper.Api.Core.Entities.Campaign", b =>
+                {
+                    b.Navigation("Maps");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

Sledgemapper.Api/Migrations/20210917112525_UserIdGuid.cs

@@ -0,0 +1,46 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace Sledgemapper.Api.Migrations
+{
+    public partial class UserIdGuid : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AlterColumn<Guid>(
+                name: "UserId",
+                table: "UserConnections",
+                type: "TEXT",
+                nullable: false,
+                oldClrType: typeof(int),
+                oldType: "INTEGER");
+
+            migrationBuilder.AlterColumn<Guid>(
+                name: "UserId",
+                table: "SessionUsers",
+                type: "TEXT",
+                nullable: false,
+                oldClrType: typeof(int),
+                oldType: "INTEGER");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AlterColumn<int>(
+                name: "UserId",
+                table: "UserConnections",
+                type: "INTEGER",
+                nullable: false,
+                oldClrType: typeof(Guid),
+                oldType: "TEXT");
+
+            migrationBuilder.AlterColumn<int>(
+                name: "UserId",
+                table: "SessionUsers",
+                type: "INTEGER",
+                nullable: false,
+                oldClrType: typeof(Guid),
+                oldType: "TEXT");
+        }
+    }
+}

Sledgemapper.Api/Migrations/SledgemapperDbContextModelSnapshot.cs

@@ -337,8 +337,8 @@ namespace Sledgemapper.Api.Migrations
                     b.Property<Guid>("SessionId")
                         .HasColumnType("TEXT");
 
-                    b.Property<int>("UserId")
+                    b.Property<Guid>("UserId")
-                        .HasColumnType("INTEGER");
+                        .HasColumnType("TEXT");
 
                     b.HasKey("SessionUserId");
 
@@ -376,8 +376,8 @@ namespace Sledgemapper.Api.Migrations
                         .IsRequired()
                         .HasColumnType("TEXT");
 
-                    b.Property<int>("UserId")
+                    b.Property<Guid>("UserId")
-                        .HasColumnType("INTEGER");
+                        .HasColumnType("TEXT");
 
                     b.HasKey("UserConnectionId");
 

Sledgemapper.Shared/Entities/Player.cs

@@ -1,8 +1,10 @@
+using System;
+
 namespace Sledgemapper.Shared.Entities
 {
     public class Player
     {
-        public int UserId { get; set; }
+        public Guid UserId { get; set; }
         public string Color { get; set; }
         public string UserName { get; set; }
         public string Initials { get; set; }

Sledgemapper/CommunicationManager.cs

@@ -33,7 +33,7 @@ namespace Sledgemapper
             SessionData = sessionData;
             Connection = new HubConnectionBuilder()
                                        .WithAutomaticReconnect()
-
+                                       
                                        .WithUrl($"{baseAddress}/SledgemapperHub", options =>
                                         {
                                             options.AccessTokenProvider = () => Task.FromResult(_authenticateResponse.Token);
@@ -109,7 +109,7 @@ namespace Sledgemapper
          {
              if (!string.IsNullOrWhiteSpace(SessionData.SessionName))
              {
-                 Connection?.SendAsync("UpdatePosition", SessionData.SessionName, SessionData.SessionId, SessionData.Players.First(p => p.UserId == int.Parse(_authenticateResponse.Id)));
+                 Connection?.SendAsync("UpdatePosition", SessionData.SessionName, State.Instance.MapId, SessionData.Players.First(p => p.UserId == new Guid(_authenticateResponse.Id)));
              }
          });
 
@@ -160,6 +160,8 @@ namespace Sledgemapper
             });
         }
 
+       
+
         private Task<string> GetToken()
         {
             return Task.FromResult(_authenticateResponse.Token);

Sledgemapper/Sledgemapper.cs

@@ -308,7 +308,7 @@ namespace Sledgemapper
                     {
                         _state.SelectedTile.X = _state.HoveredTile.X;
                         _state.SelectedTile.Y = _state.HoveredTile.Y;
-                        _communicationManager.Connection?.SendAsync("UpdatePosition", _sessionData.SessionName, _sessionData.SessionId, _state.SelectedTile);
+                        _communicationManager.Connection?.SendAsync("UpdatePosition", _sessionData.SessionName, State.Instance.MapId, _state.SelectedTile);
 
                     }
                 }

Sledgemapper/UI/MainWidget.Custom.cs

@@ -94,6 +94,14 @@ namespace Sledgemapper.UI
             CommunicationManager.SessionData.MapEntityAdded += OnMapEntityAdded;
             CommunicationManager.SessionData.MapEntityDeleted += OnMapEntityDeleted;
             var serverMap = await CommunicationManager.Api.GetMap(State.Instance.CampaignId, State.Instance.MapId);
+            if (CommunicationManager.Connection.State != HubConnectionState.Connected)
+            {
+                
+                await CommunicationManager.Connection.StartAsync();
+                UpdateConnectionState(CommunicationManager.Connection);
+            }
+            var result = await CommunicationManager.Connection?.InvokeAsync<bool>("JoinSession", State.Instance.MapId);
+
             CommunicationManager.SessionData.Overlays = serverMap.Overlays;
             CommunicationManager.SessionData.Map = serverMap.Map;
             CommunicationManager.SessionData.Walls = serverMap.Walls;