diff --git a/Api/Configurations/AppConfigurationService.cs b/Api/Configurations/AppConfigurationService.cs
index 2e2a991..50c7af6 100644
--- a/Api/Configurations/AppConfigurationService.cs
+++ b/Api/Configurations/AppConfigurationService.cs
@@ -3,7 +3,6 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Diagnostics;
 using Microsoft.Extensions.Options;
-using DomainLayer.Constants;
 using RepositoryLayer.Contexts;
 using RepositoryLayer.Repositories;
 using Serilog;
@@ -31,6 +30,7 @@ public static void AddAppServices(this IServiceCollection services)
             services.AddScoped<ICharacterTypeServices, CharacterTypeServices>();
             services.AddScoped<IGameServerServices, GameServerServices>();
             services.AddScoped<IGameServices, GameServices>();
+            services.AddScoped<IGameUserServices, GameUserServices>();
             services.AddScoped<ILevelProgressServices, LevelProgressServices>();
             services.AddScoped<ILevelServices, LevelServices>();
             services.AddScoped<IPaymentServices, PaymentServices>();
diff --git a/Api/Configurations/DatabaseInitializer.cs b/Api/Configurations/DatabaseInitializer.cs
index a351029..bf1b159 100644
--- a/Api/Configurations/DatabaseInitializer.cs
+++ b/Api/Configurations/DatabaseInitializer.cs
@@ -16,6 +16,7 @@ public static async Task InitializeAsync(ApplicationDbContext dbContext)
         await dbContext.MockAttributeGroup();
         await dbContext.MockUser();
         await dbContext.MockGame();
+        await dbContext.MockGameUser();
         await dbContext.MockGameServer();
         await dbContext.MockAssetType();
         await dbContext.MockAsset();
@@ -104,6 +105,25 @@ public static async Task MockGame(this ApplicationDbContext dbContext)
             await dbContext.SaveChangesAsync();
         }
     }
+    public static async Task MockGameUser(this ApplicationDbContext dbContext)
+    {
+        if (dbContext.GamesUsers.Any()) return;
+
+        var users = dbContext.Users.ToList();
+        var games = dbContext.Games.ToList();
+        for (int i =0; i < 20; i++)
+        {
+            await dbContext.GamesUsers.AddAsync(
+                new GameUserEntity
+                {
+                    GameId = games[_rand.Next(games.Count)].Id,
+                    UserId = users[_rand.Next(users.Count)].Id,
+                    CreatedAt = DateTime.Now,
+                    ModifiedAt = DateTime.Now
+            });
+        }
+        await dbContext.SaveChangesAsync();
+    }
     public static async Task MockGameServer(this ApplicationDbContext dbContext)
     {
         if (dbContext.GameServers.Any()) return;
@@ -311,10 +331,9 @@ public static async Task MockLevel(this ApplicationDbContext dbContext)
                     CreatedAt = DateTime.Now,
                     ModifiedAt = DateTime.Now
                 };
-            } while (await dbContext.Levels.FirstOrDefaultAsync(l => l.Name == newLevel.Name && l.GameId == newLevel.GameId) != null);
-
-            await dbContext.Levels.AddAsync(newLevel);
-            await dbContext.SaveChangesAsync(); // Await this operation
+            } while (dbContext.Levels.FirstOrDefault(l => l.Name == newLevel.Name && l.GameId == newLevel.GameId) != null);
+            dbContext.Levels.Add(newLevel);
+            dbContext.SaveChanges(); // Await this operation
         }
     }
     public static async Task MockLevelProgress(this ApplicationDbContext dbContext)
diff --git a/Api/Controllers/GamesController.cs b/Api/Controllers/GamesController.cs
index 8aaf2da..8e21845 100644
--- a/Api/Controllers/GamesController.cs
+++ b/Api/Controllers/GamesController.cs
@@ -11,27 +11,31 @@ namespace WebApiLayer.Controllers;
 public class GamesController : BaseController
 {
     private readonly IGameServices _gameServices;
+    private readonly IGameUserServices _gameUserServices;
     private readonly IActivityTypeServices _activityTypeServices;
     private readonly IAssetTypeServices _assetTypeServices;
     private readonly ICharacterTypeServices _characterTypeServices;
     private readonly IGameServerServices _gameServerServices;
     private readonly ILevelServices _levelServices;
     private readonly IWalletCategoryServices _walletCategoryServices;
+    private readonly IUserServices _userServices;
     private readonly IGenericRepository<GameEntity> _gameRepo;
     private readonly IGenericRepository<UserEntity> _userRepo;
-    public GamesController(IGameServices gameServices, IActivityTypeServices activityTypeServices
-        , IAssetTypeServices assetTypeServices
-        , ICharacterTypeServices characterTypeServices , IGameServerServices gameServerServices
-        , ILevelServices levelServices, IWalletCategoryServices walletCategoryServices
+    public GamesController(IGameServices gameServices, IActivityTypeServices activityTypeServices, IGameUserServices gameUserServices
+        , IAssetTypeServices assetTypeServices, ICharacterTypeServices characterTypeServices 
+        , IGameServerServices gameServerServices, ILevelServices levelServices
+        , IWalletCategoryServices walletCategoryServices, IUserServices userServices
         , IGenericRepository<GameEntity> gameRepo, IGenericRepository<UserEntity> userRepo)
     {
         _gameServices = gameServices;
         _activityTypeServices = activityTypeServices;
+        _gameUserServices = gameUserServices;
         _assetTypeServices = assetTypeServices;
         _characterTypeServices = characterTypeServices;
         _gameServerServices = gameServerServices;
         _levelServices = levelServices;
         _walletCategoryServices = walletCategoryServices;
+        _userServices = userServices;
         _gameRepo = gameRepo;
         _userRepo = userRepo;
     }
@@ -55,39 +59,44 @@ public async Task<IActionResult> GetGame(Guid id)
     [HttpGet("{id}/activity-types")]
     public async Task<IActionResult> GetActTypeByGameID(Guid id)
     {
-        return Ok(await _activityTypeServices.GetByGameId(id));
+        return Ok(await _activityTypeServices.ListActTypesByGameId(id));
     }
 
     [HttpGet("{id}/asset-types")]
     public async Task<IActionResult> GetAssTypeByGameID(Guid id)
     {
-        return Ok(await _assetTypeServices.GetByGameId(id));
+        return Ok(await _assetTypeServices.ListAssTypesByGameId(id));
     }
 
     [HttpGet("{id}/character-types")]
     public async Task<IActionResult> GetCharTypeByGameID(Guid id)
     {
-        return Ok(await _characterTypeServices.GetByGameId(id));
+        return Ok(await _characterTypeServices.ListCharTypesByGameId(id));
     }
 
     [HttpGet("{id}/game-servers")]
     public async Task<IActionResult> GetGameServerByGameID(Guid id)
     {
-        return Ok(await _gameServerServices.GetByGameId(id));
+        return Ok(await _gameServerServices.ListServersByGameId(id));
     }
 
     [HttpGet("{id}/levels")]
     public async Task<IActionResult> GetLevelByGameID(Guid id)
     {
-        return Ok(await _levelServices.GetByGameId(id));
+        return Ok(await _levelServices.ListLevelsByGameId(id));
     }
 
     [HttpGet("{id}/wallet-category")]
     public async Task<IActionResult> GetWalCatByGameID(Guid id)
     {
-        return Ok(await _walletCategoryServices.GetByGameId(id));
+        return Ok(await _walletCategoryServices.ListWalCatsByGameId(id));
     }
 
+    [HttpGet("{id}/users")]
+    public async Task<IActionResult> GetUsersByGameID(Guid id)
+    {
+        return Ok(await _gameUserServices.ListUsersByGameId(id));
+    }
     [HttpPost]
     public async Task<IActionResult> CreateGame([FromBody] CreateGameRequest newGame)
     {
diff --git a/Api/Controllers/LevelsController.cs b/Api/Controllers/LevelsController.cs
index ce5028b..f43b3a1 100644
--- a/Api/Controllers/LevelsController.cs
+++ b/Api/Controllers/LevelsController.cs
@@ -22,10 +22,13 @@ public class LevelsController : BaseController
     }
 
     [HttpGet]
-    public async Task<IActionResult> GetLevels()
+    public async Task<IActionResult> GetLevels([FromQuery] Guid[]? idList)
     {
-        var levels = await _levelServices.List();
-        return Ok(levels);
+        if (idList != null && idList.Count() > 0)
+        {
+            return Ok(await _levelServices.List(idList));
+        }
+        return Ok(await _levelServices.List());
     }
 
     [HttpGet("{id}")]
@@ -36,17 +39,23 @@ public async Task<IActionResult> GetLevel(Guid id)
     }
 
     [HttpPost]
-    public async Task<IActionResult> CreateLevel([FromBody] CreateLevelsController level)
+    public async Task<IActionResult> CreateLevel([FromBody] CreateLevelsRequest[] level)
     {
-        await _gameRepo.FoundOrThrowAsync(level.GameId, Constants.ENTITY.GAME + Constants.ERROR.NOT_EXIST_ERROR);
-        var newLevel = new LevelEntity();
-        Mapper.Map(level, newLevel);
-        await _levelServices.Create(newLevel);
-        return CreatedAtAction(nameof(GetLevel), new { id = newLevel.Id }, newLevel);
+        List<LevelEntity> levelList = new List<LevelEntity>();
+        foreach (var singleLevel in level)
+        {
+            await _gameRepo.FoundOrThrowAsync(singleLevel.GameId, Constants.ENTITY.GAME +"id " + singleLevel.GameId + " " + Constants.ERROR.NOT_EXIST_ERROR);
+            await _levelServices.CheckForDuplicateLevel(singleLevel.Name, singleLevel.GameId);
+            LevelEntity newLevel = new LevelEntity();
+            Mapper.Map(singleLevel, newLevel);
+            levelList.Add(newLevel);
+        }
+        await _levelServices.Create(levelList);
+        return CreatedAtAction(nameof(GetLevels), new { ids = levelList.Select(l => l.Id).ToList() }, level);
     }
 
     [HttpPut("{id}")]
-    public async Task<IActionResult> UpdateLevel(Guid id, [FromBody] UpdateLevelsController level)
+    public async Task<IActionResult> UpdateLevel(Guid id, [FromBody] UpdateLevelsRequest level)
     {
         var updateLevel = await _levelRepo.FoundOrThrowAsync(id, Constants.ENTITY.LEVEL + Constants.ERROR.NOT_EXIST_ERROR);
         Mapper.Map(level, updateLevel);
diff --git a/Api/Controllers/UsersController.cs b/Api/Controllers/UsersController.cs
index ff04535..a4daa92 100644
--- a/Api/Controllers/UsersController.cs
+++ b/Api/Controllers/UsersController.cs
@@ -3,6 +3,7 @@
 using Microsoft.AspNetCore.Mvc;
 using RepositoryLayer.Repositories;
 using ServiceLayer.Business;
+using System.Runtime.ConstrainedExecution;
 using WebApiLayer.UserFeatures.Requests;
 
 namespace WebApiLayer.Controllers;
@@ -11,24 +12,26 @@ namespace WebApiLayer.Controllers;
 public class UsersController : BaseController
 {
     private readonly IUserServices _userServices;
+    private readonly IGameUserServices _gameUserServices;
     private readonly IGenericRepository<UserEntity> _userRepo;
-    public UsersController(IUserServices userServices, IGenericRepository<UserEntity> userRepo)
+    private readonly IGenericRepository<GameUserEntity> _gameUserRepo;
+    public UsersController(IUserServices userServices, IGenericRepository<UserEntity> userRepo, IGameUserServices gameUserServices, IGenericRepository<GameUserEntity> gameUserRepo)
     {
         _userServices = userServices;
         _userRepo = userRepo;
+        _gameUserServices = gameUserServices;
+        _gameUserRepo = gameUserRepo;
     }
     [HttpGet]
     public async Task<IActionResult> GetUsers([FromQuery] string? email)
-    {
-        var users = await _userServices.List(email);
-        return Ok(users);
+    { 
+        return Ok(await _userServices.List(email));
     }
 
     [HttpGet("{id}")]
     public async Task<IActionResult> GetUser(Guid id)
     {
-        var user = await _userServices.GetById(id);
-        return Ok(user);
+        return Ok(await _userServices.GetById(id));
     }
 
     [HttpPost]
@@ -40,6 +43,17 @@ public async Task<IActionResult> CreateUser([FromBody] CreateUserRequest cUser)
         return CreatedAtAction(nameof(GetUser), new { id = user.Id }, user);
     }
 
+    [HttpPost("{id}/add-game")]
+    public async Task<IActionResult> CreateGameUser(Guid id, [FromQuery] Guid GameId)
+    {
+        var gameUser = new GameUserEntity {
+            UserId = id,
+            GameId = GameId
+        };
+        await _gameUserServices.Create(gameUser);
+        return CreatedAtAction(nameof(GetUser), new {id = id}, gameUser);
+    }
+
     [HttpPut("{id}")]
     public async Task<IActionResult> UpdateUser(Guid id, [FromBody] UpdateUserRequest user)
     {
@@ -56,4 +70,12 @@ public async Task<IActionResult> DeleteUser(Guid id)
         await _userServices.Delete(id);
         return NoContent();
     }
+
+    [HttpDelete("{id}/delete-game")]
+    public async Task<IActionResult> DeleteGameUser(Guid id)
+    {
+        await _gameUserRepo.FoundOrThrowAsync(id, Constants.ERROR.NOT_EXIST_ERROR);
+        await _gameUserServices.Delete(id);
+        return NoContent();
+    }
 }
\ No newline at end of file
diff --git a/Api/MockData/USER_MOCK_DATA.json b/Api/MockData/USER_MOCK_DATA.json
index addcf32..3cc959c 100644
--- a/Api/MockData/USER_MOCK_DATA.json
+++ b/Api/MockData/USER_MOCK_DATA.json
@@ -8,7 +8,7 @@
     "Email": "Keshaun.Stanton75@gmail.com",
     "Phone": "1-720-275-0500 x968",
     "Code": "Code 1",
-    "Status": 87806,
+    "Status": 0,
     "Balance": 49122,
     "id": "1"
   },
@@ -21,7 +21,7 @@
     "Email": "Alvena_Huel73@yahoo.com",
     "Phone": "283.583.2852",
     "Code": "Code 2",
-    "Status": 33835,
+    "Status": 1,
     "Balance": 44836,
     "id": "2"
   },
