Send position and overlay

2021-09-17 12:37:02 +01:00 · 2021-09-17 12:37:02 +01:00 · f12132009f
commit f12132009f
parent db41143312
11 changed files with 599 additions and 34 deletions
--- a/Sledgemapper.Api/Core/Entities/SessionUser.cs
+++ b/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; }
    }
 }
--- a/Sledgemapper.Api/Core/Entities/UserConnection.cs
+++ b/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;}
--- a/Sledgemapper.Api/Handlers/SendNewOverlayMessage.cs
+++ b/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);
        }
    }
 }
--- a/Sledgemapper.Api/Hubs/SledgemapperHub.cs
+++ b/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 user = _dbContext.Users.First(u => u.Id == 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 == 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 userId = int.Parse(Context.User.Identity.Name);
+            var session = _dbContext.Sessions.FirstOrDefault(s => s.SessionId == mapId);
+
+            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);
-                var user = _dbContext.Users.First(u => u.Id == Context.User.Identity.Name);
+                await Groups.AddToGroupAsync(Context.ConnectionId, session.SessionId.ToString());
+                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.SessionName).RefreshPlayers();
+                await Clients.Group(session.SessionId.ToString()).NewPlayer(player);
+                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();
--- a/Sledgemapper.Api/Migrations/20210917112525_UserIdGuid.Designer.cs
+++ b/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
+        }
+    }
+}
--- a/Sledgemapper.Api/Migrations/20210917112525_UserIdGuid.cs
+++ b/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");
+        }
+    }
+}
--- a/Sledgemapper.Api/Migrations/SledgemapperDbContextModelSnapshot.cs
+++ b/Sledgemapper.Api/Migrations/SledgemapperDbContextModelSnapshot.cs
@ -337,8 +337,8 @@ namespace Sledgemapper.Api.Migrations
                    b.Property<Guid>("SessionId")
                        .HasColumnType("TEXT");

-                    b.Property<int>("UserId")
-                        .HasColumnType("INTEGER");
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");

                    b.HasKey("SessionUserId");

@ -376,8 +376,8 @@ namespace Sledgemapper.Api.Migrations
                        .IsRequired()
                        .HasColumnType("TEXT");

-                    b.Property<int>("UserId")
-                        .HasColumnType("INTEGER");
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");

                    b.HasKey("UserConnectionId");

--- a/Sledgemapper.Shared/Entities/Player.cs
+++ b/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; }
--- a/Sledgemapper/CommunicationManager.cs
+++ b/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);
--- a/Sledgemapper/Sledgemapper.cs
+++ b/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);

                    }
                }
--- a/Sledgemapper/UI/MainWidget.Custom.cs
+++ b/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;