@@ -34,7 +34,7 @@
     "Email": "Drake79@hotmail.com",
     "Phone": "(371) 702-1711",
     "Code": "Code 3",
-    "Status": 73744,
+    "Status": 2,
     "Balance": 32726,
     "id": "3"
   },
@@ -47,7 +47,7 @@
     "Email": "Westley.Krajcik@yahoo.com",
     "Phone": "(308) 794-9029",
     "Code": "Code 4",
-    "Status": 36813,
+    "Status": 2,
     "Balance": 3817,
     "id": "4"
   },
@@ -60,7 +60,7 @@
     "Email": "Madisyn.Cassin@yahoo.com",
     "Phone": "850.222.8780 x8010",
     "Code": "Code 5",
-    "Status": 69677,
+    "Status": 0,
     "Balance": 63987,
     "id": "5"
   },
@@ -73,7 +73,7 @@
     "Email": "Mohamed11@gmail.com",
     "Phone": "1-322-329-9579 x701",
     "Code": "Code 6",
-    "Status": 39450,
+    "Status": 0,
     "Balance": 25724,
     "id": "6"
   },
@@ -86,7 +86,7 @@
     "Email": "Adela.Altenwerth33@yahoo.com",
     "Phone": "904.306.5271 x5346",
     "Code": "Code 7",
-    "Status": 66411,
+    "Status": 1,
     "Balance": 96593,
     "id": "7"
   },
@@ -99,7 +99,7 @@
     "Email": "Brandy69@yahoo.com",
     "Phone": "(786) 398-4085 x017",
     "Code": "Code 8",
-    "Status": 60715,
+    "Status": 2,
     "Balance": 78886,
     "id": "8"
   },
@@ -112,7 +112,7 @@
     "Email": "Flavio_Wiza@gmail.com",
     "Phone": "(780) 504-7257 x76176",
     "Code": "Code 9",
-    "Status": 80375,
+    "Status": 1,
     "Balance": 68874,
     "id": "9"
   },
@@ -125,7 +125,7 @@
     "Email": "Omer74@gmail.com",
     "Phone": "683-601-9692 x33962",
     "Code": "Code 10",
-    "Status": 16357,
+    "Status": 0,
     "Balance": 84492,
     "id": "10"
   },
@@ -138,7 +138,7 @@
     "Email": "Ozella.Okuneva@yahoo.com",
     "Phone": "1-375-231-9060 x731",
     "Code": "Code 11",
-    "Status": 77787,
+    "Status": 1,
     "Balance": 77924,
     "id": "11"
   },
@@ -151,7 +151,7 @@
     "Email": "Hosea.Wolff@yahoo.com",
     "Phone": "1-948-531-6755 x120",
     "Code": "Code 12",
-    "Status": 39001,
+    "Status": 2,
     "Balance": 75031,
     "id": "12"
   },
@@ -164,7 +164,7 @@
     "Email": "Audie_MacGyver@hotmail.com",
     "Phone": "1-201-890-9809 x8047",
     "Code": "Code 13",
-    "Status": 82234,
+    "Status": 0,
     "Balance": 87629,
     "id": "13"
   },
@@ -177,7 +177,7 @@
     "Email": "Julio_Cruickshank97@hotmail.com",
     "Phone": "1-496-899-2138 x387",
     "Code": "Code 14",
-    "Status": 74781,
+    "Status": 1,
     "Balance": 97454,
     "id": "14"
   },
@@ -190,7 +190,7 @@
     "Email": "Kailyn.Nader31@gmail.com",
     "Phone": "801-943-0306 x301",
     "Code": "Code 15",
-    "Status": 62733,
+    "Status": 2,
     "Balance": 32040,
     "id": "15"
   }
diff --git a/Api/UserFeatures/Requests/CreateLevelsController.cs b/Api/UserFeatures/Requests/CreateLevelsRequest.cs
similarity index 80%
rename from Api/UserFeatures/Requests/CreateLevelsController.cs
rename to Api/UserFeatures/Requests/CreateLevelsRequest.cs
index b913bf2..085bd98 100644
--- a/Api/UserFeatures/Requests/CreateLevelsController.cs
+++ b/Api/UserFeatures/Requests/CreateLevelsRequest.cs
@@ -4,7 +4,7 @@
 
 namespace WebApiLayer.UserFeatures.Requests
 {
-    public class CreateLevelsController : IMapTo<LevelEntity>, IMapFrom<LevelEntity>
+    public class CreateLevelsRequest : IMapTo<LevelEntity>, IMapFrom<LevelEntity>
     {
         [Required]
         public string Name { get; set; }
diff --git a/Api/UserFeatures/Requests/CreateUserRequest.cs b/Api/UserFeatures/Requests/CreateUserRequest.cs
index 57e5344..a54da35 100644
--- a/Api/UserFeatures/Requests/CreateUserRequest.cs
+++ b/Api/UserFeatures/Requests/CreateUserRequest.cs
@@ -10,6 +10,8 @@ public class CreateUserRequest : IMapTo<UserEntity>
         [Required]
         public string Username { get; set; }
         [Required]
+        public string Uid { get; set; }
+        [Required]
         public string Password { get; set; }
         [Required]
         public string FirstName { get; set; }
@@ -23,5 +25,6 @@ public class CreateUserRequest : IMapTo<UserEntity>
         [Required]
         [RegularExpression(@"^(03|05|07|08|09)\d{8}$", ErrorMessage = "Invalid phone number")]
         public string Phone { get; set; }
+        public Guid? GameId { get; set; }
     }
 }
diff --git a/Api/UserFeatures/Requests/UpdateLevelsController.cs b/Api/UserFeatures/Requests/UpdateLevelsRequest.cs
similarity index 74%
rename from Api/UserFeatures/Requests/UpdateLevelsController.cs
rename to Api/UserFeatures/Requests/UpdateLevelsRequest.cs
index ed18cd0..f3bd445 100644
--- a/Api/UserFeatures/Requests/UpdateLevelsController.cs
+++ b/Api/UserFeatures/Requests/UpdateLevelsRequest.cs
@@ -4,7 +4,7 @@
 
 namespace WebApiLayer.UserFeatures.Requests
 {
-    public class UpdateLevelsController : IMapTo<LevelEntity>, IMapFrom<LevelEntity>
+    public class UpdateLevelsRequest : IMapTo<LevelEntity>, IMapFrom<LevelEntity>
     {
         public string? Name { get; set; }
         public int? LevelUpPoint { get; set; }
diff --git a/Api/UserFeatures/Requests/UpdateUserRequest.cs b/Api/UserFeatures/Requests/UpdateUserRequest.cs
index 7b85ada..965f561 100644
--- a/Api/UserFeatures/Requests/UpdateUserRequest.cs
+++ b/Api/UserFeatures/Requests/UpdateUserRequest.cs
@@ -16,5 +16,8 @@ public class UpdateUserRequest : IMapTo<UserEntity>
         public string? Email { get; set; }
         [RegularExpression(@"^(03|05|07|08|09)\d{8}$", ErrorMessage = "Invalid phone number")]
         public string? Phone { get; set; }
+        [Range(0,2)]
+        public int? Status { get; set; }
+        public Guid? GameId { get; set; }
     }
 }
diff --git a/Application/Business/ActivityType/ActivityTypeServices.cs b/Application/Business/ActivityType/ActivityTypeServices.cs
index 1019cf9..3f38d0e 100644
--- a/Application/Business/ActivityType/ActivityTypeServices.cs
+++ b/Application/Business/ActivityType/ActivityTypeServices.cs
@@ -20,11 +20,11 @@ public async Task<ActivityTypeEntity> GetById(Guid activityTypeId)
     {
         return await _activityTypeRepo.FoundOrThrowAsync(activityTypeId, Constants.ENTITY.ACTIVITY_TYPE + Constants.ERROR.NOT_EXIST_ERROR);
     }
-    public async Task<ICollection<ActivityTypeEntity>> GetByGameId(Guid gameid)
+    public async Task<ICollection<ActivityTypeEntity>> ListActTypesByGameId(Guid gameid)
     {
         return await _activityTypeRepo.WhereAsync(a => a.GameId.Equals(gameid));
     }
-    public async Task<ICollection<ActivityTypeEntity>> GetByCharacterId(Guid characterid)
+    public async Task<ICollection<ActivityTypeEntity>> ListActTypesByCharId(Guid characterid)
     {
         return await _activityTypeRepo.WhereAsync(a => a.CharacterId.Equals(characterid));
     }
diff --git a/Application/Business/ActivityType/IActivityTypeServices.cs b/Application/Business/ActivityType/IActivityTypeServices.cs
index f7ec2a0..83dbc9d 100644
--- a/Application/Business/ActivityType/IActivityTypeServices.cs
+++ b/Application/Business/ActivityType/IActivityTypeServices.cs
@@ -6,8 +6,8 @@ public interface IActivityTypeServices
 {
     Task<ICollection<ActivityTypeEntity>> List();
     Task<ActivityTypeEntity> GetById(Guid activityTypeId);
-    Task<ICollection<ActivityTypeEntity>> GetByGameId(Guid id);
-    Task<ICollection<ActivityTypeEntity>> GetByCharacterId(Guid id);
+    Task<ICollection<ActivityTypeEntity>> ListActTypesByGameId(Guid id);
+    Task<ICollection<ActivityTypeEntity>> ListActTypesByCharId(Guid id);
     Task<int> Count();
     Task Create(ActivityTypeEntity activityType);
     Task Update(ActivityTypeEntity activityType);
diff --git a/Application/Business/AssetType/AssetTypeServices.cs b/Application/Business/AssetType/AssetTypeServices.cs
index c642d94..4e59be2 100644
--- a/Application/Business/AssetType/AssetTypeServices.cs
+++ b/Application/Business/AssetType/AssetTypeServices.cs
@@ -21,7 +21,7 @@ public async Task<AssetTypeEntity> GetById(Guid assetTypeId)
     {
         return await _assetTypeRepo.FoundOrThrowAsync(assetTypeId, Constants.ENTITY.ASSET_ATTRIBUTE + Constants.ERROR.NOT_EXIST_ERROR);
     }
-    public async Task<ICollection<AssetTypeEntity>> GetByGameId(Guid gameId)
+    public async Task<ICollection<AssetTypeEntity>> ListAssTypesByGameId(Guid gameId)
     {
         return await _assetTypeRepo.WhereAsync(
             a => a.GameId.Equals(gameId));
diff --git a/Application/Business/AssetType/IAssetTypeServices.cs b/Application/Business/AssetType/IAssetTypeServices.cs
index e9ffc46..6ce54aa 100644
--- a/Application/Business/AssetType/IAssetTypeServices.cs
+++ b/Application/Business/AssetType/IAssetTypeServices.cs
@@ -6,7 +6,7 @@ public interface IAssetTypeServices
 {
     Task<ICollection<AssetTypeEntity>> List();
     Task<AssetTypeEntity> GetById(Guid assetTypeId);
-    Task<ICollection<AssetTypeEntity>> GetByGameId(Guid gameId);
+    Task<ICollection<AssetTypeEntity>> ListAssTypesByGameId(Guid gameId);
     Task<int> Count();
     Task Create(AssetTypeEntity assetType);
     Task Update(AssetTypeEntity assetType);
diff --git a/Application/Business/CharacterType/CharacterTypeServices.cs b/Application/Business/CharacterType/CharacterTypeServices.cs
index e7ec7e2..e98f5b6 100644
--- a/Application/Business/CharacterType/CharacterTypeServices.cs
+++ b/Application/Business/CharacterType/CharacterTypeServices.cs
@@ -24,7 +24,7 @@ public async Task<CharacterTypeEntity> GetById(Guid characterTypeId)
         return await _characterTypeRepo.FoundOrThrowAsync(characterTypeId,
             Constants.ENTITY.CHARACTER_TYPE + Constants.ERROR.NOT_EXIST_ERROR);
     }
-    public async Task<ICollection<CharacterTypeEntity>> GetByGameId(Guid gameId)
+    public async Task<ICollection<CharacterTypeEntity>> ListCharTypesByGameId(Guid gameId)
     {
         return await _characterTypeRepo.WhereAsync(c => c.GameId.Equals(gameId));
     }
diff --git a/Application/Business/CharacterType/ICharacterTypeServices.cs b/Application/Business/CharacterType/ICharacterTypeServices.cs
index 838bb0a..f3e52db 100644
--- a/Application/Business/CharacterType/ICharacterTypeServices.cs
+++ b/Application/Business/CharacterType/ICharacterTypeServices.cs
@@ -6,7 +6,7 @@ public interface ICharacterTypeServices
 {
     Task<ICollection<CharacterTypeEntity>> List();
     Task<CharacterTypeEntity> GetById(Guid characterTypeId);
-    Task<ICollection<CharacterTypeEntity>> GetByGameId(Guid gameId);
+    Task<ICollection<CharacterTypeEntity>> ListCharTypesByGameId(Guid gameId);
     Task<int> Count();
     Task Create(CharacterTypeEntity characterType);
     Task Update(CharacterTypeEntity characterType);
diff --git a/Application/Business/GameServer/GameServerServices.cs b/Application/Business/GameServer/GameServerServices.cs
index 52653e8..85b9a0c 100644
--- a/Application/Business/GameServer/GameServerServices.cs
+++ b/Application/Business/GameServer/GameServerServices.cs
@@ -23,7 +23,7 @@ public async Task<GameServerEntity> GetById(Guid gameServerId)
         return await _gameServerRepo.FoundOrThrowAsync(gameServerId,
             Constants.ENTITY.GAME_SERVER + Constants.ERROR.NOT_EXIST_ERROR);
     }
-    public async Task<ICollection<GameServerEntity>> GetByGameId(Guid gameId)
+    public async Task<ICollection<GameServerEntity>> ListServersByGameId(Guid gameId)
     {
         return await _gameServerRepo.WhereAsync(g => g.GameId.Equals(gameId));
     }
diff --git a/Application/Business/GameServer/IGameServerServices.cs b/Application/Business/GameServer/IGameServerServices.cs
index 1e053d3..5fc2b9d 100644
--- a/Application/Business/GameServer/IGameServerServices.cs
+++ b/Application/Business/GameServer/IGameServerServices.cs
@@ -5,7 +5,7 @@ public interface IGameServerServices
 {
     Task<ICollection<GameServerEntity>> List();
     Task<GameServerEntity> GetById(Guid gameServerId);
-    Task<ICollection<GameServerEntity>> GetByGameId(Guid gameId);
+    Task<ICollection<GameServerEntity>> ListServersByGameId(Guid gameId);
     Task<int> Count();
     Task Create(GameServerEntity gameServer);
     Task Update(GameServerEntity gameServer);
diff --git a/Application/Business/GameUserServices/GameUserServices.cs b/Application/Business/GameUserServices/GameUserServices.cs
new file mode 100644
index 0000000..332f636
--- /dev/null
+++ b/Application/Business/GameUserServices/GameUserServices.cs
@@ -0,0 +1,54 @@
+using AutoWrapper.Filters;
+using DomainLayer.Constants;
+using DomainLayer.Entities;
+using DomainLayer.Exceptions;
+using Microsoft.EntityFrameworkCore;
+using RepositoryLayer.Contexts;
+using RepositoryLayer.Repositories;
+using System.Collections.Generic;
+using System;
+
+namespace ServiceLayer.Business;
+
+public class GameUserServices : IGameUserServices
+{
+    public readonly IGenericRepository<GameUserEntity> _gameUserRepo;
+    public readonly IGenericRepository<GameEntity> _gameRepo;
+    public readonly IGenericRepository<UserEntity> _userRepo;
+    public GameUserServices(IGenericRepository<GameUserEntity> gameUserRepo, IGenericRepository<GameEntity> gameRepo, IGenericRepository<UserEntity> userRepo)
+    {
+        _gameUserRepo = gameUserRepo;
+        _gameRepo = gameRepo;
+        _userRepo = userRepo;
+    }
+    public async Task<ICollection<GameUserEntity>> List()
+    {
+        var list = await _gameUserRepo.ListAsync();
+        return list;
+    }
+    public async Task<List<UserEntity>> ListUsersByGameId(Guid id)
+    {
+        var game = await _gameUserRepo.WhereAsync(gu => gu.GameId == id,new string[] {"User"});
+        return game.Select(g => g.User).ToList();
+    }
+    public async Task Create(GameUserEntity gameUser)
+    {
+        await CheckDuplicateGameAndUser(gameUser);
+        await _gameUserRepo.CreateAsync(gameUser);
+    }
+    public async Task Delete(Guid id)
+    {
+        var gameUser = await _gameUserRepo.FoundOrThrowAsync(id);
+        await _gameUserRepo.DeleteAsync(gameUser);
+    }
+
+    public async Task CheckDuplicateGameAndUser(GameUserEntity gu)
+    {
+        var checkGameUser = await _gameUserRepo.FirstOrDefaultAsync(
+            guser => guser.GameId.Equals(gu.GameId) && guser.UserId.Equals(gu.UserId));
+        if (checkGameUser is not null)
+        {
+            throw new BadRequestException("This user is " + Constants.ERROR.ALREADY_EXIST_ERROR + " in this game");
+        }
+    }
+}
\ No newline at end of file
diff --git a/Application/Business/GameUserServices/IGameUserServices.cs b/Application/Business/GameUserServices/IGameUserServices.cs
new file mode 100644
index 0000000..ae85584
--- /dev/null
+++ b/Application/Business/GameUserServices/IGameUserServices.cs
@@ -0,0 +1,10 @@
+using DomainLayer.Entities;
+
+namespace ServiceLayer.Business;
+public interface IGameUserServices
+{
+    Task<ICollection<GameUserEntity>> List();
+    Task<List<UserEntity>> ListUsersByGameId(Guid id);
+    Task Create(GameUserEntity user);
+    Task Delete(Guid id);
+}
diff --git a/Application/Business/LevelServices/ILevelServices.cs b/Application/Business/LevelServices/ILevelServices.cs
index 52f22d6..e5d532c 100644
--- a/Application/Business/LevelServices/ILevelServices.cs
+++ b/Application/Business/LevelServices/ILevelServices.cs
@@ -5,10 +5,12 @@ public interface ILevelServices
 {
     Task<ICollection<LevelEntity>> List();
     Task<LevelEntity> GetById(Guid levelId);
-    Task<ICollection<LevelEntity>> GetByGameId(Guid gameId);
+    Task<ICollection<LevelEntity>> List(Guid[] levelIds);
+    Task<ICollection<LevelEntity>> ListLevelsByGameId(Guid gameId);
     Task<int> Count();
     Task<int> Count(Guid GameId); // Count levels in 1 game
-    Task Create(LevelEntity level);
+    Task Create(List<LevelEntity> level);
     Task Update(LevelEntity level);
     Task Delete(Guid levelId);
+    Task CheckForDuplicateLevel(string name, Guid GameId, Guid? id = null);
 }
diff --git a/Application/Business/LevelServices/LevelServices.cs b/Application/Business/LevelServices/LevelServices.cs
index c9fb7cf..242969c 100644
--- a/Application/Business/LevelServices/LevelServices.cs
+++ b/Application/Business/LevelServices/LevelServices.cs
@@ -2,6 +2,7 @@
 using DomainLayer.Entities;
 using DomainLayer.Exceptions;
 using RepositoryLayer.Repositories;
+using System.Security.Cryptography;
 
 namespace ServiceLayer.Business;
 
@@ -21,7 +22,12 @@ public async Task<LevelEntity> GetById(Guid levelId)
         return await _levelRepo.FoundOrThrowAsync(levelId,
             Constants.ENTITY.LEVEL + Constants.ERROR.NOT_EXIST_ERROR);
     }
-    public async Task<ICollection<LevelEntity>> GetByGameId(Guid gameId)
+    public async Task<ICollection<LevelEntity>> List(Guid[] levelIds)
+    {
+        var levels = await _levelRepo.WhereAsync(level => levelIds.Contains(level.Id));
+        return levels;
+    }
+    public async Task<ICollection<LevelEntity>> ListLevelsByGameId(Guid gameId)
     {
         return await _levelRepo.WhereAsync(l => l.GameId.Equals(gameId));
     }
@@ -34,26 +40,25 @@ public async Task<int> Count(Guid gameId)
         var levels = await _levelRepo.WhereAsync(l => l.GameId.Equals(gameId));
         return levels.Count();
     }
-    public async Task Create(LevelEntity level)
+    public async Task Create(List<LevelEntity> level)
     {
-        await CheckForDuplicateLevel(level);
-        await _levelRepo.CreateAsync(level);
+        await _levelRepo.CreateRangeAsync(level);
     }
     public async Task Update(LevelEntity level)
     {
-        await CheckForDuplicateLevel(level);
+        await CheckForDuplicateLevel(level.Name, level.GameId, level.Id);
         await _levelRepo.UpdateAsync(level);
     }
     public async Task Delete(Guid levelId)
     {
         await _levelRepo.DeleteSoftAsync(levelId);
     }
-    public async Task CheckForDuplicateLevel(LevelEntity level)
+    public async Task CheckForDuplicateLevel(string name, Guid GameId, Guid? id = null)
     {
-        var levelCheck = await _levelRepo.FirstOrDefaultAsync(l => l.Name == level.Name && l.GameId == level.GameId);
+        var levelCheck = await _levelRepo.FirstOrDefaultAsync(l => l.Name == name && l.GameId == GameId);
         if (levelCheck is not null)
         {
-            if (level.Id == Guid.Empty || levelCheck.Id != level.Id)
+            if (!id.HasValue || levelCheck.Id != id)
             {
                 throw new BadRequestException(Constants.ENTITY.LEVEL + Constants.ERROR.ALREADY_EXIST_ERROR);
             }
diff --git a/Application/Business/UserServices/UserServices.cs b/Application/Business/UserServices/UserServices.cs
index f5cb7e1..c508578 100644
--- a/Application/Business/UserServices/UserServices.cs
+++ b/Application/Business/UserServices/UserServices.cs
@@ -8,17 +8,21 @@ namespace ServiceLayer.Business;
 
 public class UserServices : IUserServices
 {
-    public readonly IGenericRepository<UserEntity> _userRepo;
-    public UserServices(IGenericRepository<UserEntity> userRepo)
+    private readonly IGenericRepository<UserEntity> _userRepo;
+    private readonly IGenericRepository<GameUserEntity> _gameUserRepo;
+    private readonly IGenericRepository<GameEntity> _gameRepo;
+    public UserServices(IGenericRepository<UserEntity> userRepo, IGenericRepository<GameUserEntity> gameUserRepo
+        , IGenericRepository<GameEntity> gameRepo)
     {
         _userRepo = userRepo;
+        _gameUserRepo = gameUserRepo;
+        _gameRepo = gameRepo;
     }
     public async Task<ICollection<UserEntity>> List(string? email)
     {
         if (!string.IsNullOrEmpty(email))
         {
-            var user = await _userRepo.WhereAsync(u => u.Email.Equals(email));
-            return user;
+            return await _userRepo.WhereAsync(u => u.Email.Equals(email));
         }
         return await _userRepo.ListAsync();
     }
diff --git a/Application/Business/WalletCategory/IWalletCategoryServices.cs b/Application/Business/WalletCategory/IWalletCategoryServices.cs
index 59a2f95..f672074 100644
--- a/Application/Business/WalletCategory/IWalletCategoryServices.cs
+++ b/Application/Business/WalletCategory/IWalletCategoryServices.cs
@@ -5,7 +5,7 @@ public interface IWalletCategoryServices
 {
     Task<ICollection<WalletCategoryEntity>> List();
     Task<WalletCategoryEntity> GetById(Guid categoryId);
-    Task<ICollection<WalletCategoryEntity>> GetByGameId(Guid gameId);
+    Task<ICollection<WalletCategoryEntity>> ListWalCatsByGameId(Guid gameId);
     Task<int> Count();
     Task Create(WalletCategoryEntity walletCategory);
     Task Update(WalletCategoryEntity walletCategory);
diff --git a/Application/Business/WalletCategory/WalletCategoryServices.cs b/Application/Business/WalletCategory/WalletCategoryServices.cs
index 565ada5..b01f757 100644
--- a/Application/Business/WalletCategory/WalletCategoryServices.cs
+++ b/Application/Business/WalletCategory/WalletCategoryServices.cs
@@ -21,7 +21,7 @@ public async Task<WalletCategoryEntity> GetById(Guid categoryId)
         return await _walletCategoryRepo.FoundOrThrowAsync(categoryId,
            Constants.ENTITY.WALLET_CATEGORY + Constants.ERROR.NOT_EXIST_ERROR);
     }
-    public async Task<ICollection<WalletCategoryEntity>> GetByGameId(Guid gameId)
+    public async Task<ICollection<WalletCategoryEntity>> ListWalCatsByGameId(Guid gameId)
     {
         return await _walletCategoryRepo.WhereAsync(wc => wc.GameId.Equals(gameId));
     }
diff --git a/Domain/Entities/GameEntity.cs b/Domain/Entities/GameEntity.cs
index 9b6d0c1..643cda7 100644
--- a/Domain/Entities/GameEntity.cs
+++ b/Domain/Entities/GameEntity.cs
@@ -8,8 +8,6 @@ public class GameEntity : BaseEntity
     public string Name { get; set; }
     public string Logo { get; set; }
     public string Link { get; set; }
-    // M Users - M Games
-    public virtual ICollection<UserEntity>? Users { get; set; }
     // 1 Game - M Activity Type
     public virtual ICollection<ActivityTypeEntity>? ActivityTypes { get; set; }
     // M Game - M Attribute Group
diff --git a/Domain/Entities/GameUserEntity.cs b/Domain/Entities/GameUserEntity.cs
new file mode 100644
index 0000000..f0ffb4c
--- /dev/null
+++ b/Domain/Entities/GameUserEntity.cs
@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DomainLayer.Entities;
+
+[Table("GameUserEntity")]
+public class GameUserEntity : BaseEntity
+{
+    public GameEntity Game { get; set; }
+    public Guid GameId { get; set; }
+    public UserEntity User { get; set; }
+    public Guid UserId { get; set; }
+}
diff --git a/Domain/Entities/UserEntity.cs b/Domain/Entities/UserEntity.cs
index 1d659da..5d26611 100644
--- a/Domain/Entities/UserEntity.cs
+++ b/Domain/Entities/UserEntity.cs
@@ -15,8 +15,6 @@ public class UserEntity : BaseEntity
     public string Code { get; set; } = "";
     public int Status { get; set; } = 0;
     public float Balance { get; set; } = 0;
-    // M User - M Games
-    public virtual ICollection<GameEntity>? Games { get; set; }
     // 1 User - M Characters
     public virtual ICollection<CharacterEntity>? Characters { get; set; }
     //1 User - M Payment
diff --git a/Infrastructure/Contexts/DbContext/ApplicationDbContext.cs b/Infrastructure/Contexts/DbContext/ApplicationDbContext.cs
index a6fa898..0404dd7 100644
--- a/Infrastructure/Contexts/DbContext/ApplicationDbContext.cs
+++ b/Infrastructure/Contexts/DbContext/ApplicationDbContext.cs
@@ -30,6 +30,7 @@ protected override void OnModelCreating(ModelBuilder modelBuilder)
     public DbSet<CharacterEntity> Characters { get; set; }
     public DbSet<CharacterTypeEntity> CharacterTypes { get; set; }
     public DbSet<GameEntity> Games { get; set; }
+    public DbSet<GameUserEntity> GamesUsers { get; set; }
     public DbSet<GameServerEntity> GameServers { get; set; }
     public DbSet<LevelEntity> Levels { get; set; }
     public DbSet<LevelProgressEntity> LevelProgresses { get; set; }
diff --git a/Infrastructure/Contexts/DbContext/IApplicationDbContext.cs b/Infrastructure/Contexts/DbContext/IApplicationDbContext.cs
index 6c11073..01fd94d 100644
--- a/Infrastructure/Contexts/DbContext/IApplicationDbContext.cs
+++ b/Infrastructure/Contexts/DbContext/IApplicationDbContext.cs
@@ -16,6 +16,7 @@ public interface IApplicationDbContext
     public DbSet<CharacterEntity> Characters { get; set; }
     public DbSet<CharacterTypeEntity> CharacterTypes { get; set; }
     public DbSet<GameEntity> Games { get; set; }
+    public DbSet<GameUserEntity> GamesUsers { get; set; }
     public DbSet<GameServerEntity> GameServers { get; set; }
     public DbSet<LevelEntity> Levels { get; set; }
     public DbSet<LevelProgressEntity> LevelProgresses { get; set; }
diff --git a/Infrastructure/Migrations/20231120171446_Update_New_Database.Designer.cs b/Infrastructure/Migrations/20231120171446_Update_New_Database.Designer.cs
new file mode 100644
index 0000000..6b34c4d
--- /dev/null
+++ b/Infrastructure/Migrations/20231120171446_Update_New_Database.Designer.cs
@@ -0,0 +1,1175 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using RepositoryLayer.Contexts;
+
+#nullable disable
+
+namespace RepositoryLayer.Migrations
+{
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20231120171446_Update_New_Database")]
+    partial class Update_New_Database
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "6.0.5")
+                .HasAnnotation("Relational:MaxIdentifierLength", 128);
+
+            SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder, 1L, 1);
+
+            modelBuilder.Entity("AttributeGroupEntityGameEntity", b =>
+                {
+                    b.Property<Guid>("AttributeGroupsId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("GamesId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("AttributeGroupsId", "GamesId");
+
+                    b.HasIndex("GamesId");
+
+                    b.ToTable("AttributeGroupEntityGameEntity");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.ActivityEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("ActivityTypeId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("CharacterId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("int");
+
+                    b.Property<Guid>("TransactionId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ActivityTypeId");
+
+                    b.HasIndex("CharacterId");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.HasIndex("TransactionId");
+
+                    b.ToTable("Activity");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.ActivityTypeEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("CharacterId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<Guid>("GameId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CharacterId");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.HasIndex("GameId");
+
+                    b.ToTable("ActivityType");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.AssetAttributeEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("AssetId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("AttributeGroupId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("Value")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetId");
+
+                    b.HasIndex("AttributeGroupId");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.ToTable("AssetAttribute");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.AssetEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("AssetTypeId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Image")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetTypeId");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.ToTable("Asset");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.AssetTypeEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<Guid>("GameId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.HasIndex("GameId");
+
+                    b.ToTable("AssetType");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.AttributeGroupEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Effect")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.ToTable("AttributeGroup");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.CharacterAssetEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("AssetsId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("CharacterId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime>("ExpiredDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("Value")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetsId");
+
+                    b.HasIndex("CharacterId");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.ToTable("CharacterAsset");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.CharacterAttributeEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("AttributeGroupId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("CharacterId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("Value")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AttributeGroupId");
+
+                    b.HasIndex("CharacterId");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.ToTable("CharacterAttribute");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.CharacterEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("CharacterTypeId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CurrentProperty")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<Guid>("GameServerId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("PointReward")
+                        .HasColumnType("int");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CharacterTypeId");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.HasIndex("GameServerId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Character");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.CharacterTypeEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("BaseProperties")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid>("GameId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.HasIndex("GameId");
+
+                    b.ToTable("CharacterType");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.GameEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Link")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Logo")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.ToTable("Game");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.GameServerEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("ArtifactUrl")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<Guid>("GameId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("Location")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.HasIndex("GameId");
+
+                    b.ToTable("GameServer");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.GameUserEntity", b =>
+                {
+                    b.Property<Guid>("GameId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasIndex("GameId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("GameUserEntity");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.LevelEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<Guid>("GameId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("LevelUpPoint")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.HasIndex("GameId");
+
+                    b.ToTable("Level");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.LevelProgressEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("CharacterId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("ExpPoint")
+                        .HasColumnType("int");
+
+                    b.Property<Guid>("LevelId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("LevelUpDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CharacterId");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.HasIndex("LevelId")
+                        .IsUnique();
+
+                    b.ToTable("LevelProgress");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.PaymentEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("Amount")
+                        .HasColumnType("int");
+
+                    b.Property<string>("BankCode")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid>("CharacterId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("Content")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime>("Date")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("WalletId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CharacterId");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("WalletId")
+                        .IsUnique();
+
+                    b.ToTable("Payment");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.TransactionEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<float>("Value")
+                        .HasColumnType("real");
+
+                    b.Property<Guid>("WalletId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.HasIndex("WalletId");
+
+                    b.ToTable("Transaction");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.UserEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("Avatar")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<float>("Balance")
+                        .HasColumnType("real");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Email")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FirstName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("LastName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Phone")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Uid")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.ToTable("User");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.WalletCategoryEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<Guid>("GameId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.HasIndex("GameId");
+
+                    b.ToTable("WalletCategory");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.WalletEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("CharacterId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<float>("TotalMoney")
+                        .HasColumnType("real");
+
+                    b.Property<Guid>("WalletCategoryId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CharacterId");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.HasIndex("WalletCategoryId");
+
+                    b.ToTable("Wallet");
+                });
+
+            modelBuilder.Entity("GameEntityUserEntity", b =>
+                {
+                    b.Property<Guid>("GamesId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("UsersId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("GamesId", "UsersId");
+
+                    b.HasIndex("UsersId");
+
+                    b.ToTable("GameEntityUserEntity", (string)null);
+                });
+
+            modelBuilder.Entity("AttributeGroupEntityGameEntity", b =>
+                {
+                    b.HasOne("DomainLayer.Entities.AttributeGroupEntity", null)
+                        .WithMany()
+                        .HasForeignKey("AttributeGroupsId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("DomainLayer.Entities.GameEntity", null)
+                        .WithMany()
+                        .HasForeignKey("GamesId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.ActivityEntity", b =>
+                {
+                    b.HasOne("DomainLayer.Entities.ActivityTypeEntity", "ActivityType")
+                        .WithMany()
+                        .HasForeignKey("ActivityTypeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("DomainLayer.Entities.CharacterEntity", "Character")
+                        .WithMany()
+                        .HasForeignKey("CharacterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("DomainLayer.Entities.TransactionEntity", "Transaction")
+                        .WithMany("Activities")
+                        .HasForeignKey("TransactionId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.Navigation("ActivityType");
+
+                    b.Navigation("Character");
+
+                    b.Navigation("Transaction");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.ActivityTypeEntity", b =>
+                {
+                    b.HasOne("DomainLayer.Entities.CharacterEntity", "Character")
+                        .WithMany()
+                        .HasForeignKey("CharacterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("DomainLayer.Entities.GameEntity", "Game")
+                        .WithMany("ActivityTypes")
+                        .HasForeignKey("GameId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.Navigation("Character");
+
+                    b.Navigation("Game");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.AssetAttributeEntity", b =>
+                {
+                    b.HasOne("DomainLayer.Entities.AssetEntity", "Asset")
+                        .WithMany()
+                        .HasForeignKey("AssetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("DomainLayer.Entities.AttributeGroupEntity", "AttributeGroup")
+                        .WithMany()
+                        .HasForeignKey("AttributeGroupId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Asset");
+
+                    b.Navigation("AttributeGroup");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.AssetEntity", b =>
+                {
+                    b.HasOne("DomainLayer.Entities.AssetTypeEntity", "AssetType")
+                        .WithMany()
+                        .HasForeignKey("AssetTypeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("AssetType");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.AssetTypeEntity", b =>
+                {
+                    b.HasOne("DomainLayer.Entities.GameEntity", "Game")
+                        .WithMany()
+                        .HasForeignKey("GameId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Game");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.CharacterAssetEntity", b =>
+                {
+                    b.HasOne("DomainLayer.Entities.AssetEntity", "Assets")
+                        .WithMany()
+                        .HasForeignKey("AssetsId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("DomainLayer.Entities.CharacterEntity", "Characters")
+                        .WithMany("CharacterAssets")
+                        .HasForeignKey("CharacterId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.Navigation("Assets");
+
+                    b.Navigation("Characters");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.CharacterAttributeEntity", b =>
+                {
+                    b.HasOne("DomainLayer.Entities.AttributeGroupEntity", "AttributeGroup")
+                        .WithMany()
+                        .HasForeignKey("AttributeGroupId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("DomainLayer.Entities.CharacterEntity", "Character")
+                        .WithMany()
+                        .HasForeignKey("CharacterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("AttributeGroup");
+
+                    b.Navigation("Character");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.CharacterEntity", b =>
+                {
+                    b.HasOne("DomainLayer.Entities.CharacterTypeEntity", "CharacterType")
+                        .WithMany()
+                        .HasForeignKey("CharacterTypeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("DomainLayer.Entities.GameServerEntity", "GameServer")
+                        .WithMany("Characters")
+                        .HasForeignKey("GameServerId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("DomainLayer.Entities.UserEntity", "User")
+                        .WithMany("Characters")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.Navigation("CharacterType");
+
+                    b.Navigation("GameServer");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.CharacterTypeEntity", b =>
+                {
+                    b.HasOne("DomainLayer.Entities.GameEntity", "Game")
+                        .WithMany()
+                        .HasForeignKey("GameId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Game");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.GameServerEntity", b =>
+                {
+                    b.HasOne("DomainLayer.Entities.GameEntity", "Game")
+                        .WithMany()
+                        .HasForeignKey("GameId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Game");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.GameUserEntity", b =>
+                {
+                    b.HasOne("DomainLayer.Entities.GameEntity", "Game")
+                        .WithMany()
+                        .HasForeignKey("GameId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("DomainLayer.Entities.UserEntity", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Game");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.LevelEntity", b =>
+                {
+                    b.HasOne("DomainLayer.Entities.GameEntity", "Game")
+                        .WithMany()
+                        .HasForeignKey("GameId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Game");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.LevelProgressEntity", b =>
+                {
+                    b.HasOne("DomainLayer.Entities.CharacterEntity", "Character")
+                        .WithMany()
+                        .HasForeignKey("CharacterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("DomainLayer.Entities.LevelEntity", "Level")
+                        .WithOne("LevelProgress")
+                        .HasForeignKey("DomainLayer.Entities.LevelProgressEntity", "LevelId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.Navigation("Character");
+
+                    b.Navigation("Level");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.PaymentEntity", b =>
+                {
+                    b.HasOne("DomainLayer.Entities.CharacterEntity", "Character")
+                        .WithMany()
+                        .HasForeignKey("CharacterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("DomainLayer.Entities.UserEntity", "User")
+                        .WithMany("Payments")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("DomainLayer.Entities.WalletEntity", "Wallet")
+                        .WithOne("Payment")
+                        .HasForeignKey("DomainLayer.Entities.PaymentEntity", "WalletId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.Navigation("Character");
+
+                    b.Navigation("User");
+
+                    b.Navigation("Wallet");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.TransactionEntity", b =>
+                {
+                    b.HasOne("DomainLayer.Entities.WalletEntity", "Wallet")
+                        .WithMany()
+                        .HasForeignKey("WalletId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Wallet");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.WalletCategoryEntity", b =>
+                {
+                    b.HasOne("DomainLayer.Entities.GameEntity", "Game")
+                        .WithMany()
+                        .HasForeignKey("GameId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Game");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.WalletEntity", b =>
+                {
+                    b.HasOne("DomainLayer.Entities.CharacterEntity", "Character")
+                        .WithMany()
+                        .HasForeignKey("CharacterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("DomainLayer.Entities.WalletCategoryEntity", "WalletCategory")
+                        .WithMany("WalletEntities")
+                        .HasForeignKey("WalletCategoryId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.Navigation("Character");
+
+                    b.Navigation("WalletCategory");
+                });
+
+            modelBuilder.Entity("GameEntityUserEntity", b =>
+                {
+                    b.HasOne("DomainLayer.Entities.GameEntity", null)
+                        .WithMany()
+                        .HasForeignKey("GamesId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("DomainLayer.Entities.UserEntity", null)
+                        .WithMany()
+                        .HasForeignKey("UsersId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.CharacterEntity", b =>
+                {
+                    b.Navigation("CharacterAssets");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.GameEntity", b =>
+                {
+                    b.Navigation("ActivityTypes");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.GameServerEntity", b =>
+                {
+                    b.Navigation("Characters");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.LevelEntity", b =>
+                {
+                    b.Navigation("LevelProgress")
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.TransactionEntity", b =>
+                {
+                    b.Navigation("Activities");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.UserEntity", b =>
+                {
+                    b.Navigation("Characters");
+
+                    b.Navigation("Payments");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.WalletCategoryEntity", b =>
+                {
+                    b.Navigation("WalletEntities");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.WalletEntity", b =>
+                {
+                    b.Navigation("Payment")
+                        .IsRequired();
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/Infrastructure/Migrations/20231120171446_Update_New_Database.cs b/Infrastructure/Migrations/20231120171446_Update_New_Database.cs
new file mode 100644
index 0000000..88b5baf
--- /dev/null
+++ b/Infrastructure/Migrations/20231120171446_Update_New_Database.cs
@@ -0,0 +1,52 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace RepositoryLayer.Migrations
+{
+    public partial class Update_New_Database : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "GameUserEntity",
+                columns: table => new
+                {
+                    GameId = table.Column<Guid>(type: "uniqueidentifier", nullable: false),
+                    UserId = table.Column<Guid>(type: "uniqueidentifier", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.ForeignKey(
+                        name: "FK_GameUserEntity_Game_GameId",
+                        column: x => x.GameId,
+                        principalTable: "Game",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_GameUserEntity_User_UserId",
+                        column: x => x.UserId,
+                        principalTable: "User",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_GameUserEntity_GameId",
+                table: "GameUserEntity",
+                column: "GameId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_GameUserEntity_UserId",
+                table: "GameUserEntity",
+                column: "UserId");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "GameUserEntity");
+        }
+    }
+}
diff --git a/Infrastructure/Migrations/20231121024132_Remove_GameEntityUserEntity.Designer.cs b/Infrastructure/Migrations/20231121024132_Remove_GameEntityUserEntity.Designer.cs
new file mode 100644
index 0000000..08113b9
--- /dev/null
+++ b/Infrastructure/Migrations/20231121024132_Remove_GameEntityUserEntity.Designer.cs
@@ -0,0 +1,1145 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using RepositoryLayer.Contexts;
+
+#nullable disable
+
+namespace RepositoryLayer.Migrations
+{
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20231121024132_Remove_GameEntityUserEntity")]
+    partial class Remove_GameEntityUserEntity
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "6.0.5")
+                .HasAnnotation("Relational:MaxIdentifierLength", 128);
+
+            SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder, 1L, 1);
+
+            modelBuilder.Entity("AttributeGroupEntityGameEntity", b =>
+                {
+                    b.Property<Guid>("AttributeGroupsId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("GamesId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("AttributeGroupsId", "GamesId");
+
+                    b.HasIndex("GamesId");
+
+                    b.ToTable("AttributeGroupEntityGameEntity");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.ActivityEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("ActivityTypeId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("CharacterId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("int");
+
+                    b.Property<Guid>("TransactionId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ActivityTypeId");
+
+                    b.HasIndex("CharacterId");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.HasIndex("TransactionId");
+
+                    b.ToTable("Activity");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.ActivityTypeEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("CharacterId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<Guid>("GameId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CharacterId");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.HasIndex("GameId");
+
+                    b.ToTable("ActivityType");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.AssetAttributeEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("AssetId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("AttributeGroupId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("Value")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetId");
+
+                    b.HasIndex("AttributeGroupId");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.ToTable("AssetAttribute");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.AssetEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("AssetTypeId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Image")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetTypeId");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.ToTable("Asset");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.AssetTypeEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<Guid>("GameId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.HasIndex("GameId");
+
+                    b.ToTable("AssetType");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.AttributeGroupEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Effect")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.ToTable("AttributeGroup");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.CharacterAssetEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("AssetsId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("CharacterId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime>("ExpiredDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("Value")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetsId");
+
+                    b.HasIndex("CharacterId");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.ToTable("CharacterAsset");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.CharacterAttributeEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("AttributeGroupId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("CharacterId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("Value")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AttributeGroupId");
+
+                    b.HasIndex("CharacterId");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.ToTable("CharacterAttribute");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.CharacterEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("CharacterTypeId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CurrentProperty")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<Guid>("GameServerId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("PointReward")
+                        .HasColumnType("int");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CharacterTypeId");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.HasIndex("GameServerId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Character");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.CharacterTypeEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("BaseProperties")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid>("GameId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.HasIndex("GameId");
+
+                    b.ToTable("CharacterType");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.GameEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Link")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Logo")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.ToTable("Game");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.GameServerEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("ArtifactUrl")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<Guid>("GameId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("Location")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.HasIndex("GameId");
+
+                    b.ToTable("GameServer");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.GameUserEntity", b =>
+                {
+                    b.Property<Guid>("GameId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasIndex("GameId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("GameUserEntity");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.LevelEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<Guid>("GameId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("LevelUpPoint")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.HasIndex("GameId");
+
+                    b.ToTable("Level");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.LevelProgressEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("CharacterId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("ExpPoint")
+                        .HasColumnType("int");
+
+                    b.Property<Guid>("LevelId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("LevelUpDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CharacterId");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.HasIndex("LevelId")
+                        .IsUnique();
+
+                    b.ToTable("LevelProgress");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.PaymentEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("Amount")
+                        .HasColumnType("int");
+
+                    b.Property<string>("BankCode")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid>("CharacterId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("Content")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime>("Date")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("WalletId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CharacterId");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("WalletId")
+                        .IsUnique();
+
+                    b.ToTable("Payment");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.TransactionEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<float>("Value")
+                        .HasColumnType("real");
+
+                    b.Property<Guid>("WalletId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.HasIndex("WalletId");
+
+                    b.ToTable("Transaction");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.UserEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("Avatar")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<float>("Balance")
+                        .HasColumnType("real");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Email")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FirstName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("LastName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Phone")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Uid")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.ToTable("User");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.WalletCategoryEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<Guid>("GameId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.HasIndex("GameId");
+
+                    b.ToTable("WalletCategory");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.WalletEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("CharacterId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<float>("TotalMoney")
+                        .HasColumnType("real");
+
+                    b.Property<Guid>("WalletCategoryId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CharacterId");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.HasIndex("WalletCategoryId");
+
+                    b.ToTable("Wallet");
+                });
+
+            modelBuilder.Entity("AttributeGroupEntityGameEntity", b =>
+                {
+                    b.HasOne("DomainLayer.Entities.AttributeGroupEntity", null)
+                        .WithMany()
+                        .HasForeignKey("AttributeGroupsId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("DomainLayer.Entities.GameEntity", null)
+                        .WithMany()
+                        .HasForeignKey("GamesId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.ActivityEntity", b =>
+                {
+                    b.HasOne("DomainLayer.Entities.ActivityTypeEntity", "ActivityType")
+                        .WithMany()
+                        .HasForeignKey("ActivityTypeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("DomainLayer.Entities.CharacterEntity", "Character")
+                        .WithMany()
+                        .HasForeignKey("CharacterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("DomainLayer.Entities.TransactionEntity", "Transaction")
+                        .WithMany("Activities")
+                        .HasForeignKey("TransactionId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.Navigation("ActivityType");
+
+                    b.Navigation("Character");
+
+                    b.Navigation("Transaction");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.ActivityTypeEntity", b =>
+                {
+                    b.HasOne("DomainLayer.Entities.CharacterEntity", "Character")
+                        .WithMany()
+                        .HasForeignKey("CharacterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("DomainLayer.Entities.GameEntity", "Game")
+                        .WithMany("ActivityTypes")
+                        .HasForeignKey("GameId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.Navigation("Character");
+
+                    b.Navigation("Game");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.AssetAttributeEntity", b =>
+                {
+                    b.HasOne("DomainLayer.Entities.AssetEntity", "Asset")
+                        .WithMany()
+                        .HasForeignKey("AssetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("DomainLayer.Entities.AttributeGroupEntity", "AttributeGroup")
+                        .WithMany()
+                        .HasForeignKey("AttributeGroupId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Asset");
+
+                    b.Navigation("AttributeGroup");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.AssetEntity", b =>
+                {
+                    b.HasOne("DomainLayer.Entities.AssetTypeEntity", "AssetType")
+                        .WithMany()
+                        .HasForeignKey("AssetTypeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("AssetType");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.AssetTypeEntity", b =>
+                {
+                    b.HasOne("DomainLayer.Entities.GameEntity", "Game")
+                        .WithMany()
+                        .HasForeignKey("GameId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Game");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.CharacterAssetEntity", b =>
+                {
+                    b.HasOne("DomainLayer.Entities.AssetEntity", "Assets")
+                        .WithMany()
+                        .HasForeignKey("AssetsId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("DomainLayer.Entities.CharacterEntity", "Characters")
+                        .WithMany("CharacterAssets")
+                        .HasForeignKey("CharacterId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.Navigation("Assets");
+
+                    b.Navigation("Characters");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.CharacterAttributeEntity", b =>
+                {
+                    b.HasOne("DomainLayer.Entities.AttributeGroupEntity", "AttributeGroup")
+                        .WithMany()
+                        .HasForeignKey("AttributeGroupId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("DomainLayer.Entities.CharacterEntity", "Character")
+                        .WithMany()
+                        .HasForeignKey("CharacterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("AttributeGroup");
+
+                    b.Navigation("Character");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.CharacterEntity", b =>
+                {
+                    b.HasOne("DomainLayer.Entities.CharacterTypeEntity", "CharacterType")
+                        .WithMany()
+                        .HasForeignKey("CharacterTypeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("DomainLayer.Entities.GameServerEntity", "GameServer")
+                        .WithMany("Characters")
+                        .HasForeignKey("GameServerId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("DomainLayer.Entities.UserEntity", "User")
+                        .WithMany("Characters")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.Navigation("CharacterType");
+
+                    b.Navigation("GameServer");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.CharacterTypeEntity", b =>
+                {
+                    b.HasOne("DomainLayer.Entities.GameEntity", "Game")
+                        .WithMany()
+                        .HasForeignKey("GameId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Game");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.GameServerEntity", b =>
+                {
+                    b.HasOne("DomainLayer.Entities.GameEntity", "Game")
+                        .WithMany()
+                        .HasForeignKey("GameId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Game");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.GameUserEntity", b =>
+                {
+                    b.HasOne("DomainLayer.Entities.GameEntity", "Game")
+                        .WithMany()
+                        .HasForeignKey("GameId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("DomainLayer.Entities.UserEntity", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Game");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.LevelEntity", b =>
+                {
+                    b.HasOne("DomainLayer.Entities.GameEntity", "Game")
+                        .WithMany()
+                        .HasForeignKey("GameId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Game");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.LevelProgressEntity", b =>
+                {
+                    b.HasOne("DomainLayer.Entities.CharacterEntity", "Character")
+                        .WithMany()
+                        .HasForeignKey("CharacterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("DomainLayer.Entities.LevelEntity", "Level")
+                        .WithOne("LevelProgress")
+                        .HasForeignKey("DomainLayer.Entities.LevelProgressEntity", "LevelId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.Navigation("Character");
+
+                    b.Navigation("Level");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.PaymentEntity", b =>
+                {
+                    b.HasOne("DomainLayer.Entities.CharacterEntity", "Character")
+                        .WithMany()
+                        .HasForeignKey("CharacterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("DomainLayer.Entities.UserEntity", "User")
+                        .WithMany("Payments")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("DomainLayer.Entities.WalletEntity", "Wallet")
+                        .WithOne("Payment")
+                        .HasForeignKey("DomainLayer.Entities.PaymentEntity", "WalletId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.Navigation("Character");
+
+                    b.Navigation("User");
+
+                    b.Navigation("Wallet");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.TransactionEntity", b =>
+                {
+                    b.HasOne("DomainLayer.Entities.WalletEntity", "Wallet")
+                        .WithMany()
+                        .HasForeignKey("WalletId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Wallet");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.WalletCategoryEntity", b =>
+                {
+                    b.HasOne("DomainLayer.Entities.GameEntity", "Game")
+                        .WithMany()
+                        .HasForeignKey("GameId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Game");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.WalletEntity", b =>
+                {
+                    b.HasOne("DomainLayer.Entities.CharacterEntity", "Character")
+                        .WithMany()
+                        .HasForeignKey("CharacterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("DomainLayer.Entities.WalletCategoryEntity", "WalletCategory")
+                        .WithMany("WalletEntities")
+                        .HasForeignKey("WalletCategoryId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.Navigation("Character");
+
+                    b.Navigation("WalletCategory");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.CharacterEntity", b =>
+                {
+                    b.Navigation("CharacterAssets");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.GameEntity", b =>
+                {
+                    b.Navigation("ActivityTypes");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.GameServerEntity", b =>
+                {
+                    b.Navigation("Characters");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.LevelEntity", b =>
+                {
+                    b.Navigation("LevelProgress")
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.TransactionEntity", b =>
+                {
+                    b.Navigation("Activities");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.UserEntity", b =>
+                {
+                    b.Navigation("Characters");
+
+                    b.Navigation("Payments");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.WalletCategoryEntity", b =>
+                {
+                    b.Navigation("WalletEntities");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.WalletEntity", b =>
+                {
+                    b.Navigation("Payment")
+                        .IsRequired();
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/Infrastructure/Migrations/20231121024132_Remove_GameEntityUserEntity.cs b/Infrastructure/Migrations/20231121024132_Remove_GameEntityUserEntity.cs
new file mode 100644
index 0000000..0f8a3b0
--- /dev/null
+++ b/Infrastructure/Migrations/20231121024132_Remove_GameEntityUserEntity.cs
@@ -0,0 +1,48 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace RepositoryLayer.Migrations
+{
+    public partial class Remove_GameEntityUserEntity : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "GameEntityUserEntity");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "GameEntityUserEntity",
+                columns: table => new
+                {
+                    GamesId = table.Column<Guid>(type: "uniqueidentifier", nullable: false),
+                    UsersId = table.Column<Guid>(type: "uniqueidentifier", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_GameEntityUserEntity", x => new { x.GamesId, x.UsersId });
+                    table.ForeignKey(
+                        name: "FK_GameEntityUserEntity_Game_GamesId",
+                        column: x => x.GamesId,
+                        principalTable: "Game",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_GameEntityUserEntity_User_UsersId",
+                        column: x => x.UsersId,
+                        principalTable: "User",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_GameEntityUserEntity_UsersId",
+                table: "GameEntityUserEntity",
+                column: "UsersId");
+        }
+    }
+}
diff --git a/Infrastructure/Migrations/20231122024235_UpdateGameUser.Designer.cs b/Infrastructure/Migrations/20231122024235_UpdateGameUser.Designer.cs
new file mode 100644
index 0000000..20a94be
--- /dev/null
+++ b/Infrastructure/Migrations/20231122024235_UpdateGameUser.Designer.cs
@@ -0,0 +1,1162 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using RepositoryLayer.Contexts;
+
+#nullable disable
+
+namespace RepositoryLayer.Migrations
+{
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20231122024235_UpdateGameUser")]
+    partial class UpdateGameUser
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "6.0.5")
+                .HasAnnotation("Relational:MaxIdentifierLength", 128);
+
+            SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder, 1L, 1);
+
+            modelBuilder.Entity("AttributeGroupEntityGameEntity", b =>
+                {
+                    b.Property<Guid>("AttributeGroupsId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("GamesId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("AttributeGroupsId", "GamesId");
+
+                    b.HasIndex("GamesId");
+
+                    b.ToTable("AttributeGroupEntityGameEntity");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.ActivityEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("ActivityTypeId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("CharacterId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("int");
+
+                    b.Property<Guid>("TransactionId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ActivityTypeId");
+
+                    b.HasIndex("CharacterId");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.HasIndex("TransactionId");
+
+                    b.ToTable("Activity");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.ActivityTypeEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("CharacterId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<Guid>("GameId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CharacterId");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.HasIndex("GameId");
+
+                    b.ToTable("ActivityType");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.AssetAttributeEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("AssetId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("AttributeGroupId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("Value")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetId");
+
+                    b.HasIndex("AttributeGroupId");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.ToTable("AssetAttribute");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.AssetEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("AssetTypeId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Image")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetTypeId");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.ToTable("Asset");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.AssetTypeEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<Guid>("GameId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.HasIndex("GameId");
+
+                    b.ToTable("AssetType");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.AttributeGroupEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Effect")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.ToTable("AttributeGroup");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.CharacterAssetEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("AssetsId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("CharacterId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime>("ExpiredDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("Value")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetsId");
+
+                    b.HasIndex("CharacterId");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.ToTable("CharacterAsset");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.CharacterAttributeEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("AttributeGroupId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("CharacterId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("Value")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AttributeGroupId");
+
+                    b.HasIndex("CharacterId");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.ToTable("CharacterAttribute");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.CharacterEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("CharacterTypeId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CurrentProperty")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<Guid>("GameServerId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("PointReward")
+                        .HasColumnType("int");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CharacterTypeId");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.HasIndex("GameServerId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Character");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.CharacterTypeEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("BaseProperties")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid>("GameId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.HasIndex("GameId");
+
+                    b.ToTable("CharacterType");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.GameEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Link")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Logo")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.ToTable("Game");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.GameServerEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("ArtifactUrl")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<Guid>("GameId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("Location")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.HasIndex("GameId");
+
+                    b.ToTable("GameServer");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.GameUserEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<Guid>("GameId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.HasIndex("GameId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("GameUserEntity");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.LevelEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<Guid>("GameId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("LevelUpPoint")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.HasIndex("GameId");
+
+                    b.ToTable("Level");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.LevelProgressEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("CharacterId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("ExpPoint")
+                        .HasColumnType("int");
+
+                    b.Property<Guid>("LevelId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("LevelUpDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CharacterId");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.HasIndex("LevelId")
+                        .IsUnique();
+
+                    b.ToTable("LevelProgress");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.PaymentEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("Amount")
+                        .HasColumnType("int");
+
+                    b.Property<string>("BankCode")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid>("CharacterId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("Content")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime>("Date")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("WalletId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CharacterId");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("WalletId")
+                        .IsUnique();
+
+                    b.ToTable("Payment");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.TransactionEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<float>("Value")
+                        .HasColumnType("real");
+
+                    b.Property<Guid>("WalletId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.HasIndex("WalletId");
+
+                    b.ToTable("Transaction");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.UserEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("Avatar")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<float>("Balance")
+                        .HasColumnType("real");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Email")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FirstName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("LastName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Phone")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Uid")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.ToTable("User");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.WalletCategoryEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<Guid>("GameId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.HasIndex("GameId");
+
+                    b.ToTable("WalletCategory");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.WalletEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("CharacterId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<float>("TotalMoney")
+                        .HasColumnType("real");
+
+                    b.Property<Guid>("WalletCategoryId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CharacterId");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.HasIndex("WalletCategoryId");
+
+                    b.ToTable("Wallet");
+                });
+
+            modelBuilder.Entity("AttributeGroupEntityGameEntity", b =>
+                {
+                    b.HasOne("DomainLayer.Entities.AttributeGroupEntity", null)
+                        .WithMany()
+                        .HasForeignKey("AttributeGroupsId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("DomainLayer.Entities.GameEntity", null)
+                        .WithMany()
+                        .HasForeignKey("GamesId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.ActivityEntity", b =>
+                {
+                    b.HasOne("DomainLayer.Entities.ActivityTypeEntity", "ActivityType")
+                        .WithMany()
+                        .HasForeignKey("ActivityTypeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("DomainLayer.Entities.CharacterEntity", "Character")
+                        .WithMany()
+                        .HasForeignKey("CharacterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("DomainLayer.Entities.TransactionEntity", "Transaction")
+                        .WithMany("Activities")
+                        .HasForeignKey("TransactionId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.Navigation("ActivityType");
+
+                    b.Navigation("Character");
+
+                    b.Navigation("Transaction");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.ActivityTypeEntity", b =>
+                {
+                    b.HasOne("DomainLayer.Entities.CharacterEntity", "Character")
+                        .WithMany()
+                        .HasForeignKey("CharacterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("DomainLayer.Entities.GameEntity", "Game")
+                        .WithMany("ActivityTypes")
+                        .HasForeignKey("GameId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.Navigation("Character");
+
+                    b.Navigation("Game");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.AssetAttributeEntity", b =>
+                {
+                    b.HasOne("DomainLayer.Entities.AssetEntity", "Asset")
+                        .WithMany()
+                        .HasForeignKey("AssetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("DomainLayer.Entities.AttributeGroupEntity", "AttributeGroup")
+                        .WithMany()
+                        .HasForeignKey("AttributeGroupId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Asset");
+
+                    b.Navigation("AttributeGroup");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.AssetEntity", b =>
+                {
+                    b.HasOne("DomainLayer.Entities.AssetTypeEntity", "AssetType")
+                        .WithMany()
+                        .HasForeignKey("AssetTypeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("AssetType");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.AssetTypeEntity", b =>
+                {
+                    b.HasOne("DomainLayer.Entities.GameEntity", "Game")
+                        .WithMany()
+                        .HasForeignKey("GameId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Game");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.CharacterAssetEntity", b =>
+                {
+                    b.HasOne("DomainLayer.Entities.AssetEntity", "Assets")
+                        .WithMany()
+                        .HasForeignKey("AssetsId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("DomainLayer.Entities.CharacterEntity", "Characters")
+                        .WithMany("CharacterAssets")
+                        .HasForeignKey("CharacterId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.Navigation("Assets");
+
+                    b.Navigation("Characters");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.CharacterAttributeEntity", b =>
+                {
+                    b.HasOne("DomainLayer.Entities.AttributeGroupEntity", "AttributeGroup")
+                        .WithMany()
+                        .HasForeignKey("AttributeGroupId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("DomainLayer.Entities.CharacterEntity", "Character")
+                        .WithMany()
+                        .HasForeignKey("CharacterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("AttributeGroup");
+
+                    b.Navigation("Character");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.CharacterEntity", b =>
+                {
+                    b.HasOne("DomainLayer.Entities.CharacterTypeEntity", "CharacterType")
+                        .WithMany()
+                        .HasForeignKey("CharacterTypeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("DomainLayer.Entities.GameServerEntity", "GameServer")
+                        .WithMany("Characters")
+                        .HasForeignKey("GameServerId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("DomainLayer.Entities.UserEntity", "User")
+                        .WithMany("Characters")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.Navigation("CharacterType");
+
+                    b.Navigation("GameServer");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.CharacterTypeEntity", b =>
+                {
+                    b.HasOne("DomainLayer.Entities.GameEntity", "Game")
+                        .WithMany()
+                        .HasForeignKey("GameId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Game");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.GameServerEntity", b =>
+                {
+                    b.HasOne("DomainLayer.Entities.GameEntity", "Game")
+                        .WithMany()
+                        .HasForeignKey("GameId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Game");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.GameUserEntity", b =>
+                {
+                    b.HasOne("DomainLayer.Entities.GameEntity", "Game")
+                        .WithMany()
+                        .HasForeignKey("GameId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("DomainLayer.Entities.UserEntity", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Game");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.LevelEntity", b =>
+                {
+                    b.HasOne("DomainLayer.Entities.GameEntity", "Game")
+                        .WithMany()
+                        .HasForeignKey("GameId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Game");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.LevelProgressEntity", b =>
+                {
+                    b.HasOne("DomainLayer.Entities.CharacterEntity", "Character")
+                        .WithMany()
+                        .HasForeignKey("CharacterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("DomainLayer.Entities.LevelEntity", "Level")
+                        .WithOne("LevelProgress")
+                        .HasForeignKey("DomainLayer.Entities.LevelProgressEntity", "LevelId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.Navigation("Character");
+
+                    b.Navigation("Level");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.PaymentEntity", b =>
+                {
+                    b.HasOne("DomainLayer.Entities.CharacterEntity", "Character")
+                        .WithMany()
+                        .HasForeignKey("CharacterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("DomainLayer.Entities.UserEntity", "User")
+                        .WithMany("Payments")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("DomainLayer.Entities.WalletEntity", "Wallet")
+                        .WithOne("Payment")
+                        .HasForeignKey("DomainLayer.Entities.PaymentEntity", "WalletId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.Navigation("Character");
+
+                    b.Navigation("User");
+
+                    b.Navigation("Wallet");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.TransactionEntity", b =>
+                {
+                    b.HasOne("DomainLayer.Entities.WalletEntity", "Wallet")
+                        .WithMany()
+                        .HasForeignKey("WalletId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Wallet");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.WalletCategoryEntity", b =>
+                {
+                    b.HasOne("DomainLayer.Entities.GameEntity", "Game")
+                        .WithMany()
+                        .HasForeignKey("GameId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Game");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.WalletEntity", b =>
+                {
+                    b.HasOne("DomainLayer.Entities.CharacterEntity", "Character")
+                        .WithMany()
+                        .HasForeignKey("CharacterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("DomainLayer.Entities.WalletCategoryEntity", "WalletCategory")
+                        .WithMany("WalletEntities")
+                        .HasForeignKey("WalletCategoryId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.Navigation("Character");
+
+                    b.Navigation("WalletCategory");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.CharacterEntity", b =>
+                {
+                    b.Navigation("CharacterAssets");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.GameEntity", b =>
+                {
+                    b.Navigation("ActivityTypes");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.GameServerEntity", b =>
+                {
+                    b.Navigation("Characters");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.LevelEntity", b =>
+                {
+                    b.Navigation("LevelProgress")
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.TransactionEntity", b =>
+                {
+                    b.Navigation("Activities");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.UserEntity", b =>
+                {
+                    b.Navigation("Characters");
+
+                    b.Navigation("Payments");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.WalletCategoryEntity", b =>
+                {
+                    b.Navigation("WalletEntities");
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.WalletEntity", b =>
+                {
+                    b.Navigation("Payment")
+                        .IsRequired();
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/Infrastructure/Migrations/20231122024235_UpdateGameUser.cs b/Infrastructure/Migrations/20231122024235_UpdateGameUser.cs
new file mode 100644
index 0000000..66ba89d
--- /dev/null
+++ b/Infrastructure/Migrations/20231122024235_UpdateGameUser.cs
@@ -0,0 +1,75 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace RepositoryLayer.Migrations
+{
+    public partial class UpdateGameUser : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<Guid>(
+                name: "Id",
+                table: "GameUserEntity",
+                type: "uniqueidentifier",
+                nullable: false,
+                defaultValue: new Guid("00000000-0000-0000-0000-000000000000"));
+
+            migrationBuilder.AddColumn<DateTime>(
+                name: "CreatedAt",
+                table: "GameUserEntity",
+                type: "datetime2",
+                nullable: true);
+
+            migrationBuilder.AddColumn<DateTime>(
+                name: "DeletedAt",
+                table: "GameUserEntity",
+                type: "datetime2",
+                nullable: true);
+
+            migrationBuilder.AddColumn<DateTime>(
+                name: "ModifiedAt",
+                table: "GameUserEntity",
+                type: "datetime2",
+                nullable: true);
+
+            migrationBuilder.AddPrimaryKey(
+                name: "PK_GameUserEntity",
+                table: "GameUserEntity",
+                column: "Id");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_GameUserEntity_DeletedAt",
+                table: "GameUserEntity",
+                column: "DeletedAt");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropPrimaryKey(
+                name: "PK_GameUserEntity",
+                table: "GameUserEntity");
+
+            migrationBuilder.DropIndex(
+                name: "IX_GameUserEntity_DeletedAt",
+                table: "GameUserEntity");
+
+            migrationBuilder.DropColumn(
+                name: "Id",
+                table: "GameUserEntity");
+
+            migrationBuilder.DropColumn(
+                name: "CreatedAt",
+                table: "GameUserEntity");
+
+            migrationBuilder.DropColumn(
+                name: "DeletedAt",
+                table: "GameUserEntity");
+
+            migrationBuilder.DropColumn(
+                name: "ModifiedAt",
+                table: "GameUserEntity");
+        }
+    }
+}
diff --git a/Infrastructure/Migrations/ApplicationDbContextModelSnapshot.cs b/Infrastructure/Migrations/ApplicationDbContextModelSnapshot.cs
index e1e001b..fe58683 100644
--- a/Infrastructure/Migrations/ApplicationDbContextModelSnapshot.cs
+++ b/Infrastructure/Migrations/ApplicationDbContextModelSnapshot.cs
@@ -34,7 +34,7 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     b.HasIndex("GamesId");
 
-                    b.ToTable("AttributeGroupEntityGameEntity");
+                    b.ToTable("AttributeGroupEntityGameEntity", (string)null);
                 });
 
             modelBuilder.Entity("DomainLayer.Entities.ActivityEntity", b =>
@@ -78,7 +78,7 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     b.HasIndex("TransactionId");
 
-                    b.ToTable("Activity");
+                    b.ToTable("Activity", (string)null);
                 });
 
             modelBuilder.Entity("DomainLayer.Entities.ActivityTypeEntity", b =>
@@ -114,7 +114,7 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     b.HasIndex("GameId");
 
-                    b.ToTable("ActivityType");
+                    b.ToTable("ActivityType", (string)null);
                 });
 
             modelBuilder.Entity("DomainLayer.Entities.AssetAttributeEntity", b =>
@@ -149,7 +149,7 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     b.HasIndex("DeletedAt");
 
-                    b.ToTable("AssetAttribute");
+                    b.ToTable("AssetAttribute", (string)null);
                 });
 
             modelBuilder.Entity("DomainLayer.Entities.AssetEntity", b =>
@@ -188,7 +188,7 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     b.HasIndex("DeletedAt");
 
-                    b.ToTable("Asset");
+                    b.ToTable("Asset", (string)null);
                 });
 
             modelBuilder.Entity("DomainLayer.Entities.AssetTypeEntity", b =>
@@ -219,7 +219,7 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     b.HasIndex("GameId");
 
-                    b.ToTable("AssetType");
+                    b.ToTable("AssetType", (string)null);
                 });
 
             modelBuilder.Entity("DomainLayer.Entities.AttributeGroupEntity", b =>
@@ -249,7 +249,7 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     b.HasIndex("DeletedAt");
 
-                    b.ToTable("AttributeGroup");
+                    b.ToTable("AttributeGroup", (string)null);
                 });
 
             modelBuilder.Entity("DomainLayer.Entities.CharacterAssetEntity", b =>
@@ -287,7 +287,7 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     b.HasIndex("DeletedAt");
 
-                    b.ToTable("CharacterAsset");
+                    b.ToTable("CharacterAsset", (string)null);
                 });
 
             modelBuilder.Entity("DomainLayer.Entities.CharacterAttributeEntity", b =>
@@ -322,7 +322,7 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     b.HasIndex("DeletedAt");
 
-                    b.ToTable("CharacterAttribute");
+                    b.ToTable("CharacterAttribute", (string)null);
                 });
 
             modelBuilder.Entity("DomainLayer.Entities.CharacterEntity", b =>
@@ -366,7 +366,7 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     b.HasIndex("UserId");
 
-                    b.ToTable("Character");
+                    b.ToTable("Character", (string)null);
                 });
 
             modelBuilder.Entity("DomainLayer.Entities.CharacterTypeEntity", b =>
@@ -405,7 +405,7 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     b.HasIndex("GameId");
 
-                    b.ToTable("CharacterType");
+                    b.ToTable("CharacterType", (string)null);
                 });
 
             modelBuilder.Entity("DomainLayer.Entities.GameEntity", b =>
@@ -439,7 +439,7 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     b.HasIndex("DeletedAt");
 
-                    b.ToTable("Game");
+                    b.ToTable("Game", (string)null);
                 });
 
             modelBuilder.Entity("DomainLayer.Entities.GameServerEntity", b =>
@@ -478,7 +478,39 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     b.HasIndex("GameId");
 
-                    b.ToTable("GameServer");
+                    b.ToTable("GameServer", (string)null);
+                });
+
+            modelBuilder.Entity("DomainLayer.Entities.GameUserEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<Guid>("GameId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("ModifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DeletedAt");
+
+                    b.HasIndex("GameId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("GameUserEntity", (string)null);
                 });
 
             modelBuilder.Entity("DomainLayer.Entities.LevelEntity", b =>
@@ -512,7 +544,7 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     b.HasIndex("GameId");
 
-                    b.ToTable("Level");
+                    b.ToTable("Level", (string)null);
                 });
 
             modelBuilder.Entity("DomainLayer.Entities.LevelProgressEntity", b =>
@@ -555,7 +587,7 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.HasIndex("LevelId")
                         .IsUnique();
 
-                    b.ToTable("LevelProgress");
+                    b.ToTable("LevelProgress", (string)null);
                 });
 
             modelBuilder.Entity("DomainLayer.Entities.PaymentEntity", b =>
@@ -611,7 +643,7 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.HasIndex("WalletId")
                         .IsUnique();
 
-                    b.ToTable("Payment");
+                    b.ToTable("Payment", (string)null);
                 });
 
             modelBuilder.Entity("DomainLayer.Entities.TransactionEntity", b =>
@@ -645,7 +677,7 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     b.HasIndex("WalletId");
 
-                    b.ToTable("Transaction");
+                    b.ToTable("Transaction", (string)null);
                 });
 
             modelBuilder.Entity("DomainLayer.Entities.UserEntity", b =>
@@ -700,7 +732,7 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     b.HasIndex("DeletedAt");
 
-                    b.ToTable("User");
+                    b.ToTable("User", (string)null);
                 });
 
             modelBuilder.Entity("DomainLayer.Entities.WalletCategoryEntity", b =>
@@ -731,7 +763,7 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     b.HasIndex("GameId");
 
-                    b.ToTable("WalletCategory");
+                    b.ToTable("WalletCategory", (string)null);
                 });
 
             modelBuilder.Entity("DomainLayer.Entities.WalletEntity", b =>
@@ -770,22 +802,7 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     b.HasIndex("WalletCategoryId");
 
-                    b.ToTable("Wallet");
-                });
-
-            modelBuilder.Entity("GameEntityUserEntity", b =>
-                {
-                    b.Property<Guid>("GamesId")
-                        .HasColumnType("uniqueidentifier");
-
-                    b.Property<Guid>("UsersId")
-                        .HasColumnType("uniqueidentifier");
-
-                    b.HasKey("GamesId", "UsersId");
-
-                    b.HasIndex("UsersId");
-
-                    b.ToTable("GameEntityUserEntity");
+                    b.ToTable("Wallet", (string)null);
                 });
 
             modelBuilder.Entity("AttributeGroupEntityGameEntity", b =>
@@ -977,6 +994,25 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Navigation("Game");
                 });
 
+            modelBuilder.Entity("DomainLayer.Entities.GameUserEntity", b =>
+                {
+                    b.HasOne("DomainLayer.Entities.GameEntity", "Game")
+                        .WithMany()
+                        .HasForeignKey("GameId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("DomainLayer.Entities.UserEntity", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Game");
+
+                    b.Navigation("User");
+                });
+
             modelBuilder.Entity("DomainLayer.Entities.LevelEntity", b =>
                 {
                     b.HasOne("DomainLayer.Entities.GameEntity", "Game")
@@ -1075,21 +1111,6 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Navigation("WalletCategory");
                 });
 
-            modelBuilder.Entity("GameEntityUserEntity", b =>
-                {
-                    b.HasOne("DomainLayer.Entities.GameEntity", null)
-                        .WithMany()
-                        .HasForeignKey("GamesId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("DomainLayer.Entities.UserEntity", null)
-                        .WithMany()
-                        .HasForeignKey("UsersId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
             modelBuilder.Entity("DomainLayer.Entities.CharacterEntity", b =>
                 {
                     b.Navigation("CharacterAssets");
diff --git a/Infrastructure/Repositories/GenericRepository.cs b/Infrastructure/Repositories/GenericRepository.cs
index 4880ff4..140dcca 100644
--- a/Infrastructure/Repositories/GenericRepository.cs
+++ b/Infrastructure/Repositories/GenericRepository.cs
@@ -128,6 +128,11 @@ public async Task<long> SumAsync(Expression<Func<T, bool>> predicate, Expression
 
     public async Task CreateRangeAsync(IEnumerable<T> entities)
     {
+        foreach (var entity in entities)
+        {
+            entity.CreatedAt = DateTime.UtcNow;
+            entity.ModifiedAt = DateTime.UtcNow;
+        }
         await _context.AddRangeAsync(entities);
         await _context.SaveChangesAsync();
     }