Refactor Queries handlers

MafiaTelegramBot.sln

@@ -2,8 +2,6 @@
 Microsoft Visual Studio Solution File, Format Version 12.00
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MafiaTelegramBot", "MafiaTelegramBot\MafiaTelegramBot.csproj", "{2447C2FC-E9CD-4212-8949-90B6C6B4A8D5}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MafiaTelegramBotTests", "MafiaTelegramBotTests\MafiaTelegramBotTests.csproj", "{BB1857E4-418E-4AE5-8437-43EBD1D903FB}"
-EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ResetStatsProgram", "ResetStatsProgram\ResetStatsProgram.csproj", "{05720E84-C98B-44CD-8B98-AF42FEB5AA9C}"
 EndProject
 Global
@@ -16,10 +14,6 @@ Global
 		{2447C2FC-E9CD-4212-8949-90B6C6B4A8D5}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{2447C2FC-E9CD-4212-8949-90B6C6B4A8D5}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{2447C2FC-E9CD-4212-8949-90B6C6B4A8D5}.Release|Any CPU.Build.0 = Release|Any CPU
-		{BB1857E4-418E-4AE5-8437-43EBD1D903FB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{BB1857E4-418E-4AE5-8437-43EBD1D903FB}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{BB1857E4-418E-4AE5-8437-43EBD1D903FB}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{BB1857E4-418E-4AE5-8437-43EBD1D903FB}.Release|Any CPU.Build.0 = Release|Any CPU
 		{05720E84-C98B-44CD-8B98-AF42FEB5AA9C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{05720E84-C98B-44CD-8B98-AF42FEB5AA9C}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{05720E84-C98B-44CD-8B98-AF42FEB5AA9C}.Release|Any CPU.ActiveCfg = Release|Any CPU

MafiaTelegramBot/Bot.cs

@@ -0,0 +1,32 @@
+using System;
+using System.Threading;
+using MafiaTelegramBot.Controllers;
+using MafiaTelegramBot.Resources;
+using Telegram.Bot;
+using Telegram.Bot.Extensions.Polling;
+
+namespace MafiaTelegramBot
+{
+    public static class Bot
+    {
+        private static TelegramBotClient _client;
+
+        public static TelegramBotClient Client
+        {
+            get
+            {
+                if (_client != null) return _client;
+                _client = new TelegramBotClient(AppSettings.Token);
+                return _client;
+            }
+        }
+        
+        public static void Main()
+        {
+            var cts = new CancellationTokenSource();
+            Client.StartReceiving(new DefaultUpdateHandler(MessageController.HandleUpdateAsync, MessageController.HandleErrorAsync), cts.Token);
+            Console.ReadLine();
+            cts.Cancel();
+        }
+    }
+}

MafiaTelegramBot/Commands/Bot.cs

@@ -1,85 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using MafiaTelegramBot.Resources;
-using Telegram.Bot;
-using Telegram.Bot.Types.Enums;
-using Telegram.Bot.Types.ReplyMarkups;
-using static MafiaTelegramBot.Logs;
-
-namespace MafiaTelegramBot.Models
-{
-    public static class Bot
-    {
-        private static TelegramBotClient _client;
-
-        public static readonly List<long> UsersThatChangesNickname = new();
-        public static readonly Dictionary<long, string> UsersThatCreatesRoom = new();
-        public static readonly List<long> UserThatEntersPrivateCode = new();
-
-        public static TelegramBotClient Client
-        {
-            get
-            {
-                if (_client != null) return _client;
-                _client = new TelegramBotClient(AppSettings.Token);
-                return _client;
-            }
-        }
-
-        public static async Task<Telegram.Bot.Types.Message> SendStickerAsync(long chatId, string fileId)
-        {
-            try
-            {
-                return await Get().SendStickerAsync(chatId, fileId, true);
-            }
-            catch (Exception e)
-            {
-                LogOutError(e.Message);
-                return new Telegram.Bot.Types.Message();
-            }
-        }
-
-        public static async Task<Telegram.Bot.Types.Message> SendHyperLink(long chatId, string message)
-        {
-            try
-            {
-                return await Get().SendTextMessageAsync(chatId, message, ParseMode.Html, disableNotification: true);
-            }
-            catch (Exception e)
-            {
-                LogOutError(e.Message);
-                return new Telegram.Bot.Types.Message();
-            }
-        }
-        
-        public static async Task<Telegram.Bot.Types.Message> SendWithMarkdown2(long chatId, string message, IReplyMarkup replyMarkup = null)
-        {
-            try
-            {
-                var editedMessage = await Utilities.ToMarkdownString(message);
-                return await Get().SendTextMessageAsync(chatId, editedMessage,
-                    ParseMode.MarkdownV2, replyMarkup: replyMarkup, disableNotification: true);
-            }
-            catch (Exception e)
-            {
-                LogOutError(e.Message);
-                return new Telegram.Bot.Types.Message();
-            }
-        }
-
-        public static async Task<Telegram.Bot.Types.Message> EditMessageAsync(long chatId, int messageId, string message, InlineKeyboardMarkup keyboard = null)
-        {
-            try
-            {
-                var editedMessage = await Utilities.ToMarkdownString(message);
-                return await Get().EditMessageTextAsync(chatId, messageId, editedMessage, ParseMode.MarkdownV2, replyMarkup: keyboard);
-            }
-            catch (Exception e)
-            {
-                LogOutError(e.Message);
-                return new Telegram.Bot.Types.Message();
-            }
-        }
-    }
-}

MafiaTelegramBot/Commands/Inlines/ApplyRolesChangeQuery.cs → MafiaTelegramBot/Commands/CallbackQueries/ApplyRolesChangeCallbackQueryHandler.cs

@@ -2,30 +2,32 @@ using System;
 using System.Linq;
 using System.Threading.Tasks;
 using MafiaTelegramBot.Controllers;
+using MafiaTelegramBot.Game;
 using MafiaTelegramBot.Game.GameRooms;
 using MafiaTelegramBot.Resources;
 using Telegram.Bot.Types;
 
-namespace MafiaTelegramBot.Models.Inlines
+namespace MafiaTelegramBot.Commands.CallbackQueries
 {
-    public class ApplyRolesChangeQuery : Query
+    public class ApplyRolesChangeCallbackQueryHandler : CallbackQueryHandler
     {
-        protected override Callback Name => Callback.ApplyRolesChange;
+        protected override string Command => Callback.ApplyRolesChange.ToString();
         private ExtendedGameRoom _room;
-        protected override async Task<Message> Execute(Update update)
+        public override async Task<Message> Execute(Update update)
         {
             var data = update.CallbackQuery.Data.Split('|');
-            var roomKey = data[2];
+            var roomKey = data[1];
             _room = (ExtendedGameRoom) RoomController.GetRoom(roomKey);
             if(_room == null)
-                await Bot.EditMessageAsync(ChatId, update.CallbackQuery.Message.MessageId, strings.room_does_not_exists);
-            var roleQuery = Enum.Parse<Roles>(data[3]);
-            if(roleQuery is Roles.Villager or Roles.Mafia) MafiaVillager(roleQuery, data[4]);
+                 return await MessageController.EditMessage(User.Info,
+                     update.CallbackQuery.Message.MessageId, strings.room_does_not_exists);
+            var roleQuery = Enum.Parse<Roles>(data[2]);
+            if(roleQuery is Roles.Villager or Roles.Mafia) MafiaVillager(roleQuery, data[3]);
             else SwitchRole(roleQuery);
             var message = $"{strings.current_enabled_roles}";
             foreach (var (role, count) in _room.CustomRoomSettings)
                 message += $"\n| {roles.ResourceManager.GetString(role.ToString())} ({count}) |";
-            return await Bot.EditMessageAsync(ChatId, update.CallbackQuery.Message.MessageId, message, Keyboard.ChangeRolesKeyboard(UserId, roomKey, _room));
+            return await MessageController.EditMessage(User.Info, update.CallbackQuery.Message.MessageId, message, Keyboard.ChangeRolesKeyboard(roomKey, _room));
         }
 
         private void MafiaVillager(Roles role, string action)
@@ -111,5 +113,7 @@ namespace MafiaTelegramBot.Models.Inlines
                 else _room.CustomRoomSettings.Add(role, 1);
             }
         }
+
+        public ApplyRolesChangeCallbackQueryHandler(Player player) : base(player) { }
     }
 }

MafiaTelegramBot/Commands/CallbackQueries/BackToProfileCallbackQueryHandler.cs

@@ -0,0 +1,32 @@
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using MafiaTelegramBot.Controllers;
+using MafiaTelegramBot.Game;
+using MafiaTelegramBot.Resources;
+using Telegram.Bot.Types;
+
+namespace MafiaTelegramBot.Commands.CallbackQueries
+{
+    public class BackToProfileCallbackQueryHandler : CallbackQueryHandler
+    {
+        protected override string Command => Callback.BackToProfile.ToString();
+        public override async Task<Message> Execute(Update update)
+        {
+            var rolesList = Enum.GetValues(typeof(Roles)).Cast<Roles>().ToList();
+            rolesList.Remove(Roles.None);
+            rolesList.Remove(Roles.All);
+            var allStatsRow = User.Statistics[Roles.All];
+            var message =
+                $"{strings.statistics_for} {User.Info.NickName}\n" +
+                $"{strings.games_count} {allStatsRow.Games}\n" +
+                $"{strings.wins_count} {allStatsRow.Wins}\n" +
+                $"{strings.winrate} {(int)(allStatsRow.GetWinrate()*100)}%\n" +
+                $"{strings.rate} {User.Info.RankNumber}";
+            return await MessageController.EditMessage(User.Info,
+                update.CallbackQuery.Message.MessageId,message, Keyboard.ProfileKeyboard());
+        }
+
+        public BackToProfileCallbackQueryHandler(Player player) : base(player) { }
+    }
+}

MafiaTelegramBot/Commands/CallbackQueries/CallbackQueryHandler.cs

@@ -0,0 +1,48 @@
+#nullable enable
+using System.Collections.Generic;
+using MafiaTelegramBot.Game;
+
+namespace MafiaTelegramBot.Commands.CallbackQueries
+{
+    public class CallbackQueryHandler : UpdateHandler
+    {
+        protected override List<UpdateHandler> List => new()
+        {
+            // Переносим обработку сообщений в другой класс, если игрок находится в комнате
+            new UserInGameCallbackQueryHandler(null),
+            
+            // Остальные обработчики
+            new ApplyRolesChangeCallbackQueryHandler(null),
+            new BackToProfileCallbackQueryHandler(null),
+            new ChangeNickNameCallbackQueryHandler(null),
+            new ChangeRolesCallbackQueryHandler(null),
+            new ChooseGameModeCallbackQueryHandler(null),
+            new ChooseGameTypeCallbackQueryHandler(null),
+            new ChooseRoomViewCallbackQueryHandler(null),
+            new ConnectToNotRankedCallbackQueryHandler(null),
+            new ConnectToPrivateRoomCallbackQueryHandler(null),
+            new ConnectToPublicRoomCallbackQueryHandler(null),
+            new ConnectToRankedCallbackQueryHandler(null),
+            new ConnectToSelectedRoomCallbackQueryHandler(null),
+            new ContinueCallbackQueryHandler(null),
+            new GiveRoleCallbackQueryHandler(null),
+            new GiveToAllCallbackQueryHandler(null),
+            new GiveToSelectedCallbackQueryHandler(null),
+            new KickSelectedPlayerCallbackQueryHandler(null),
+            new PackInfoCallbackQueryHandler(null),
+            new PackOpenCallbackQueryHandler(null),
+            new PlayersCountSettingsCallbackQueryHandler(null),
+            new SetPlayersMaximumCallbackQueryHandler(null),
+            new SettingsProfileCallbackQueryHandler(null),
+            new SettingsRoomCallbackQueryHandler(null),
+            new ShopMenuCallbackQueryHandler(null),
+            new ShowMyExtendedStatsCallbackQueryHandler(null),
+            new ShowMyPacksCallbackQueryHandler(null),
+            new ShowMyRolesCallbackQueryHandler(null),
+            new StartGameCallbackQueryHandler(null),
+            new SwitchTimerCallbackQueryHandler(null),
+        };
+
+        public CallbackQueryHandler(Player player) : base(player) { }
+    }
+}

MafiaTelegramBot/Commands/CallbackQueries/ChangeNickNameCallbackQueryHandler.cs

@@ -0,0 +1,23 @@
+using System.Threading.Tasks;
+using MafiaTelegramBot.Commands.Messages;
+using MafiaTelegramBot.Controllers;
+using MafiaTelegramBot.Game;
+using MafiaTelegramBot.Resources;
+using Telegram.Bot.Types;
+
+namespace MafiaTelegramBot.Commands.CallbackQueries
+{
+    public class ChangeNickNameCallbackQueryHandler : CallbackQueryHandler
+    {
+        protected override string Command => Callback.ChangeNickName.ToString();
+
+        public override async Task<Message> Execute(Update update)
+        {
+            ChangeNicknameHandler.AddToQueue(User.Info.Id);
+            return await MessageController.EditMessage(User.Info,
+                update.CallbackQuery.Message.MessageId, strings.enter_your_name);
+        }
+
+        public ChangeNickNameCallbackQueryHandler(Player player) : base(player) { }
+    }
+}

MafiaTelegramBot/Commands/CallbackQueries/ChangeRolesCallbackQueryHandler.cs

@@ -0,0 +1,29 @@
+using System.Threading.Tasks;
+using MafiaTelegramBot.Controllers;
+using MafiaTelegramBot.Game;
+using MafiaTelegramBot.Game.GameRooms;
+using MafiaTelegramBot.Resources;
+using Telegram.Bot.Types;
+
+namespace MafiaTelegramBot.Commands.CallbackQueries
+{
+    public class ChangeRolesCallbackQueryHandler : CallbackQueryHandler
+    {
+        protected override string Command => Callback.ChangeRoles.ToString();
+        public override async Task<Message> Execute(Update update)
+        {
+            var roomKey = RoomEncrypter.GetCode(User.GetRoomName());
+            var room = (ExtendedGameRoom) RoomController.GetRoom(roomKey);
+            if(room == null) return await MessageController.EditMessage(User.Info,
+                update.CallbackQuery.Message.MessageId, strings.room_does_not_exists);
+            if(room.CustomRoomSettings.Count == 0) await room.InitSettings();
+            var message = $"{strings.current_enabled_roles}";
+            foreach (var (role, count) in room.CustomRoomSettings)
+                message += $"\n| {roles.ResourceManager.GetString(role.ToString())} ({count}) |";
+            return await MessageController.EditMessage(User.Info, update.CallbackQuery.Message.MessageId,
+                message, Keyboard.ChangeRolesKeyboard(roomKey, room));
+        }
+
+        public ChangeRolesCallbackQueryHandler(Player player) : base(player) { }
+    }
+}

MafiaTelegramBot/Commands/CallbackQueries/ChooseGameModeCallbackQueryHandler.cs

@@ -0,0 +1,25 @@
+using System.Threading.Tasks;
+using MafiaTelegramBot.Controllers;
+using MafiaTelegramBot.Game;
+using MafiaTelegramBot.Resources;
+using Telegram.Bot.Types;
+
+namespace MafiaTelegramBot.Commands.CallbackQueries
+{
+    public class ChooseGameModeCallbackQueryHandler : CallbackQueryHandler
+    {
+        protected override string Command => Callback.ChooseGameMode.ToString();
+
+        public override async Task<Message> Execute(Update update)
+        {
+            if (User.GetRoomName() != "")
+                return await MessageController.EditMessage(User.Info, update.CallbackQuery.Message.MessageId, strings.user_already_in_game);
+            var data = update.CallbackQuery.Data;
+            var param = data.Split('|');
+            return await MessageController.EditMessage(User.Info, update.CallbackQuery.Message.MessageId,
+                strings.choose_game_type, Keyboard.ChooseTypeKeyboard(param[1]));
+        }
+
+        public ChooseGameModeCallbackQueryHandler(Player player) : base(player) { }
+    }
+}

MafiaTelegramBot/Commands/CallbackQueries/ChooseGameTypeCallbackQueryHandler.cs

@@ -0,0 +1,28 @@
+using System.Threading.Tasks;
+using MafiaTelegramBot.Commands.Messages;
+using MafiaTelegramBot.Controllers;
+using MafiaTelegramBot.Game;
+using MafiaTelegramBot.Resources;
+using Telegram.Bot.Types;
+
+namespace MafiaTelegramBot.Commands.CallbackQueries
+{
+    public class ChooseGameTypeCallbackQueryHandler : CallbackQueryHandler
+    {
+        protected override string Command => Callback.ChooseGameType.ToString();
+
+        public override async Task<Message> Execute(Update update)
+        {
+            if (User.GetRoomName() != "")
+                return await MessageController.EditMessage(User.Info,
+                    update.CallbackQuery.Message.MessageId, strings.user_already_in_game);
+            var data = update.CallbackQuery.Data;
+            var param = data.Split('|');
+            CreateRoomHandler.AddToQueue(User.Info.Id, param[1]);
+            return await MessageController.EditMessage(User.Info,
+                update.CallbackQuery.Message.MessageId, strings.enter_room_name);
+        }
+
+        public ChooseGameTypeCallbackQueryHandler(Player player) : base(player) { }
+    }
+}

MafiaTelegramBot/Commands/CallbackQueries/ChooseRoomViewCallbackQueryHandler.cs

@@ -0,0 +1,26 @@
+using System.Threading.Tasks;
+using MafiaTelegramBot.Controllers;
+using MafiaTelegramBot.Game;
+using MafiaTelegramBot.Resources;
+using Telegram.Bot.Types;
+
+namespace MafiaTelegramBot.Commands.CallbackQueries
+{
+    public class ChooseRoomViewCallbackQueryHandler : CallbackQueryHandler
+    {
+        protected override string Command => Callback.ChooseRoomView.ToString();
+
+        public override async Task<Message> Execute(Update update)
+        {
+            if (User.GetRoomName() != "")
+                return await MessageController.EditMessage(User.Info,
+                    update.CallbackQuery.Message.MessageId, strings.user_already_in_game);
+            var data = update.CallbackQuery.Data;
+            var param = data.Split('|');
+            return await MessageController.EditMessage(User.Info, update.CallbackQuery.Message.MessageId,
+                strings.choose_game_mode, Keyboard.ChooseModeKeyboard(param[1]));
+        }
+
+        public ChooseRoomViewCallbackQueryHandler(Player player) : base(player) { }
+    }
+}

MafiaTelegramBot/Commands/CallbackQueries/ConnectToNotRankedCallbackQueryHandler.cs

@@ -0,0 +1,24 @@
+using System.Threading.Tasks;
+using MafiaTelegramBot.Controllers;
+using MafiaTelegramBot.Game;
+using MafiaTelegramBot.Resources;
+using Telegram.Bot.Types;
+
+namespace MafiaTelegramBot.Commands.CallbackQueries
+{
+    public class ConnectToNotRankedCallbackQueryHandler : CallbackQueryHandler
+    {
+        protected override string Command => Callback.ConnectToNotRanked.ToString();
+
+        public override async Task<Message> Execute(Update update)
+        {
+            if (User.GetRoomName() != "")
+                return await MessageController.EditMessage(User.Info,
+                    update.CallbackQuery.Message.MessageId, strings.user_already_in_game);
+            return await MessageController.EditMessage(User.Info, update.CallbackQuery.Message.MessageId,
+                strings.choose_view_room, Keyboard.RoomViewKeyboard(Callback.ConnectToPrivateRoom, Callback.ConnectToPublicRoom));
+        }
+
+        public ConnectToNotRankedCallbackQueryHandler(Player player) : base(player) { }
+    }
+}

MafiaTelegramBot/Commands/CallbackQueries/ConnectToPrivateRoomCallbackQueryHandler.cs

@@ -0,0 +1,23 @@
+using System.Threading.Tasks;
+using MafiaTelegramBot.Commands.Messages;
+using MafiaTelegramBot.Controllers;
+using MafiaTelegramBot.Game;
+using MafiaTelegramBot.Resources;
+using Telegram.Bot.Types;
+
+namespace MafiaTelegramBot.Commands.CallbackQueries
+{
+    public class ConnectToPrivateRoomCallbackQueryHandler : CallbackQueryHandler
+    {
+        protected override string Command => Callback.ConnectToPrivateRoom.ToString();
+
+        public override async Task<Message> Execute(Update update)
+        {
+            EnterCodeHandler.AddToQueue(User.Info.Id);
+            return await MessageController.EditMessage(User.Info,
+                update.CallbackQuery.Message.MessageId, strings.enter_private_code);
+        }
+
+        public ConnectToPrivateRoomCallbackQueryHandler(Player player) : base(player) { }
+    }
+}

MafiaTelegramBot/Commands/CallbackQueries/ConnectToPublicRoomCallbackQueryHandler.cs

@@ -0,0 +1,25 @@
+using System.Threading.Tasks;
+using MafiaTelegramBot.Controllers;
+using MafiaTelegramBot.Game;
+using MafiaTelegramBot.Resources;
+using Telegram.Bot.Types;
+
+namespace MafiaTelegramBot.Commands.CallbackQueries
+{
+    public class ConnectToPublicRoomCallbackQueryHandler : CallbackQueryHandler
+    {
+        protected override string Command => Callback.ConnectToPublicRoom.ToString();
+
+        public override async Task<Message> Execute(Update update)
+        {
+            var data = update.CallbackQuery.Data.Split('|');
+            var rooms = await RoomController.GetPublicNotRankedRooms();
+            if (rooms.Count == 0) return await MessageController.EditMessage(User.Info,
+                update.CallbackQuery.Message.MessageId, strings.public_rooms_are_not_exist);
+            return await MessageController.EditMessage(User.Info, update.CallbackQuery.Message.MessageId,
+                strings.rooms, Keyboard.RoomsKeyboard(rooms, int.Parse(data[1])));
+        }
+
+        public ConnectToPublicRoomCallbackQueryHandler(Player player) : base(player) { }
+    }
+}

MafiaTelegramBot/Commands/CallbackQueries/ConnectToRankedCallbackQueryHandler.cs

@@ -0,0 +1,31 @@
+using System.Threading.Tasks;
+using MafiaTelegramBot.Controllers;
+using MafiaTelegramBot.Game;
+using MafiaTelegramBot.Resources;
+using Telegram.Bot.Types;
+
+namespace MafiaTelegramBot.Commands.CallbackQueries
+{
+    public class ConnectToRankedCallbackQueryHandler : CallbackQueryHandler
+    {
+        protected override string Command => Callback.ConnectToRanked.ToString();
+
+        public override async Task<Message> Execute(Update update)
+        {
+            if (User.GetRoomName() != "")
+                return await MessageController.EditMessage(User.Info,
+                    update.CallbackQuery.Message.MessageId, strings.user_already_in_game);
+            var rooms = await RoomController.GetPublicRankedRooms(User.GetRank());
+            if (rooms.Count == 0) return await MessageController.EditMessage(User.Info,
+                update.CallbackQuery.Message.MessageId, strings.public_rooms_are_not_exist);
+            var roomKey = RoomEncrypter.GetCode(rooms[0].RoomName);
+            var resultCode = await RoomController.ConnectToGame(User, roomKey);
+            if (resultCode != ResultCode.CodeOk) return await MessageController.EditMessage(User.Info,
+                update.CallbackQuery.Message.MessageId,Utilities.GetResultCodeMessage(resultCode));
+            await MessageController.DeleteMessage(User.Info.ChatId, update.CallbackQuery.Message.MessageId);
+            return await MessageController.SendText(User.Info, strings.successful_entry_into_room, Keyboard.PlayerGameMenu);
+        }
+
+        public ConnectToRankedCallbackQueryHandler(Player player) : base(player) { }
+    }
+}

MafiaTelegramBot/Commands/CallbackQueries/ConnectToSelectedRoomCallbackQueryHandler.cs

@@ -0,0 +1,27 @@
+using System.Threading.Tasks;
+using MafiaTelegramBot.Controllers;
+using MafiaTelegramBot.Game;
+using MafiaTelegramBot.Resources;
+using Telegram.Bot.Types;
+
+namespace MafiaTelegramBot.Commands.CallbackQueries
+{
+    public class ConnectToSelectedRoomCallbackQueryHandler : CallbackQueryHandler
+    {
+        protected override string Command => Callback.ConnectToSelectedRoom.ToString();
+
+        public override async Task<Message> Execute(Update update)
+        {
+            var data = update.CallbackQuery.Data;
+            var param = data.Split('|');
+            var roomKey = param[1];
+            var resultCode = await RoomController.ConnectToGame(User, roomKey);
+            if (resultCode != ResultCode.CodeOk) return await MessageController.EditMessage(User.Info,
+                update.CallbackQuery.Message.MessageId,Utilities.GetResultCodeMessage(resultCode));
+            await MessageController.DeleteMessage(User.Info.ChatId, update.CallbackQuery.Message.MessageId);
+            return await MessageController.SendText(User.Info, strings.successful_entry_into_room, Keyboard.PlayerGameMenu);
+        }
+
+        public ConnectToSelectedRoomCallbackQueryHandler(Player player) : base(player) { }
+    }
+}

MafiaTelegramBot/Commands/CallbackQueries/ContinueCallbackQueryHandler.cs

@@ -0,0 +1,28 @@
+using System.Threading.Tasks;
+using MafiaTelegramBot.Controllers;
+using MafiaTelegramBot.CustomCollections.Extensions;
+using MafiaTelegramBot.Game;
+using MafiaTelegramBot.Game.GameRooms;
+using MafiaTelegramBot.Resources;
+using Telegram.Bot.Types;
+
+namespace MafiaTelegramBot.Commands.CallbackQueries
+{
+    public class ContinueCallbackQueryHandler : CallbackQueryHandler
+    {
+        protected override string Command => Callback.Continue.ToString();
+        public override async Task<Message> Execute(Update update)
+        {
+            var roomKey = RoomEncrypter.GetCode(User.GetRoomName());
+            var room = RoomController.GetRoom(roomKey);
+            if (room is not FastGameRoom r)
+                return await MessageController.EditMessage(User.Info,
+                    update.CallbackQuery.Message.MessageId, strings.unexpected_error);
+            r.ContinuePlayers.AddUnique(User);
+            return await MessageController.EditMessage(User.Info,
+                update.CallbackQuery.Message.MessageId, strings.you_continued_the_game);
+        }
+
+        public ContinueCallbackQueryHandler(Player player) : base(player) { }
+    }
+}

MafiaTelegramBot/Commands/CallbackQueries/GiveRoleCallbackQueryHandler.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Threading.Tasks;
+using MafiaTelegramBot.Controllers;
+using MafiaTelegramBot.DataBase.EntityDao;
+using MafiaTelegramBot.Game;
+using MafiaTelegramBot.Resources;
+using Telegram.Bot.Types;
+
+namespace MafiaTelegramBot.Commands.CallbackQueries
+{
+    public class GiveRoleCallbackQueryHandler : CallbackQueryHandler
+    {
+        protected override string Command => Callback.GiveRole.ToString();
+
+        public override async Task<Message> Execute(Update update)
+        {
+            var data = update.CallbackQuery.Data.Split('|');
+            var targetId = long.Parse(data[1]);
+            if (!Enum.TryParse(data[2], out Roles role))
+                return await MessageController.EditMessage(User.Info,
+                    update.CallbackQuery.Message.MessageId, strings.unexpected_error);
+            var target = await UserDao.GetPlayerById(targetId);
+            if (!target.OpenedRoles.TryOpenRole(role))
+                return await MessageController.EditMessage(User.Info,
+                    update.CallbackQuery.Message.MessageId, strings.user_now_has_role);
+            await MessageController.SendSticker(target.Info, Stickers.Sticker[role.ToString()]);
+            await MessageController.SendText(target.Info, $"{User.Info.NickName} {strings.gives_to_you_role} " +
+                                                          $"{roles.ResourceManager.GetString(role.ToString())}");
+            return await MessageController.EditMessage(User.Info, update.CallbackQuery.Message.MessageId,
+                $"{strings.role_successfully_issued_to} {target.Info.NickName}");
+        }
+
+        public GiveRoleCallbackQueryHandler(Player player) : base(player) { }
+    }
+}

MafiaTelegramBot/Commands/Inlines/GiveToAllQuery.cs → MafiaTelegramBot/Commands/CallbackQueries/GiveToAllCallbackQueryHandler.cs

@@ -1,26 +1,27 @@
 using System;
 using System.Linq;
 using System.Threading.Tasks;
+using MafiaTelegramBot.Controllers;
+using MafiaTelegramBot.Game;
 using MafiaTelegramBot.Resources;
 using Telegram.Bot.Types;
 
-namespace MafiaTelegramBot.Models.Inlines
+namespace MafiaTelegramBot.Commands.CallbackQueries
 {
-    public class GiveToAllQuery : Query
+    public class GiveToAllCallbackQueryHandler : CallbackQueryHandler
     {
-        protected override Callback Name => Callback.GiveToAll;
-        protected override async Task<Message> Execute(Update update)
+        protected override string Command => Callback.GiveToAll.ToString();
+        public override async Task<Message> Execute(Update update)
         {
-            await DeletePreviousMessage(ChatId, update.CallbackQuery.Message.MessageId);
-            var msg1 = String.Format(strings.giveaway_sample_message, keywords.giveaway,
+            await MessageController.DeleteMessage(User.Info.ChatId, update.CallbackQuery.Message.MessageId);
+            
+            var msg1 = string.Format(strings.giveaway_sample_message, keywords.giveaway,
                 keywords.message, keywords.picture, keywords.button, keywords.prize, keywords.count, keywords.to);
-            msg1 = msg1.Replace("\\n", "\\\n");
-            await Bot.SendWithMarkdown2(ChatId, msg1);
+            await MessageController.SendText(User.Info, msg1.Replace("\\n", "\\\n"));
             
-            var msg2 = String.Format(strings.giveaway_attentions, keywords.to, keywords.message,
+            var msg2 = string.Format(strings.giveaway_attentions, keywords.to, keywords.message,
                 keywords.picture, keywords.count, keywords.picture, keywords.prize);
-            msg2 = msg2.Replace("\\n", "\\\n");
-            await Bot.SendWithMarkdown2(ChatId, msg2);
+            await MessageController.SendText(User.Info, msg2.Replace("\\n", "\\\n"));
             
             var msg3 = strings.list_of_roles;
             var rolesList = Enum.GetValues(typeof(Roles)).Cast<Roles>().ToList();
@@ -28,7 +29,9 @@ namespace MafiaTelegramBot.Models.Inlines
             msg3 += $"\n`{Roles.All}` - {strings.use_this_to_random_giveaway}";
             foreach (var role in rolesList)
                 msg3 += $"\n{roles.ResourceManager.GetString(role.ToString())} - `{role}`";
-            return await Bot.SendWithMarkdown2(ChatId, msg3);
+            return await MessageController.SendText(User.Info, msg3);
         }
+
+        public GiveToAllCallbackQueryHandler(Player player) : base(player) { }
     }
 }

MafiaTelegramBot/Commands/CallbackQueries/GiveToSelectedCallbackQueryHandler.cs

@@ -0,0 +1,23 @@
+using System.Threading.Tasks;
+using MafiaTelegramBot.Commands.Messages;
+using MafiaTelegramBot.Controllers;
+using MafiaTelegramBot.Game;
+using MafiaTelegramBot.Resources;
+using Telegram.Bot.Types;
+
+namespace MafiaTelegramBot.Commands.CallbackQueries
+{
+    public class GiveToSelectedCallbackQueryHandler : CallbackQueryHandler
+    {
+        protected override string Command => Callback.GiveToSelected.ToString();
+        
+        public override async Task<Message> Execute(Update update)
+        {
+            GiveRoleToPlayerHandler.AddToQueue(User.Info.Id);
+            return await MessageController.EditMessage(User.Info,
+                update.CallbackQuery.Message.MessageId, strings.enter_username);
+        }
+
+        public GiveToSelectedCallbackQueryHandler(Player player) : base(player) { }
+    }
+}

MafiaTelegramBot/Commands/CallbackQueries/KickSelectedPlayerCallbackQueryHandler.cs

@@ -0,0 +1,24 @@
+using System.Threading.Tasks;
+using MafiaTelegramBot.Controllers;
+using MafiaTelegramBot.Game;
+using MafiaTelegramBot.Resources;
+using Telegram.Bot.Types;
+
+namespace MafiaTelegramBot.Commands.CallbackQueries
+{
+    public class KickSelectedPlayerCallbackQueryHandler : CallbackQueryHandler
+    {
+        protected override string Command => Callback.KickUser.ToString();
+        public override async Task<Message> Execute(Update update)
+        {
+            var resultCode = await RoomController.LeaveFromGame(User);
+            if (resultCode != ResultCode.CodeOk) return await MessageController.EditMessage(User.Info,
+                update.CallbackQuery.Message.MessageId, Utilities.GetResultCodeMessage(resultCode));
+            await MessageController.DeleteMessage(User.Info.ChatId, update.CallbackQuery.Message.MessageId);
+            return await MessageController.SendText(User.Info, $"{strings.you_were_kicked}",
+                User.Info.IsAdmin ? Keyboard.AdminMainMenu : Keyboard.MainMenu);
+        }
+
+        public KickSelectedPlayerCallbackQueryHandler(Player player) : base(player) { }
+    }
+}

MafiaTelegramBot/Commands/CallbackQueries/PackInfoCallbackQueryHandler.cs

@@ -0,0 +1,20 @@
+using System.Threading.Tasks;
+using MafiaTelegramBot.Controllers;
+using MafiaTelegramBot.Game;
+using MafiaTelegramBot.Resources;
+using Telegram.Bot.Types;
+
+namespace MafiaTelegramBot.Commands.CallbackQueries
+{
+    public class PackInfoCallbackQueryHandler : CallbackQueryHandler
+    {
+        protected override string Command => Callback.PackInfo.ToString();
+        public override async Task<Message> Execute(Update update)
+        {
+            return await MessageController.EditMessage(User.Info, update.CallbackQuery.Message.MessageId,
+                strings.pack_information.Replace("\\n", "\\\n"));
+        }
+
+        public PackInfoCallbackQueryHandler(Player player) : base(player) { }
+    }
+}

MafiaTelegramBot/Commands/CallbackQueries/PackOpenCallbackQueryHandler.cs

@@ -0,0 +1,68 @@
+using System.Linq;
+using System.Threading.Tasks;
+using MafiaTelegramBot.Controllers;
+using MafiaTelegramBot.DataBase.Entity;
+using MafiaTelegramBot.Game;
+using MafiaTelegramBot.Resources;
+using Telegram.Bot.Types;
+
+namespace MafiaTelegramBot.Commands.CallbackQueries
+{
+    public class PackOpenCallbackQueryHandler : CallbackQueryHandler
+    {
+        protected override string Command => Callback.PackOpen.ToString();
+        public override async Task<Message> Execute(Update update)
+        {
+            if (User.Info.PackCount <= 0) return await MessageController.EditMessage(User.Info,
+                update.CallbackQuery.Message.MessageId, strings.you_havent_pack);
+            User.Info.PackCount--;
+            var baseRole = await GetRandomBaseRole(User.OpenedRoles);
+            if (User.OpenedRoles.TryOpenRole(baseRole))
+            {
+                await MessageController.SendSticker(User.Info, Stickers.Sticker[baseRole.ToString()]);
+                await MessageController.EditMessage(User.Info, update.CallbackQuery.Message.MessageId,
+                    $"{strings.congratulations_you_open_role} {roles.ResourceManager.GetString(baseRole.ToString())}");
+            }
+            else await MessageController.EditMessage(User.Info, update.CallbackQuery.Message.MessageId,
+                $"{strings.you_got_role} {roles.ResourceManager.GetString(baseRole.ToString())} ({strings.now_opened})");
+            
+            var addRole = await GetRandomRole();
+            if (addRole == Roles.None) return new Message();
+            
+            if (!User.OpenedRoles.TryOpenRole(addRole))
+                return await MessageController.SendText(User.Info,
+                    $"{strings.you_got_role} {roles.ResourceManager.GetString(addRole.ToString())} ({strings.now_opened})");
+            await MessageController.SendSticker(User.Info, Stickers.Sticker[addRole.ToString()]);
+            return await MessageController.SendText(User.Info, $"{strings.congratulations_you_open_role} {roles.ResourceManager.GetString(addRole.ToString())}");
+        }
+        
+        private static Task<Roles> GetRandomBaseRole(OpenedRolesEntity openedRoles)
+        {
+            return Task.Run(() =>
+            {
+                var allOpened = openedRoles.Hooker && openedRoles.Bodyguard && openedRoles.Elder && openedRoles.Werewolf;
+                if (allOpened)
+                    return Utilities.TierDictionary[2][Utilities.Rnd.Next(Utilities.TierDictionary[2].Count)];
+                var notOpened = Utilities.TierDictionary[2].Except(openedRoles.ToList()).ToArray();
+                return notOpened[Utilities.Rnd.Next(notOpened.Length)];
+            });
+        }
+
+        private static Task<Roles> GetRandomRole()
+        {
+            return Task.Run(() =>
+            {
+                var chance = Utilities.Rnd.Next(100);
+                return chance switch
+                {
+                    <1 => Utilities.TierDictionary[5][Utilities.Rnd.Next(Utilities.TierDictionary[5].Count)],
+                    <5 => Utilities.TierDictionary[4][Utilities.Rnd.Next(Utilities.TierDictionary[4].Count)],
+                    <25 => Utilities.TierDictionary[3][Utilities.Rnd.Next(Utilities.TierDictionary[3].Count)],
+                    _ => Roles.None
+                };
+            });
+        }
+
+        public PackOpenCallbackQueryHandler(Player player) : base(player) { }
+    }
+}

MafiaTelegramBot/Commands/CallbackQueries/PlayersCountSettingsCallbackQueryHandler.cs

@@ -0,0 +1,29 @@
+using System.Threading.Tasks;
+using MafiaTelegramBot.Controllers;
+using MafiaTelegramBot.Game;
+using MafiaTelegramBot.Resources;
+using Telegram.Bot.Types;
+
+namespace MafiaTelegramBot.Commands.CallbackQueries
+{
+    public class PlayersCountSettingsCallbackQueryHandler : CallbackQueryHandler
+    {
+        protected override string Command => Callback.PlayersCount.ToString();
+        
+        public override async Task<Message> Execute(Update update)
+        {
+            var roomKey = RoomEncrypter.GetCode(User.GetRoomName());
+            var room = RoomController.GetRoom(roomKey);
+            if(room == null)
+                return await MessageController.EditMessage(User.Info,
+                    update.CallbackQuery.Message.MessageId, strings.room_does_not_exists);
+            var roomMaxCapacity = room.MaxPlayers;
+            return await MessageController.EditMessage(User.Info, update.CallbackQuery.Message.MessageId,
+                $"{strings.max_capacity_message}: {roomMaxCapacity}", Keyboard.SetMaximumKeyboard());
+        }
+
+        public PlayersCountSettingsCallbackQueryHandler(Player player) : base(player)
+        {
+        }
+    }
+}

MafiaTelegramBot/Commands/CallbackQueries/SetPlayersMaximumCallbackQueryHandler.cs

@@ -0,0 +1,29 @@
+using System.Threading.Tasks;
+using MafiaTelegramBot.Controllers;
+using MafiaTelegramBot.Game;
+using MafiaTelegramBot.Resources;
+using Telegram.Bot.Types;
+
+namespace MafiaTelegramBot.Commands.CallbackQueries
+{
+    public class SetPlayersMaximumCallbackQueryHandler : CallbackQueryHandler
+    {
+        protected override string Command => Callback.SetPlayersMaximum.ToString();
+
+        public override async Task<Message> Execute(Update update)
+        {
+            var data = update.CallbackQuery.Data;
+            var count = int.Parse(data.Split('|')[1]);
+            var roomKey = RoomEncrypter.GetCode(User.GetRoomName());
+            var room = RoomController.GetRoom(roomKey);
+            if(room == null) return await MessageController.EditMessage(User.Info,
+                update.CallbackQuery.Message.MessageId, strings.room_does_not_exists);
+            room.MaxPlayers = count;
+            var message = $"{strings.maximum_was_set_to}: {count} {strings.players}";
+            return await MessageController.EditMessage(User.Info,
+                update.CallbackQuery.Message.MessageId, message);
+        }
+
+        public SetPlayersMaximumCallbackQueryHandler(Player player) : base(player) { }
+    }
+}

MafiaTelegramBot/Commands/CallbackQueries/SettingsProfileCallbackQueryHandler.cs

@@ -0,0 +1,21 @@
+using System.Threading.Tasks;
+using MafiaTelegramBot.Controllers;
+using MafiaTelegramBot.Game;
+using MafiaTelegramBot.Resources;
+using Telegram.Bot.Types;
+
+namespace MafiaTelegramBot.Commands.CallbackQueries
+{
+    public class SettingsProfileCallbackQueryHandler : CallbackQueryHandler
+    {
+        protected override string Command => Callback.SettingsProfile.ToString();
+
+        public override async Task<Message> Execute(Update update)
+        {
+            return await MessageController.EditMessage(User.Info, update.CallbackQuery.Message.MessageId, 
+                $"{strings.your_name} {User.Info.NickName}", Keyboard.ChangeNameKeyboard());
+        }
+
+        public SettingsProfileCallbackQueryHandler(Player player) : base(player) { }
+    }
+}

MafiaTelegramBot/Commands/CallbackQueries/SettingsRoomCallbackQueryHandler.cs

@@ -0,0 +1,21 @@
+using System.Threading.Tasks;
+using MafiaTelegramBot.Controllers;
+using MafiaTelegramBot.Game;
+using MafiaTelegramBot.Resources;
+using Telegram.Bot.Types;
+
+namespace MafiaTelegramBot.Commands.CallbackQueries
+{
+    public class SettingsRoomCallbackQueryHandler : CallbackQueryHandler
+    {
+        protected override string Command => Callback.SettingsRoom.ToString();
+
+        public override async Task<Message> Execute(Update update)
+        {
+            return await MessageController.EditMessage(User.Info,
+                update.CallbackQuery.Message.MessageId, strings.settings_room);
+        }
+
+        public SettingsRoomCallbackQueryHandler(Player player) : base(player) { }
+    }
+}

MafiaTelegramBot/Commands/Inlines/ShopMenuQuery.cs → MafiaTelegramBot/Commands/CallbackQueries/ShopMenuCallbackQueryHandler.cs

@@ -1,24 +1,27 @@
 using System.Threading.Tasks;
-using MafiaTelegramBot.DataBase.EntityDao;
+using MafiaTelegramBot.Controllers;
+using MafiaTelegramBot.Game;
 using MafiaTelegramBot.Resources;
 using Telegram.Bot.Types;
 
-namespace MafiaTelegramBot.Models.Inlines
+namespace MafiaTelegramBot.Commands.CallbackQueries
 {
-    public class ShopMenuQuery : Query
+    public class ShopMenuCallbackQueryHandler : CallbackQueryHandler
     {
-        protected override Callback Name => Callback.ShopMenu;
+        protected override string Command => Callback.ShopMenu.ToString();
 
-        protected override async Task<Message> Execute(Update update)
+        public override async Task<Message> Execute(Update update)
         {
-            await DeletePreviousMessage(ChatId, update.CallbackQuery.Message.MessageId);
             // var user = await UserDao.GetPlayerById(UserId);
             // if (user.OpenedRoles.AllRolesOpened())
             //     return await Bot.SendWithMarkdown2(ChatId, strings.you_already_open_all_roles);
             // return await Bot.Get().SendInvoiceAsync(ChatId, strings.random_role_payment,
             //     strings.random_role_description, $"{Payloads.RandomRole}|{UserId}",
             //     AppSettings.ProviderToken, Constants.SHOP_CURRENCY, Constants.RANDOM_ROLE_PRICE);
-            return await Bot.SendWithMarkdown2(ChatId, strings.work_in_progress, Keyboard.BackButton(UserId));
+            return await MessageController.EditMessage(User.Info,
+                update.CallbackQuery.Message.MessageId, strings.work_in_progress, Keyboard.BackButton());
         }
+
+        public ShopMenuCallbackQueryHandler(Player player) : base(player) { }
     }
 }

MafiaTelegramBot/Commands/CallbackQueries/ShowMyExtendedStatsCallbackQueryHandler.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using MafiaTelegramBot.Controllers;
+using MafiaTelegramBot.Game;
+using MafiaTelegramBot.Resources;
+using Telegram.Bot.Types;
+
+namespace MafiaTelegramBot.Commands.CallbackQueries
+{
+    public class ShowMyExtendedStatsCallbackQueryHandler : CallbackQueryHandler
+    {
+        protected override string Command => Callback.ShowMyExtendedStats.ToString();
+
+        public override async Task<Message> Execute(Update update)
+        {
+            var rolesList = Enum.GetValues(typeof(Roles)).Cast<Roles>().ToList();
+            rolesList.Remove(Roles.None);
+            rolesList.Remove(Roles.All);
+            var message = "";
+            if (User.Statistics[Roles.All].Games > 0)
+                foreach (var role in rolesList)
+                {
+                    if (!User.Statistics.Contains(role) || User.Statistics[role].Games <= 0) continue;
+                    var statsRow = User.Statistics[role];
+                    message += string.Format(strings.role_string, roles.ResourceManager.GetString(role.ToString()), statsRow.Wins, statsRow.Games, (int) (statsRow.GetWinrate()*100)) + '\n';
+                }
+            else
+                message += strings.no_stats_by_roles;
+            return await MessageController.EditMessage(User.Info,
+                update.CallbackQuery.Message.MessageId, message, Keyboard.BackButton());
+        }
+
+        public ShowMyExtendedStatsCallbackQueryHandler(Player player) : base(player) { }
+    }
+}

MafiaTelegramBot/Commands/CallbackQueries/ShowMyPacksCallbackQueryHandler.cs

@@ -0,0 +1,21 @@
+using System.Threading.Tasks;
+using MafiaTelegramBot.Controllers;
+using MafiaTelegramBot.Game;
+using MafiaTelegramBot.Resources;
+using Telegram.Bot.Types;
+
+namespace MafiaTelegramBot.Commands.CallbackQueries
+{
+    public class ShowMyPacksCallbackQueryHandler : CallbackQueryHandler
+    {
+        protected override string Command => Callback.ShowMyPacks.ToString();
+        public override async Task<Message> Execute(Update update)
+        {
+            await MessageController.SendSticker(User.Info, Stickers.Sticker["Pool"]);
+            return await MessageController.EditMessage(User.Info, update.CallbackQuery.Message.MessageId, 
+                $"{strings.your_packs} {User.Info.PackCount}", Keyboard.PackKeyboard());
+        }
+
+        public ShowMyPacksCallbackQueryHandler(Player player) : base(player) { }
+    }
+}

MafiaTelegramBot/Commands/Inlines/ShowMyRolesQuery.cs → MafiaTelegramBot/Commands/CallbackQueries/ShowMyRolesCallbackQueryHandler.cs

@@ -1,21 +1,20 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
-using MafiaTelegramBot.DataBase.EntityDao;
+using MafiaTelegramBot.Controllers;
+using MafiaTelegramBot.Game;
 using MafiaTelegramBot.Resources;
 using Telegram.Bot.Types;
 
-namespace MafiaTelegramBot.Models.Inlines
+namespace MafiaTelegramBot.Commands.CallbackQueries
 {
-    public class ShowMyRolesQuery : Query
+    public class ShowMyRolesCallbackQueryHandler : CallbackQueryHandler
     {
-        protected override Callback Name => Callback.ShowMyRoles;
+        protected override string Command => Callback.ShowMyRoles.ToString();
 
-        protected override async Task<Message> Execute(Update update)
+        public override async Task<Message> Execute(Update update)
         {
-            await DeletePreviousMessage(ChatId, update.CallbackQuery.Message.MessageId);
-            var user = await UserDao.GetPlayerById(UserId);
-            var opened = user.OpenedRoles.ToList();
+            var opened = User.OpenedRoles.ToList();
             var tier2 = Utilities.TierDictionary[2].Intersect(opened).ToList();
             var tier3 = Utilities.TierDictionary[3].Intersect(opened).ToList();
             var tier4 = Utilities.TierDictionary[4].Intersect(opened).ToList();
@@ -31,15 +30,18 @@ namespace MafiaTelegramBot.Models.Inlines
                 message += AddMessage(tier4, strings.epic);
             if (tier5.Count > 0)
                 message += AddMessage(tier5, strings.legendary);
-            return await Bot.SendWithMarkdown2(ChatId, message, Keyboard.BackButton(UserId));
+            return await MessageController.EditMessage(User.Info,
+                update.CallbackQuery.Message.MessageId, message, Keyboard.BackButton());
         }
 
-        private string AddMessage(List<Roles> list, string rarity)
+        private static string AddMessage(List<Roles> list, string rarity)
         {
             var result = $"\n\n{strings.rarity}: {rarity}";
             foreach (var role in list)
                 result += $"\n{roles.ResourceManager.GetString(role.ToString())}";
             return result;
         }
+
+        public ShowMyRolesCallbackQueryHandler(Player player) : base(player) { }
     }
 }

MafiaTelegramBot/Commands/CallbackQueries/StartGameCallbackQueryHandler.cs

@@ -0,0 +1,30 @@
+using System.Threading.Tasks;
+using MafiaTelegramBot.Controllers;
+using MafiaTelegramBot.Game;
+using MafiaTelegramBot.Resources;
+using Telegram.Bot.Types;
+
+namespace MafiaTelegramBot.Commands.CallbackQueries
+{
+    public class StartGameCallbackQueryHandler : CallbackQueryHandler
+    {
+        protected override string Command => Callback.StartGame.ToString();
+        public override async Task<Message> Execute(Update update)
+        {
+            var roomKey = RoomEncrypter.GetCode(User.GetRoomName());
+            var room = RoomController.GetRoom(roomKey);
+            if(room == null)
+                return await MessageController.EditMessage(User.Info,
+                    update.CallbackQuery.Message.MessageId, strings.room_does_not_exists);
+            var result = await MessageController.EditMessage(User.Info,
+                update.CallbackQuery.Message.MessageId, strings.game_process_started);
+            var resultCode = await room.Prepare();
+            if (resultCode != ResultCode.CodeOk) return await MessageController.EditMessage(User.Info,
+                update.CallbackQuery.Message.MessageId,Utilities.GetResultCodeMessage(resultCode));
+            room.Start();
+            return result;
+        }
+
+        public StartGameCallbackQueryHandler(Player player) : base(player) { }
+    }
+}

MafiaTelegramBot/Commands/CallbackQueries/SwitchTimerCallbackQueryHandler.cs

@@ -0,0 +1,27 @@
+using System.Threading.Tasks;
+using MafiaTelegramBot.Controllers;
+using MafiaTelegramBot.Game;
+using MafiaTelegramBot.Resources;
+using Telegram.Bot.Types;
+
+namespace MafiaTelegramBot.Commands.CallbackQueries
+{
+    public class SwitchTimerCallbackQueryHandler : CallbackQueryHandler
+    {
+        protected override string Command => Callback.SwitchTimer.ToString();
+        public override async Task<Message> Execute(Update update)
+        {
+            var roomName = User.GetRoomName();
+            var roomKey = RoomEncrypter.GetCode(roomName);
+            var room = RoomController.GetRoom(roomKey);
+            if(room == null) return await MessageController.EditMessage(User.Info,
+                update.CallbackQuery.Message.MessageId, strings.room_does_not_exists);
+            room.TimerEnabled = !room.TimerEnabled;
+            var status = room.TimerEnabled ? strings.enabled : strings.disabled;
+            return await MessageController.EditMessage(User.Info,
+                update.CallbackQuery.Message.MessageId, $"{strings.timer}: {status}");
+        }
+
+        public SwitchTimerCallbackQueryHandler(Player player) : base(player) { }
+    }
+}

MafiaTelegramBot/Commands/CallbackQueries/UserInGameCallbackQueryHandler.cs

@@ -0,0 +1,23 @@
+using System.Threading.Tasks;
+using MafiaTelegramBot.Game;
+using Telegram.Bot.Types;
+
+namespace MafiaTelegramBot.Commands.CallbackQueries
+{
+    public class UserInGameCallbackQueryHandler : CallbackQueryHandler
+    {
+        protected override string Command => "";
+
+        public override Task<Message> Execute(Update update)
+        {
+            return base.Execute(update);
+        }
+
+        protected override bool IsMatches(string command)
+        {
+            return User != null ? User.GetRoomName() != "" : base.IsMatches(command);
+        }
+
+        public UserInGameCallbackQueryHandler(Player player) : base(player) { }
+    }
+}

MafiaTelegramBot/Commands/ChannelPost/ChannelPost.cs

@@ -2,6 +2,7 @@
 using System;
 using System.Threading.Tasks;
 using System.Timers;
+using MafiaTelegramBot.Commands;
 using MafiaTelegramBot.Resources;
 using Telegram.Bot.Types;
 

MafiaTelegramBot/Commands/Messages/CommandNotFoundMessageHandler.cs → MafiaTelegramBot/Commands/CommandNotFound.cs

@@ -1,19 +1,24 @@
 using System.Threading.Tasks;
+using MafiaTelegramBot.Commands.Messages;
 using MafiaTelegramBot.Controllers;
 using MafiaTelegramBot.Game;
 using Telegram.Bot.Types;
 
-namespace MafiaTelegramBot.Commands.Messages
+namespace MafiaTelegramBot.Commands
 {
     public class CommandNotFound : MessageHandler
     {
         protected override string Command => "";
+        private string _command;
         
         public override async Task<Message> Execute(Update update)
         {
-            return await MessageController.SendText(User.Info, $"{strings.command_not_found} {update.Message.Text}");
+            return await MessageController.SendText(User.Info, $"{strings.command_not_found} {_command}");
         }
 
-        public CommandNotFound(Player player) : base(player) { }
+        public CommandNotFound(Player player, string command) : base(player)
+        {
+            _command = command;
+        }
     }
 }

MafiaTelegramBot/Commands/Inlines/BackToProfileQuery.cs

@@ -1,30 +0,0 @@
-using System;
-using System.Linq;
-using System.Threading.Tasks;
-using MafiaTelegramBot.DataBase.EntityDao;
-using MafiaTelegramBot.Resources;
-using Telegram.Bot.Types;
-
-namespace MafiaTelegramBot.Models.Inlines
-{
-    public class BackToProfileQuery : Query
-    {
-        protected override Callback Name => Callback.BackToProfile;
-        protected override async Task<Message> Execute(Update update)
-        {
-            await DeletePreviousMessage(ChatId, update.CallbackQuery.Message.MessageId);
-            var user = await UserDao.GetPlayerById(UserId);
-            var rolesList = Enum.GetValues(typeof(Roles)).Cast<Roles>().ToList();
-            rolesList.Remove(Roles.None);
-            rolesList.Remove(Roles.All);
-            var allStatsRow = user.Statistics[Roles.All];
-            var message =
-                $"__*{strings.statistics_for} _{user.NickName}_*__\n" +
-                $"{strings.games_count} {allStatsRow.Games}\n" +
-                $"{strings.wins_count} {allStatsRow.Wins}\n" +
-                $"{strings.winrate} {(int)(allStatsRow.GetWinrate()*100)}%\n" +
-                $"{strings.rate} {user.RankNumber}";
-            return await Bot.SendWithMarkdown2(ChatId, message, Keyboard.ProfileKeyboard(UserId));
-        }
-    }
-}

MafiaTelegramBot/Commands/Inlines/ChangeNickNameQuery.cs

@@ -1,18 +0,0 @@
-using System.Threading.Tasks;
-using MafiaTelegramBot.Resources;
-using Telegram.Bot.Types;
-
-namespace MafiaTelegramBot.Models.Inlines
-{
-    public class ChangeNickNameQuery : Query
-    {
-        protected override Callback Name => Callback.ChangeNickName;
-
-        protected override async Task<Message> Execute(Update update)
-        {
-            await DeletePreviousMessage(ChatId, update.CallbackQuery.Message.MessageId);
-            Bot.UsersThatChangesNickname.Add(UserId);
-            return await Bot.SendWithMarkdown2(ChatId, strings.enter_your_name);
-        }
-    }
-}

MafiaTelegramBot/Commands/Inlines/ChangeRolesQuery.cs

@@ -1,29 +0,0 @@
-using System.Threading.Tasks;
-using MafiaTelegramBot.Controllers;
-using MafiaTelegramBot.DataBase.EntityDao;
-using MafiaTelegramBot.Game;
-using MafiaTelegramBot.Game.GameRooms;
-using MafiaTelegramBot.Resources;
-using Telegram.Bot.Types;
-
-namespace MafiaTelegramBot.Models.Inlines
-{
-    public class ChangeRolesQuery : Query
-    {
-        protected override Callback Name => Callback.ChangeRoles;
-        protected override async Task<Message> Execute(Update update)
-        {
-            await DeletePreviousMessage(ChatId, update.CallbackQuery.Message.MessageId);
-            var user = await UserDao.GetPlayerById(UserId);
-            var roomKey = RoomEncrypter.GetCode(user.GetRoomName());
-            var room = (ExtendedGameRoom) RoomController.GetRoom(roomKey);
-            if(room == null)
-                return await Bot.SendWithMarkdown2(ChatId, strings.room_does_not_exists);
-            if(room.CustomRoomSettings.Count == 0) await room.InitSettings();
-            var message = $"{strings.current_enabled_roles}";
-            foreach (var (role, count) in room.CustomRoomSettings)
-                message += $"\n| {roles.ResourceManager.GetString(role.ToString())} ({count}) |";
-            return await Bot.SendWithMarkdown2(ChatId, message, Keyboard.ChangeRolesKeyboard(UserId, roomKey, room));
-        }
-    }
-}

MafiaTelegramBot/Commands/Inlines/ChooseGameModeQuery.cs

@@ -1,23 +0,0 @@
-using System.Threading.Tasks;
-using MafiaTelegramBot.DataBase.EntityDao;
-using MafiaTelegramBot.Resources;
-using Telegram.Bot.Types;
-
-namespace MafiaTelegramBot.Models.Inlines
-{
-    public class ChooseGameModeQuery : Query
-    {
-        protected override Callback Name => Callback.ChooseGameMode;
-
-        protected override async Task<Message> Execute(Update update)
-        {
-            await DeletePreviousMessage(ChatId, update.CallbackQuery.Message.MessageId);
-            var user = await UserDao.GetPlayerById(UserId);
-            if (user.GetRoomName() != "")
-                return await Bot.SendWithMarkdown2(ChatId, strings.user_already_in_game);
-            var data = update.CallbackQuery.Data;
-            var param = data.Split('|');
-            return await Bot.SendWithMarkdown2(ChatId, strings.choose_game_type, Keyboard.ChooseTypeKeyboard(UserId, param[2]));
-        }
-    }
-}

MafiaTelegramBot/Commands/Inlines/ChooseGameTypeQuery.cs

@@ -1,26 +0,0 @@
-using System;
-using System.Threading.Tasks;
-using MafiaTelegramBot.DataBase.EntityDao;
-using MafiaTelegramBot.Resources;
-using Telegram.Bot.Types;
-
-namespace MafiaTelegramBot.Models.Inlines
-{
-    public class ChooseGameTypeQuery : Query
-    {
-        protected override Callback Name => Callback.ChooseGameType;
-
-        protected override async Task<Message> Execute(Update update)
-        {
-            await DeletePreviousMessage(ChatId, update.CallbackQuery.Message.MessageId);
-            var user = await UserDao.GetPlayerById(UserId);
-            if (user.GetRoomName() != "")
-                return await Bot.SendWithMarkdown2(ChatId, strings.user_already_in_game);
-            var data = update.CallbackQuery.Data;
-            var param = data.Split('|');
-            if (!Bot.UsersThatCreatesRoom.TryAdd(UserId, param[2]))
-                Bot.UsersThatCreatesRoom[UserId] = param[2];
-            return await Bot.SendWithMarkdown2(ChatId, strings.enter_room_name);
-        }
-    }
-}

MafiaTelegramBot/Commands/Inlines/ChooseRoomViewQuery.cs

@@ -1,23 +0,0 @@
-using System.Threading.Tasks;
-using MafiaTelegramBot.DataBase.EntityDao;
-using MafiaTelegramBot.Resources;
-using Telegram.Bot.Types;
-
-namespace MafiaTelegramBot.Models.Inlines
-{
-    public class ChooseRoomViewQuery : Query
-    {
-        protected override Callback Name => Callback.ChooseRoomView;
-
-        protected override async Task<Message> Execute(Update update)
-        {
-            await DeletePreviousMessage(ChatId, update.CallbackQuery.Message.MessageId);
-            var user = await UserDao.GetPlayerById(UserId);
-            if (user.GetRoomName() != "")
-                return await Bot.SendWithMarkdown2(ChatId, strings.user_already_in_game);
-            var data = update.CallbackQuery.Data;
-            var param = data.Split('|');
-            return await Bot.SendWithMarkdown2(ChatId, strings.choose_game_mode, Keyboard.ChooseModeKeyboard(UserId, param[2]));
-        }
-    }
-}

MafiaTelegramBot/Commands/Inlines/ConnectToNotRankedQuery.cs

@@ -1,22 +0,0 @@
-using System.Threading.Tasks;
-using MafiaTelegramBot.DataBase.EntityDao;
-using MafiaTelegramBot.Resources;
-using Telegram.Bot.Types;
-
-namespace MafiaTelegramBot.Models.Inlines
-{
-    public class ConnectToNotRankedQuery : Query
-    {
-        protected override Callback Name => Callback.ConnectToNotRanked;
-
-        protected override async Task<Message> Execute(Update update)
-        {
-            await DeletePreviousMessage(ChatId, update.CallbackQuery.Message.MessageId);
-            var user = await UserDao.GetPlayerById(UserId);
-            if (user.GetRoomName() != "")
-                return await Bot.SendWithMarkdown2(ChatId, strings.user_already_in_game);
-            return await Bot.SendWithMarkdown2(ChatId, strings.choose_view_room, 
-                Keyboard.RoomViewKeyboard(UserId, Callback.ConnectToPrivateRoom, Callback.ConnectToPublicRoom));
-        }
-    }
-}

MafiaTelegramBot/Commands/Inlines/ConnectToPrivateRoomQuery.cs

@@ -1,18 +0,0 @@
-using System.Threading.Tasks;
-using MafiaTelegramBot.Resources;
-using Telegram.Bot.Types;
-
-namespace MafiaTelegramBot.Models.Inlines
-{
-    public class ConnectToPrivateRoomQuery : Query
-    {
-        protected override Callback Name => Callback.ConnectToPrivateRoom;
-
-        protected override async Task<Message> Execute(Update update)
-        {
-            await DeletePreviousMessage(ChatId, update.CallbackQuery.Message.MessageId);
-            Bot.UserThatEntersPrivateCode.Add(UserId);
-            return await Bot.SendWithMarkdown2(ChatId, strings.enter_private_code);
-        }
-    }
-}

MafiaTelegramBot/Commands/Inlines/ConnectToPublicRoomQuery.cs

@@ -1,21 +0,0 @@
-using System.Threading.Tasks;
-using MafiaTelegramBot.Controllers;
-using MafiaTelegramBot.Resources;
-using Telegram.Bot.Types;
-
-namespace MafiaTelegramBot.Models.Inlines
-{
-    public class ConnectToPublicRoomQuery : Query
-    {
-        protected override Callback Name => Callback.ConnectToPublicRoom;
-
-        protected override async Task<Message> Execute(Update update)
-        {
-            await DeletePreviousMessage(ChatId, update.CallbackQuery.Message.MessageId);
-            var data = update.CallbackQuery.Data.Split('|');
-            var rooms = await RoomController.GetPublicNotRankedRooms();
-            if (rooms.Count == 0) return await Bot.SendWithMarkdown2(ChatId, strings.public_rooms_are_not_exist);
-            return await Bot.SendWithMarkdown2(ChatId, strings.rooms, Keyboard.RoomsKeyboard(rooms, UserId, int.Parse(data[2])));
-        }
-    }
-}

MafiaTelegramBot/Commands/Inlines/ConnectToRankedQuery.cs

@@ -1,28 +0,0 @@
-using System.Threading.Tasks;
-using MafiaTelegramBot.Controllers;
-using MafiaTelegramBot.DataBase.EntityDao;
-using MafiaTelegramBot.Game;
-using MafiaTelegramBot.Resources;
-using Telegram.Bot.Types;
-
-namespace MafiaTelegramBot.Models.Inlines
-{
-    public class ConnectToRankedQuery : Query
-    {
-        protected override Callback Name => Callback.ConnectToRanked;
-
-        protected override async Task<Message> Execute(Update update)
-        {
-            await DeletePreviousMessage(ChatId, update.CallbackQuery.Message.MessageId);
-            var user = await UserDao.GetPlayerById(UserId);
-            if (user.GetRoomName() != "")
-                return await Bot.SendWithMarkdown2(ChatId, strings.user_already_in_game);
-            var rooms = await RoomController.GetPublicRankedRooms(user.GetRank());
-            if (rooms.Count == 0) return await Bot.SendWithMarkdown2(ChatId, strings.public_rooms_are_not_exist);
-            var roomKey = RoomEncrypter.GetCode(rooms[0].RoomName);
-            var resultCode = await RoomController.ConnectToGame(user, roomKey);
-            if (resultCode != ResultCode.CodeOk) return await Utilities.GetResultCodeMessage(resultCode, ChatId);
-            return await Bot.SendWithMarkdown2(ChatId, strings.successful_entry_into_room, Keyboard.PlayerGameMenu);
-        }
-    }
-}

MafiaTelegramBot/Commands/Inlines/ConnectToSelectedRoomQuery.cs

@@ -1,26 +0,0 @@
-using System.Threading.Tasks;
-using MafiaTelegramBot.Controllers;
-using MafiaTelegramBot.DataBase.EntityDao;
-using MafiaTelegramBot.Game;
-using MafiaTelegramBot.Resources;
-using Telegram.Bot.Types;
-
-namespace MafiaTelegramBot.Models.Inlines
-{
-    public class ConnectToSelectedRoomQuery : Query
-    {
-        protected override Callback Name => Callback.ConnectToSelectedRoom;
-
-        protected override async Task<Message> Execute(Update update)
-        {
-            await DeletePreviousMessage(ChatId, update.CallbackQuery.Message.MessageId);
-            var data = update.CallbackQuery.Data;
-            var param = data.Split('|');
-            var roomKey = param[2];
-            var user = await UserDao.GetPlayerById(UserId);
-            var resultCode = await RoomController.ConnectToGame(user, roomKey);
-            if (resultCode != ResultCode.CodeOk) return await Utilities.GetResultCodeMessage(resultCode, ChatId);
-            return await Bot.SendWithMarkdown2(ChatId, strings.successful_entry_into_room, Keyboard.PlayerGameMenu);
-        }
-    }
-}

MafiaTelegramBot/Commands/Inlines/ContinueQuery.cs

@@ -1,28 +0,0 @@
-using System.Threading.Tasks;
-using MafiaTelegramBot.Controllers;
-using MafiaTelegramBot.CustomCollections.Extensions;
-using MafiaTelegramBot.DataBase.EntityDao;
-using MafiaTelegramBot.Game;
-using MafiaTelegramBot.Game.GameRooms;
-using MafiaTelegramBot.Resources;
-using Telegram.Bot.Types;
-
-namespace MafiaTelegramBot.Models.Inlines
-{
-    public class ContinueQuery : Query
-    {
-        protected override Callback Name => Callback.Continue;
-        protected override async Task<Message> Execute(Update update)
-        {
-            var user = await UserDao.GetPlayerById(UserId);
-            var roomKey = RoomEncrypter.GetCode(user.GetRoomName());
-            var room = RoomController.GetRoom(roomKey);
-            if (room is FastGameRoom r)
-            {
-                r.ContinuePlayers.AddUnique(user);
-                return await Bot.EditMessageAsync(ChatId, update.CallbackQuery.Message.MessageId, strings.you_continued_the_game);
-            }
-            return await Bot.SendWithMarkdown2(ChatId, strings.unexpected_error);
-        }
-    }
-}

MafiaTelegramBot/Commands/Inlines/GiveRoleQuery.cs

@@ -1,27 +0,0 @@
-using System;
-using System.Threading.Tasks;
-using MafiaTelegramBot.DataBase.EntityDao;
-using MafiaTelegramBot.Resources;
-using Telegram.Bot.Types;
-
-namespace MafiaTelegramBot.Models.Inlines
-{
-    public class GiveRoleQuery : Query
-    {
-        protected override Callback Name => Callback.GiveRole;
-        protected override async Task<Message> Execute(Update update)
-        {
-            await DeletePreviousMessage(ChatId, update.CallbackQuery.Message.MessageId);
-            var data = update.CallbackQuery.Data.Split('|');
-            var target = long.Parse(data[2]);
-            if(!Enum.TryParse(data[3], out Roles role)) return await Bot.SendWithMarkdown2(ChatId, strings.unexpected_error);
-            var admin = await UserDao.GetPlayerById(UserId);
-            var user = await UserDao.GetPlayerById(target);
-            if(!user.OpenedRoles.TryOpenRole(role)) return await Bot.SendWithMarkdown2(ChatId, strings.user_now_has_role);
-            await Bot.SendStickerAsync(user.ChatId, Stickers.Sticker[role.ToString()]);
-            await Bot.SendWithMarkdown2(user.ChatId,
-                $"{admin.NickName} {strings.gives_to_you_role} {roles.ResourceManager.GetString(role.ToString())}");
-            return await Bot.SendWithMarkdown2(ChatId, $"{strings.role_successfully_issued_to} {user.NickName}");
-        }
-    }
-}

MafiaTelegramBot/Commands/Inlines/GiveToSelectedQuery.cs

@@ -1,17 +0,0 @@
-using System.Threading.Tasks;
-using MafiaTelegramBot.Resources;
-using Telegram.Bot.Types;
-
-namespace MafiaTelegramBot.Models.Inlines
-{
-    public class GiveToSelectedQuery : Query
-    {
-        protected override Callback Name => Callback.GiveToSelected;
-        
-        protected override async Task<Message> Execute(Update update)
-        {
-            await GiveRoleToPlayerHandler.AddToQueue(UserId);
-            return await Bot.SendWithMarkdown2(ChatId, strings.enter_username);
-        }
-    }
-}

MafiaTelegramBot/Commands/Inlines/KickSelectedPlayerQuery.cs

@@ -1,20 +0,0 @@
-using System.Threading.Tasks;
-using MafiaTelegramBot.Controllers;
-using MafiaTelegramBot.DataBase.EntityDao;
-using MafiaTelegramBot.Resources;
-using Telegram.Bot.Types;
-
-namespace MafiaTelegramBot.Models.Inlines
-{
-    public class KickSelectedPlayerQuery : Query
-    {
-        protected override Callback Name => Callback.KickUser;
-        protected override async Task<Message> Execute(Update update)
-        {
-            var user = await UserDao.GetPlayerById(UserId);
-            var resultCode = await RoomController.LeaveFromGame(user);
-            if (resultCode != ResultCode.CodeOk) return await Utilities.GetResultCodeMessage(resultCode, ChatId);
-            return await Bot.SendWithMarkdown2(user.ChatId, $"{strings.you_were_kicked}", user.IsAdmin ? Keyboard.AdminMainMenu : Keyboard.MainMenu);
-        }
-    }
-}

MafiaTelegramBot/Commands/Inlines/PackInfoQuery.cs

@@ -1,16 +0,0 @@
-using System.Threading.Tasks;
-using MafiaTelegramBot.Resources;
-using Telegram.Bot.Types;
-
-namespace MafiaTelegramBot.Models.Inlines
-{
-    public class PackInfoQuery : Query
-    {
-        protected override Callback Name => Callback.PackInfo;
-        protected override async Task<Message> Execute(Update update)
-        {
-            var msg1 = strings.pack_information.Replace("\\n", "\\\n");
-            return await Bot.SendWithMarkdown2(ChatId, msg1);
-        }
-    }
-}

MafiaTelegramBot/Commands/Inlines/PackOpenQuery.cs

@@ -1,66 +0,0 @@
-using System.Linq;
-using System.Threading.Tasks;
-using MafiaTelegramBot.DataBase.Entity;
-using MafiaTelegramBot.DataBase.EntityDao;
-using MafiaTelegramBot.Resources;
-using Telegram.Bot.Types;
-
-namespace MafiaTelegramBot.Models.Inlines
-{
-    public class PackOpenQuery : Query
-    {
-        protected override Callback Name => Callback.PackOpen;
-        protected override async Task<Message> Execute(Update update)
-        {
-            await DeletePreviousMessage(ChatId, update.CallbackQuery.Message.MessageId);
-            var user = await UserDao.GetPlayerById(UserId);
-            if (user.Info.PackCount <= 0) return await Bot.SendWithMarkdown2(ChatId, strings.you_havent_pack);
-            user.Info.PackCount--;
-            var baseRole = await GetRandomBaseRole(user.OpenedRoles);
-            if (user.OpenedRoles.TryOpenRole(baseRole))
-            {
-                await Bot.SendStickerAsync(ChatId, Stickers.Sticker[baseRole.ToString()]);
-                await Bot.SendWithMarkdown2(ChatId,$"{strings.congratulations_you_open_role} {roles.ResourceManager.GetString(baseRole.ToString())}");
-            }
-            else await Bot.SendWithMarkdown2(ChatId,$"{strings.you_got_role} {roles.ResourceManager.GetString(baseRole.ToString())} ({strings.now_opened})");
-            var addRole = await GetRandomRole();
-            if (addRole != Roles.None)
-            {
-                if (user.OpenedRoles.TryOpenRole(addRole))
-                {
-                    await Bot.SendStickerAsync(ChatId, Stickers.Sticker[addRole.ToString()]);
-                    await Bot.SendWithMarkdown2(ChatId,$"{strings.congratulations_you_open_role} {roles.ResourceManager.GetString(addRole.ToString())}");
-                }
-                else await Bot.SendWithMarkdown2(ChatId,$"{strings.you_got_role} {roles.ResourceManager.GetString(addRole.ToString())} ({strings.now_opened})");
-            }
-            return new Message();
-        }
-        
-        private Task<Roles> GetRandomBaseRole(OpenedRolesEntity openedRoles)
-        {
-            return Task.Run(() =>
-            {
-                var allOpened = openedRoles.Hooker && openedRoles.Bodyguard && openedRoles.Elder && openedRoles.Werewolf;
-                if (allOpened)
-                    return Utilities.TierDictionary[2][Utilities.Rnd.Next(Utilities.TierDictionary[2].Count)];
-                var notOpened = Utilities.TierDictionary[2].Except(openedRoles.ToList()).ToArray();
-                return notOpened[Utilities.Rnd.Next(notOpened.Length)];
-            });
-        }
-
-        private Task<Roles> GetRandomRole()
-        {
-            return Task.Run(() =>
-            {
-                var chance = Utilities.Rnd.Next(100);
-                return chance switch
-                {
-                    <1 => Utilities.TierDictionary[5][Utilities.Rnd.Next(Utilities.TierDictionary[5].Count)],
-                    <5 => Utilities.TierDictionary[4][Utilities.Rnd.Next(Utilities.TierDictionary[4].Count)],
-                    <25 => Utilities.TierDictionary[3][Utilities.Rnd.Next(Utilities.TierDictionary[3].Count)],
-                    _ => Roles.None
-                };
-            });
-        }
-    }
-}

MafiaTelegramBot/Commands/Inlines/PlayersCountSettingsQuery.cs

@@ -1,26 +0,0 @@
-using System.Threading.Tasks;
-using MafiaTelegramBot.Controllers;
-using MafiaTelegramBot.DataBase.EntityDao;
-using MafiaTelegramBot.Game;
-using MafiaTelegramBot.Resources;
-using Telegram.Bot.Types;
-
-namespace MafiaTelegramBot.Models.Inlines
-{
-    public class PlayersCountSettingsQuery : Query
-    {
-        protected override Callback Name => Callback.PlayersCount;
-        
-        protected override async Task<Message> Execute(Update update)
-        {
-            await DeletePreviousMessage(ChatId, update.CallbackQuery.Message.MessageId);
-            var user = await UserDao.GetPlayerById(UserId);
-            var roomKey = RoomEncrypter.GetCode(user.GetRoomName());
-            var room = RoomController.GetRoom(roomKey);
-            if(room == null)
-                return await Bot.SendWithMarkdown2(ChatId, strings.room_does_not_exists);
-            var roomMaxCapacity = room.MaxPlayers;
-            return await Bot.SendWithMarkdown2(ChatId, $"{strings.max_capacity_message}: {roomMaxCapacity}", Keyboard.SetMaximumKeyboard(UserId));
-        }
-    }
-}

MafiaTelegramBot/Commands/Inlines/Query.cs

@@ -1,47 +0,0 @@
-#nullable enable
-using System;
-using System.Threading.Tasks;
-using MafiaTelegramBot.Controllers;
-using MafiaTelegramBot.DataBase.EntityDao;
-using MafiaTelegramBot.Game;
-using MafiaTelegramBot.Resources;
-using Telegram.Bot.Types;
-using Telegram.Bot.Types.Enums;
-using static System.Enum;
-
-namespace MafiaTelegramBot.Models.Inlines
-{
-    public abstract class Query : UpdateModel<Callback>
-    {
-        protected override bool IsMatches(string command)
-        {
-            if (TryParse(command, out Callback res)) return Name == res;
-            return false;
-        }
-        public static async Task Update(Update update)
-        {
-            var chatId = update.CallbackQuery.Message.Chat.Id;
-            await Bot.Get().SendChatActionAsync(chatId, ChatAction.Typing);
-            var data = update.CallbackQuery.Data;
-            var userId = long.Parse(data.Split('|')[1]);
-            var user = await UserDao.GetPlayerById(userId);
-            user.SetActive();
-            if (user.IsPlaying)
-            {
-                var roomKey = RoomEncrypter.GetCode(user.GetRoomName());
-                var room = RoomController.GetRoom(roomKey);
-                if(room == null)
-                    await Bot.SendWithMarkdown2(chatId, strings.room_does_not_exists);
-                else await room.QHandler.Handle(update);
-            }
-            else
-            {
-                var query = data.Split('|')[0];
-                var queries = Bot.Queries;
-                var command = FirstOrDefault(queries, query);
-                if(command != null) await ((Query?) command.Clone(chatId, userId))!.Execute(update);
-                else await Bot.SendWithMarkdown2(chatId, $"{strings.command_not_found} _*({data})*_");
-            }
-        }
-    }
-}

MafiaTelegramBot/Commands/Inlines/SetPlayersMaximumQuery.cs

@@ -1,29 +0,0 @@
-using System.Threading.Tasks;
-using MafiaTelegramBot.Controllers;
-using MafiaTelegramBot.DataBase.EntityDao;
-using MafiaTelegramBot.Game;
-using MafiaTelegramBot.Resources;
-using Telegram.Bot.Types;
-
-namespace MafiaTelegramBot.Models.Inlines
-{
-    public class SetPlayersMaximumQuery : Query
-    {
-        protected override Callback Name => Callback.SetPlayersMaximum;
-
-        protected override async Task<Message> Execute(Update update)
-        {
-            await DeletePreviousMessage(ChatId, update.CallbackQuery.Message.MessageId);
-            var data = update.CallbackQuery.Data;
-            var count = int.Parse(data.Split('|')[2]);
-            var user = await UserDao.GetPlayerById(UserId);
-            var roomKey = RoomEncrypter.GetCode(user.GetRoomName());
-            var room = RoomController.GetRoom(roomKey);
-            if(room == null)
-                return await Bot.SendWithMarkdown2(ChatId, strings.room_does_not_exists);
-            room.MaxPlayers = count;
-            var message = $"{strings.maximum_was_set_to}: _*{count}*_ {strings.players}";
-            return await Bot.SendWithMarkdown2(ChatId, message);
-        }
-    }
-}

MafiaTelegramBot/Commands/Inlines/SettingsProfileQuery.cs

@@ -1,20 +0,0 @@
-using System.Threading.Tasks;
-using MafiaTelegramBot.DataBase;
-using MafiaTelegramBot.DataBase.EntityDao;
-using MafiaTelegramBot.Resources;
-using Telegram.Bot.Types;
-
-namespace MafiaTelegramBot.Models.Inlines
-{
-    public class SettingsProfileQuery : Query
-    {
-        protected override Callback Name => Callback.SettingsProfile;
-
-        protected override async Task<Message> Execute(Update update)
-        {
-            await DeletePreviousMessage(ChatId, update.CallbackQuery.Message.MessageId);
-            var user = await UserDao.GetPlayerById(UserId);
-            return await Bot.SendWithMarkdown2(ChatId, $"{strings.your_name} {user.NickName}", Keyboard.ChangeNameKeyboard(UserId));
-        }
-    }
-}

MafiaTelegramBot/Commands/Inlines/SettingsRoomQuery.cs

@@ -1,16 +0,0 @@
-using System.Threading.Tasks;
-using MafiaTelegramBot.Resources;
-using Telegram.Bot.Types;
-
-namespace MafiaTelegramBot.Models.Inlines
-{
-    public class SettingsRoomQuery : Query
-    {
-        protected override Callback Name => Callback.SettingsRoom;
-
-        protected override async Task<Message> Execute(Update update)
-        {
-            return await Bot.SendWithMarkdown2(ChatId, strings.settings_room);
-        }
-    }
-}

MafiaTelegramBot/Commands/Inlines/ShowMyExtendedStatsQuery.cs

@@ -1,36 +0,0 @@
-using System;
-using System.Linq;
-using System.Threading.Tasks;
-using MafiaTelegramBot.DataBase.EntityDao;
-using MafiaTelegramBot.Resources;
-using Telegram.Bot.Types;
-
-namespace MafiaTelegramBot.Models.Inlines
-{
-    public class ShowMyExtendedStatsQuery : Query
-    {
-        protected override Callback Name => Callback.ShowMyExtendedStats;
-
-        protected override async Task<Message> Execute(Update update)
-        {
-            await DeletePreviousMessage(ChatId, update.CallbackQuery.Message.MessageId);
-            var user = await UserDao.GetPlayerById(UserId);
-            var rolesList = Enum.GetValues(typeof(Roles)).Cast<Roles>().ToList();
-            rolesList.Remove(Roles.None);
-            rolesList.Remove(Roles.All);
-            var message = "";
-            if (user.Statistics[Roles.All].Games > 0)
-                foreach (var role in rolesList)
-                {
-                    if (!user.Statistics.Contains(role) || user.Statistics[role].Games <= 0) continue;
-                    var statsRow = user.Statistics[role];
-                    message += String.Format(strings.role_string, roles.ResourceManager.GetString(role.ToString()), statsRow.Wins, statsRow.Games, (int) (statsRow.GetWinrate()*100)) + '\n';
-                }
-            else
-            {
-                message += strings.no_stats_by_roles;
-            }
-            return await Bot.SendWithMarkdown2(ChatId, message, Keyboard.BackButton(UserId));
-        }
-    }
-}

MafiaTelegramBot/Commands/Inlines/ShowMyPacksQuery.cs

@@ -1,19 +0,0 @@
-using System.Threading.Tasks;
-using MafiaTelegramBot.DataBase.EntityDao;
-using MafiaTelegramBot.Resources;
-using Telegram.Bot.Types;
-
-namespace MafiaTelegramBot.Models.Inlines
-{
-    public class ShowMyPacksQuery : Query
-    {
-        protected override Callback Name => Callback.ShowMyPacks;
-        protected override async Task<Message> Execute(Update update)
-        {
-            await DeletePreviousMessage(ChatId, update.CallbackQuery.Message.MessageId);
-            var player = await UserDao.GetPlayerById(UserId);
-            await Bot.SendStickerAsync(ChatId, Stickers.Sticker["Pool"]);
-            return await Bot.SendWithMarkdown2(ChatId, $"{strings.your_packs} {player.Info.PackCount}", Keyboard.PackKeyboard(player.Id));
-        }
-    }
-}

MafiaTelegramBot/Commands/Inlines/StartGameQuery.cs

@@ -1,28 +0,0 @@
-using System.Threading.Tasks;
-using MafiaTelegramBot.Controllers;
-using MafiaTelegramBot.DataBase.EntityDao;
-using MafiaTelegramBot.Game;
-using MafiaTelegramBot.Resources;
-using Telegram.Bot.Types;
-
-namespace MafiaTelegramBot.Models.Inlines
-{
-    public class StartGameQuery : Query
-    {
-        protected override Callback Name => Callback.StartGame;
-        protected override async Task<Message> Execute(Update update)
-        {
-            await DeletePreviousMessage(ChatId, update.CallbackQuery.Message.MessageId);
-            var owner = await UserDao.GetPlayerById(UserId);
-            var roomKey = RoomEncrypter.GetCode(owner.GetRoomName());
-            var room = RoomController.GetRoom(roomKey);
-            if(room == null)
-                return await Bot.SendWithMarkdown2(ChatId, strings.room_does_not_exists);
-            var result = await Bot.SendWithMarkdown2(owner.ChatId, strings.game_process_started);
-            var resultCode = await room.Prepare();
-            if (resultCode != ResultCode.CodeOk) return await Utilities.GetResultCodeMessage(resultCode, ChatId);
-            room.Start();
-            return result;
-        }
-    }
-}

MafiaTelegramBot/Commands/Inlines/SwitchTimerQuery.cs

@@ -1,26 +0,0 @@
-using System.Threading.Tasks;
-using MafiaTelegramBot.Controllers;
-using MafiaTelegramBot.DataBase.EntityDao;
-using MafiaTelegramBot.Game;
-using MafiaTelegramBot.Resources;
-using Telegram.Bot.Types;
-
-namespace MafiaTelegramBot.Models.Inlines
-{
-    public class SwitchTimerQuery : Query
-    {
-        protected override Callback Name => Callback.SwitchTimer;
-        protected override async Task<Message> Execute(Update update)
-        {
-            var user = await UserDao.GetPlayerById(UserId);
-            var roomName = user.GetRoomName();
-            var roomKey = RoomEncrypter.GetCode(roomName);
-            var room = RoomController.GetRoom(roomKey);
-            if(room == null)
-                return await Bot.EditMessageAsync(ChatId, update.CallbackQuery.Message.MessageId, strings.room_does_not_exists);
-            room.TimerEnabled = !room.TimerEnabled;
-            var status = room.TimerEnabled ? strings.enabled : strings.disabled;
-            return await Bot.EditMessageAsync(ChatId, update.CallbackQuery.Message.MessageId, $"{strings.timer}: {status}");
-        }
-    }
-}

MafiaTelegramBot/Commands/Messages/AdminPanelMessageHandler.cs

@@ -13,7 +13,7 @@ namespace MafiaTelegramBot.Commands.Messages
         {
             if (User.Info.IsAdmin)
                 return await MessageController.SendText(User.Info, strings.start_message, Keyboard.AdminPanelKeyboard());
-            return await new CommandNotFound(User).Execute(update);
+            return await new CommandNotFound(User, update.Message.Text).Execute(update);
         }
 
 

MafiaTelegramBot/Commands/Messages/ChangeNicknameMessageHandler.cs

@@ -18,7 +18,7 @@ namespace MafiaTelegramBot.Commands.Messages
             Queue.AddUnique(id);
         }
 
-        public override bool IsMatches(string command)
+        protected override bool IsMatches(string command)
         {
             return User != null ? Queue.Contains(User.Info.Id) : base.IsMatches(command);
         }

MafiaTelegramBot/Commands/Messages/CreateRoomMessageHandler.cs

@@ -19,7 +19,7 @@ namespace MafiaTelegramBot.Commands.Messages
             Queue.AddUniqueOrReplaceByKey(id, param);
         }
 
-        public override bool IsMatches(string command)
+        protected override bool IsMatches(string command)
         {
             return User != null ? Queue.ContainsKey(User.Info.Id) : base.IsMatches(command);
         }

MafiaTelegramBot/Commands/Messages/EnterCodeMessageHandler.cs

@@ -19,7 +19,7 @@ namespace MafiaTelegramBot.Commands.Messages
             Queue.AddUnique(id);
         }
 
-        public override bool IsMatches(string command)
+        protected override bool IsMatches(string command)
         {
             return User != null ? Queue.Contains(User.Info.Id) : base.IsMatches(command);
         }

MafiaTelegramBot/Commands/Messages/GiveRoleToPlayerMessageHandler.cs

@@ -20,7 +20,7 @@ namespace MafiaTelegramBot.Commands.Messages
             Queue.AddUnique(id);
         }
 
-        public override bool IsMatches(string command)
+        protected override bool IsMatches(string command)
         {
             return User != null ? Queue.Contains(User.Info.Id) : base.IsMatches(command);
         }

MafiaTelegramBot/Commands/Messages/KickPlayerMessageHandler.cs

@@ -16,7 +16,7 @@ namespace MafiaTelegramBot.Commands.Messages
             if(room == null)
                 return await MessageController.SendText(User.Info, strings.room_does_not_exists);
             if (!User.Equals(room.Owner))
-                return await new CommandNotFound(User).Execute(update);
+                return await new CommandNotFound(User, update.Message.Text).Execute(update);
             var players = await room.GetPlayers();
             if (players.Count > 0)
                 return await MessageController.SendText(User.Info, strings.kick_user, Keyboard.KickKeyboard(players));

MafiaTelegramBot/Commands/Messages/MessageHandler.cs

@@ -1,15 +1,11 @@
-using System;
 using System.Collections.Generic;
-using System.Threading.Tasks;
-using MafiaTelegramBot.DataBase.EntityDao;
 using MafiaTelegramBot.Game;
-using Telegram.Bot.Types;
 
 namespace MafiaTelegramBot.Commands.Messages
 {
     public class MessageHandler : UpdateHandler
     {
-        private static readonly List<MessageHandler> List = new()
+        protected override List<UpdateHandler> List => new()
         {
             // Переносим обработку сообщений в другой класс, если игрок находится в комнате
             new UserInGameMessageHandler(null),
@@ -34,27 +30,6 @@ namespace MafiaTelegramBot.Commands.Messages
             new StartMessageHandler(null),
             new StartGameMessageHandler(null),
         };
-        
-        public static async Task<UpdateHandler> Factory(User user, string message)
-        {
-            // Объект пользователя
-            var player = await UserDao.GetPlayerById(user.Id) ?? await UserDao.AddNew(user);
-            
-            // Если игрок заблокирован, то нафиг его
-            if (player.Info.IsBlocked) return new MessageHandler(player);
-            
-            // Устанавливаем игроку время активности на текущее
-            player.SetActive();
-            
-            // Возвращаем объект, если есть подходящая команда
-            foreach (var item in List)
-                if(item.IsMatches(message))
-                    if (Activator.CreateInstance(item.GetType(), player) is UpdateHandler handler)
-                        if(handler.IsMatches(message)) return handler;
-            
-            // Возвращаем команда не найдена, если код дошел до сюда
-            return new CommandNotFound(player);
-        }
 
         public MessageHandler(Player player) : base(player) { }
     }

MafiaTelegramBot/Commands/Messages/RoomSettingsMessageHandler.cs

@@ -17,7 +17,7 @@ namespace MafiaTelegramBot.Commands.Messages
             if(room == null)
                 return await MessageController.SendText(User.Info, strings.room_does_not_exists);
             if (!User.Equals(room.Owner))
-                return await new CommandNotFound(User).Execute(update);
+                return await new CommandNotFound(User, update.Message.Text).Execute(update);
             var status = room.TimerEnabled ? strings.enabled : strings.disabled;
             return await MessageController.SendText(User.Info, strings.what_settings, 
                 Keyboard.SettingsRoomKeyboard($"{strings.timer}: {status}"));

MafiaTelegramBot/Commands/Messages/StartGameMessageHandler.cs

@@ -16,7 +16,7 @@ namespace MafiaTelegramBot.Commands.Messages
             if(room == null)
                 return await MessageController.SendText(User.Info, strings.room_does_not_exists);
             if (!User.Equals(room.Owner))
-                return await new CommandNotFound(User).Execute(update);
+                return await new CommandNotFound(User, update.Message.Text).Execute(update);
             if (room.IsExtended) return await MessageController.SendText(User.Info, strings.continue_question, Keyboard.StartExtendedRoomKeyboard());
             var result = await MessageController.SendText(User.Info, strings.game_process_started);
             var resultCode = await room.Prepare();

MafiaTelegramBot/Commands/Messages/UserInGameMessageHandler.cs

@@ -8,7 +8,7 @@ namespace MafiaTelegramBot.Commands.Messages
     {
         protected override string Command => "";
 
-        public override bool IsMatches(string command)
+        protected override bool IsMatches(string command)
         {
             return User != null ? User.GetRoomName()!= "" : base.IsMatches(command);
         }

MafiaTelegramBot/Commands/UpdateHandler.cs

@@ -1,4 +1,8 @@
+using System;
+using System.Collections.Generic;
 using System.Threading.Tasks;
+using MafiaTelegramBot.Commands.Messages;
+using MafiaTelegramBot.DataBase.EntityDao;
 using MafiaTelegramBot.Game;
 using Telegram.Bot.Types;
 
@@ -7,13 +11,39 @@ namespace MafiaTelegramBot.Commands
     public class UpdateHandler
     {
         protected virtual string Command { get; } = "";
+        
+        protected virtual List<UpdateHandler> List { get; } = new();
+        
         protected Player User { get; }
         
         public virtual async Task<Message> Execute(Update update) { return new Message(); }
 
-        public virtual bool IsMatches(string command) { return command.Contains(Command); }
+        protected virtual bool IsMatches(string command) { return command.Contains(Command); }
+
+        public static async Task<UpdateHandler> Factory(User user, string message, UpdateHandler caller)
+        {
+            // Объект пользователя
+            var player = await UserDao.GetPlayerById(user.Id) ?? await UserDao.AddNew(user);
+            
+            // Если игрок заблокирован, то нафиг его
+            if (player.Info.IsBlocked) return new UpdateHandler(player);
+            
+            // Устанавливаем игроку время активности на текущее
+            player.SetActive();
+
+            var list = caller.List;
+            
+            // Возвращаем объект, если есть подходящая команда
+            foreach (var item in list)
+                if(item.IsMatches(message))
+                    if (Activator.CreateInstance(item.GetType(), player) is UpdateHandler handler)
+                        if(handler.IsMatches(message)) return handler;
+            
+            // Возвращаем команда не найдена, если код дошел до сюда
+            return new CommandNotFound(player, message);
+        }
 
-        public UpdateHandler(Player player) { User = player; }
+        protected UpdateHandler(Player player) { User = player; }
         
         public UpdateHandler() { }
     }

MafiaTelegramBot/Controllers/MessageController.cs

@@ -2,9 +2,9 @@ using System;
 using System.Threading;
 using System.Threading.Tasks;
 using MafiaTelegramBot.Commands;
+using MafiaTelegramBot.Commands.CallbackQueries;
 using MafiaTelegramBot.Commands.Messages;
 using MafiaTelegramBot.DataBase.Entity;
-using MafiaTelegramBot.Models;
 using Telegram.Bot;
 using Telegram.Bot.Exceptions;
 using Telegram.Bot.Types;
@@ -23,8 +23,10 @@ namespace MafiaTelegramBot.Controllers
             {
                 var handler = update.Type switch
                 {
-                    UpdateType.Message => await MessageHandler.Factory(update.Message.From, update.Message.Text),
-                    // UpdateType.CallbackQuery => Query.Update(update),
+                    UpdateType.Message =>
+                        await UpdateHandler.Factory(update.Message.From, update.Message.Text, new MessageHandler(null)),
+                    UpdateType.CallbackQuery =>
+                        await UpdateHandler.Factory(update.CallbackQuery.From, update.CallbackQuery.Data, new CallbackQueryHandler(null)),
                     // UpdateType.ChannelPost => ChannelPost.Update(update),
                     // UpdateType.ChatMember => ChatMember.Update(update),
                     _ => await UnknownUpdateHandlerAsync(update)
@@ -67,5 +69,20 @@ namespace MafiaTelegramBot.Controllers
         {
             return await Bot.Client.SendTextMessageAsync(info.ChatId, message, ParseMode.Html, replyMarkup: keyboard, disableNotification: true);
         }
+        
+        public static async Task<Message> SendSticker(UserEntity info, string fileId)
+        {
+            return await Bot.Client.SendStickerAsync(info.ChatId, fileId, true);
+        }
+
+        public static async Task<Message> EditMessage(UserEntity info, int messageId, string message, InlineKeyboardMarkup keyboard = null)
+        {
+            return await Bot.Client.EditMessageTextAsync(info.ChatId, messageId, message, replyMarkup: keyboard);
+        }
+        
+        public static async Task DeleteMessage(long chatId, int messageId)
+        {
+            await Bot.Client.DeleteMessageAsync(chatId, messageId);
+        }
     }
 }

MafiaTelegramBot/Controllers/RoomController.cs

@@ -1,6 +1,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
+using MafiaTelegramBot.Commands;
 using MafiaTelegramBot.Game;
 using MafiaTelegramBot.Game.GameRooms;
 using MafiaTelegramBot.Models;

MafiaTelegramBot/Game/GameRoles/BodyguardRole.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Linq;
 using System.Threading.Tasks;
+using MafiaTelegramBot.Commands;
 using MafiaTelegramBot.Game.GameRooms;
 using MafiaTelegramBot.Models;
 using MafiaTelegramBot.Resources;

MafiaTelegramBot/Game/GameRoles/DameRole.cs

@@ -1,5 +1,6 @@
 using System.Linq;
 using System.Threading.Tasks;
+using MafiaTelegramBot.Commands;
 using MafiaTelegramBot.Game.GameRooms;
 using MafiaTelegramBot.Models;
 using MafiaTelegramBot.Resources;

MafiaTelegramBot/Game/GameRoles/DonRole.cs

@@ -1,5 +1,6 @@
 using System.Linq;
 using System.Threading.Tasks;
+using MafiaTelegramBot.Commands;
 using MafiaTelegramBot.Game.GameRooms;
 using MafiaTelegramBot.Models;
 using MafiaTelegramBot.Resources;

MafiaTelegramBot/Game/GameRoles/HookerRole.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Linq;
 using System.Threading.Tasks;
+using MafiaTelegramBot.Commands;
 using MafiaTelegramBot.Game.GameRooms;
 using MafiaTelegramBot.Models;
 using MafiaTelegramBot.Resources;

MafiaTelegramBot/Game/GameRoles/JournalistRole.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Linq;
 using System.Threading.Tasks;
+using MafiaTelegramBot.Commands;
 using MafiaTelegramBot.Game.GameRooms;
 using MafiaTelegramBot.Models;
 using MafiaTelegramBot.Resources;

MafiaTelegramBot/Game/GameRooms/FastGameRoom.cs

@@ -1,6 +1,7 @@
 using System.Collections.Generic;
 using System.Threading.Tasks;
 using System.Timers;
+using MafiaTelegramBot.Commands;
 using MafiaTelegramBot.Controllers;
 using MafiaTelegramBot.CustomCollections.Extensions;
 using MafiaTelegramBot.Models;

MafiaTelegramBot/Game/GameRooms/GameRoom.GameProcess.cs

@@ -2,6 +2,7 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using MafiaTelegramBot.Commands;
 using MafiaTelegramBot.Controllers;
 using MafiaTelegramBot.CustomCollections.Extensions;
 using MafiaTelegramBot.DataBase.EntityDao;

MafiaTelegramBot/Game/GameRooms/GameRoom.MessageChannels.cs

@@ -2,6 +2,7 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
+using MafiaTelegramBot.Commands;
 using MafiaTelegramBot.CustomCollections.Extensions;
 using MafiaTelegramBot.Models;
 using Telegram.Bot.Types;

MafiaTelegramBot/Game/GameRooms/GameRoom.MessageHandler.cs

@@ -1,6 +1,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
+using MafiaTelegramBot.Commands;
 using MafiaTelegramBot.Controllers;
 using MafiaTelegramBot.Game.GameRoles;
 using MafiaTelegramBot.Models;

MafiaTelegramBot/Game/GameRooms/GameRoom.PrepareRoom.cs

@@ -2,6 +2,7 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
+using MafiaTelegramBot.Commands;
 using MafiaTelegramBot.CustomCollections.Extensions;
 using MafiaTelegramBot.Models;
 using MafiaTelegramBot.Resources;

MafiaTelegramBot/Game/GameRooms/GameRoom.Structure.cs

@@ -2,6 +2,7 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
 using System.Timers;
+using MafiaTelegramBot.Commands;
 using MafiaTelegramBot.Game.GameRoles;
 using MafiaTelegramBot.Models;
 using MafiaTelegramBot.Resources;

MafiaTelegramBot/Game/GameRooms/GameRoom.Timer.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Threading.Tasks;
+using MafiaTelegramBot.Commands;
 using MafiaTelegramBot.Controllers;
 using MafiaTelegramBot.Models;
 using MafiaTelegramBot.Resources;

MafiaTelegramBot/Game/Player.cs

@@ -3,6 +3,7 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
+using MafiaTelegramBot.Commands;
 using MafiaTelegramBot.CustomCollections;
 using MafiaTelegramBot.DataBase.Entity;
 using MafiaTelegramBot.Game.GameRoles;

MafiaTelegramBot/MainClass.cs

@@ -1,20 +0,0 @@
-using System;
-using System.Threading;
-using MafiaTelegramBot.Controllers;
-using MafiaTelegramBot.Models;
-using Telegram.Bot;
-using Telegram.Bot.Extensions.Polling;
-
-namespace MafiaTelegramBot
-{
-    public static class MainClass
-    {
-        public static void Main()
-        {
-            var cts = new CancellationTokenSource();
-            Bot.Get().StartReceiving(new DefaultUpdateHandler(MessageController.HandleUpdateAsync, MessageController.HandleErrorAsync), cts.Token);
-            Console.ReadLine();
-            cts.Cancel();
-        }
-    }
-}

MafiaTelegramBot/Other/GiveAway.cs

@@ -1,6 +1,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
+using MafiaTelegramBot.Commands;
 using MafiaTelegramBot.Controllers;
 using MafiaTelegramBot.DataBase.Entity;
 using MafiaTelegramBot.DataBase.EntityDao;

MafiaTelegramBot/Resources/Keyboard.cs

@@ -55,12 +55,12 @@ namespace MafiaTelegramBot.Resources
             }, true
         );
 
-        public static InlineKeyboardMarkup RoomViewKeyboard(long userId, Callback callbackPrivate, Callback callbackPublic)
+        public static InlineKeyboardMarkup RoomViewKeyboard(Callback callbackPrivate, Callback callbackPublic)
         {
             return new(new[]
             {
-                InlineKeyboardButton.WithCallbackData(strings._public, $"{callbackPublic}|{userId}|0"),
-                InlineKeyboardButton.WithCallbackData(strings._private, $"{callbackPrivate}|{userId}|0"),
+                InlineKeyboardButton.WithCallbackData(strings._public, $"{callbackPublic}|0"),
+                InlineKeyboardButton.WithCallbackData(strings._private, $"{callbackPrivate}|0"),
             });
         }
 
@@ -91,54 +91,54 @@ namespace MafiaTelegramBot.Resources
             });
         }
 
-        public static InlineKeyboardMarkup ChooseModeKeyboard(long userId, string info)
+        public static InlineKeyboardMarkup ChooseModeKeyboard(string info)
         {
             return new InlineKeyboardMarkup(new[]
             {
-                InlineKeyboardButton.WithCallbackData(strings.standard, $"{Callback.ChooseGameMode}|{userId}|{info}{Constants.STANDARD}"),
-                InlineKeyboardButton.WithCallbackData(strings.extended, $"{Callback.ChooseGameMode}|{userId}|{info}{Constants.EXTENDED}"),
+                InlineKeyboardButton.WithCallbackData(strings.standard, $"{Callback.ChooseGameMode}|{info}{Constants.STANDARD}"),
+                InlineKeyboardButton.WithCallbackData(strings.extended, $"{Callback.ChooseGameMode}|{info}{Constants.EXTENDED}"),
             });
         }
 
-        public static InlineKeyboardMarkup ChooseTypeKeyboard(long userId, string info)
+        public static InlineKeyboardMarkup ChooseTypeKeyboard(string info)
         {
             return info[0] == '0' 
             ? new InlineKeyboardMarkup(new[]
             {
-                InlineKeyboardButton.WithCallbackData(strings.normal_game, $"{Callback.ChooseGameType}|{userId}|{info}{Constants.NORMAL}"),
-                InlineKeyboardButton.WithCallbackData(strings.ranking_game, $"{Callback.ChooseGameType}|{userId}|{info}{Constants.RANKING}"),
+                InlineKeyboardButton.WithCallbackData(strings.normal_game, $"{Callback.ChooseGameType}|{info}{Constants.NORMAL}"),
+                InlineKeyboardButton.WithCallbackData(strings.ranking_game, $"{Callback.ChooseGameType}|{info}{Constants.RANKING}"),
             })
             : new InlineKeyboardMarkup(new[]
             {
                 InlineKeyboardButton.WithCallbackData(strings.normal_game,
-                    $"{Callback.ChooseGameType}|{userId}|{info}{Constants.NORMAL}"),
+                    $"{Callback.ChooseGameType}|{info}{Constants.NORMAL}"),
             });
         }
 
-        public static InlineKeyboardMarkup SetMaximumKeyboard(long userId)
+        public static InlineKeyboardMarkup SetMaximumKeyboard()
         {
             return new InlineKeyboardMarkup(new[]
             {
                 new[] {
-                    InlineKeyboardButton.WithCallbackData(strings.minimum_players_count, $"{Callback.SetPlayersMaximum}|{userId}|6"),
+                    InlineKeyboardButton.WithCallbackData(strings.minimum_players_count, $"{Callback.SetPlayersMaximum}|6"),
                 },
                 new[] {
-                    InlineKeyboardButton.WithCallbackData("7", $"{Callback.SetPlayersMaximum}|{userId}|7"),
-                    InlineKeyboardButton.WithCallbackData("8", $"{Callback.SetPlayersMaximum}|{userId}|8"),
-                    InlineKeyboardButton.WithCallbackData("9", $"{Callback.SetPlayersMaximum}|{userId}|9"),
+                    InlineKeyboardButton.WithCallbackData("7", $"{Callback.SetPlayersMaximum}|7"),
+                    InlineKeyboardButton.WithCallbackData("8", $"{Callback.SetPlayersMaximum}|8"),
+                    InlineKeyboardButton.WithCallbackData("9", $"{Callback.SetPlayersMaximum}|9"),
                 },
                 new[] {
-                    InlineKeyboardButton.WithCallbackData("10", $"{Callback.SetPlayersMaximum}|{userId}|10"),
-                    InlineKeyboardButton.WithCallbackData("11", $"{Callback.SetPlayersMaximum}|{userId}|11"),
-                    InlineKeyboardButton.WithCallbackData("12", $"{Callback.SetPlayersMaximum}|{userId}|12"),
+                    InlineKeyboardButton.WithCallbackData("10", $"{Callback.SetPlayersMaximum}|10"),
+                    InlineKeyboardButton.WithCallbackData("11", $"{Callback.SetPlayersMaximum}|11"),
+                    InlineKeyboardButton.WithCallbackData("12", $"{Callback.SetPlayersMaximum}|12"),
                 },
                 new[] {
-                    InlineKeyboardButton.WithCallbackData("13", $"{Callback.SetPlayersMaximum}|{userId}|13"),
-                    InlineKeyboardButton.WithCallbackData("14", $"{Callback.SetPlayersMaximum}|{userId}|14"),
-                    InlineKeyboardButton.WithCallbackData("15", $"{Callback.SetPlayersMaximum}|{userId}|15"),
+                    InlineKeyboardButton.WithCallbackData("13", $"{Callback.SetPlayersMaximum}|13"),
+                    InlineKeyboardButton.WithCallbackData("14", $"{Callback.SetPlayersMaximum}|14"),
+                    InlineKeyboardButton.WithCallbackData("15", $"{Callback.SetPlayersMaximum}|15"),
                 },
                 new[] {
-                    InlineKeyboardButton.WithCallbackData(strings.maximum_players_count, $"{Callback.SetPlayersMaximum}|{userId}|16"),
+                    InlineKeyboardButton.WithCallbackData(strings.maximum_players_count, $"{Callback.SetPlayersMaximum}|16"),
                 }
             });
         }
@@ -159,22 +159,18 @@ namespace MafiaTelegramBot.Resources
             });
         }
 
-        public static InlineKeyboardMarkup ChangeNameKeyboard(long userId)
+        public static InlineKeyboardMarkup ChangeNameKeyboard()
         {
-            return new(new[]
+            return new InlineKeyboardMarkup(new[]
             {
                 new[]
-                {
-                    InlineKeyboardButton.WithCallbackData(strings.change_name, $"{Callback.ChangeNickName}|{userId}")
-                },
+                { InlineKeyboardButton.WithCallbackData(strings.change_name, $"{Callback.ChangeNickName}") },
                 new[]
-                {
-                    InlineKeyboardButton.WithCallbackData(strings.back_to_profile, $"{Callback.BackToProfile}|{userId}")
-                }
+                { InlineKeyboardButton.WithCallbackData(strings.back_to_profile, $"{Callback.BackToProfile}") }
             });
         }
 
-        public static InlineKeyboardMarkup RoomsKeyboard(List<GameRoom> rooms, long userId, int page)
+        public static InlineKeyboardMarkup RoomsKeyboard(List<GameRoom> rooms, int page)
         {
             var previousButton = page != 0;
             var nextButton = rooms.Count > (page + 1) * Constants.MAX_SHOWING_ROOMS;
@@ -189,7 +185,7 @@ namespace MafiaTelegramBot.Resources
                 {
                     InlineKeyboardButton.WithCallbackData(
                         $"[{s}] {rooms[i].RoomName} ({rooms[i].Players.Values.Count.ToString()}/{rooms[i].MaxPlayers.ToString()})",
-                    $"{Callback.ConnectToSelectedRoom}|{userId}|{RoomEncrypter.GetCode(rooms[i].RoomName)}")
+                    $"{Callback.ConnectToSelectedRoom}|{RoomEncrypter.GetCode(rooms[i].RoomName)}")
                 };
                 ++j;
             }
@@ -309,7 +305,7 @@ namespace MafiaTelegramBot.Resources
             });
         }
 
-        public static InlineKeyboardMarkup ChangeRolesKeyboard(long userId, string roomKey, ExtendedGameRoom room)
+        public static InlineKeyboardMarkup ChangeRolesKeyboard(string roomKey, ExtendedGameRoom room)
         {
             List<Roles> openedRoles = new();
             foreach (var player in room.Players.Values)
@@ -318,27 +314,27 @@ namespace MafiaTelegramBot.Resources
             keyboard[0] = new[]
             {
                 InlineKeyboardButton.WithCallbackData($"{roles.Mafia}-",
-                    $"{Callback.ApplyRolesChange}|{userId}|{roomKey}|{Roles.Mafia}|-"),
+                    $"{Callback.ApplyRolesChange}|{roomKey}|{Roles.Mafia}|-"),
                 InlineKeyboardButton.WithCallbackData($"{roles.Mafia}+",
-                    $"{Callback.ApplyRolesChange}|{userId}|{roomKey}|{Roles.Mafia}|+"),
+                    $"{Callback.ApplyRolesChange}|{roomKey}|{Roles.Mafia}|+"),
             };
             keyboard[1] = new[]
             {
                 InlineKeyboardButton.WithCallbackData($"{roles.Villager}-",
-                    $"{Callback.ApplyRolesChange}|{userId}|{roomKey}|{Roles.Villager}|-"),
+                    $"{Callback.ApplyRolesChange}|{roomKey}|{Roles.Villager}|-"),
                 InlineKeyboardButton.WithCallbackData($"{roles.Villager}+",
-                    $"{Callback.ApplyRolesChange}|{userId}|{roomKey}|{Roles.Villager}|+"),
+                    $"{Callback.ApplyRolesChange}|{roomKey}|{Roles.Villager}|+"),
             };
             for (var i = 0; i < openedRoles.Count; ++i)
             {
                 var contain = room.CustomRoomSettings.ContainsKey(openedRoles[i]);
                     keyboard[2+i] = new []{ InlineKeyboardButton.WithCallbackData(
                         $"{roles.ResourceManager.GetString(openedRoles[i].ToString())} ({(contain ? 1 : 0)})",
-                        $"{Callback.ApplyRolesChange}|{userId}|{roomKey}|{openedRoles[i]}"
+                        $"{Callback.ApplyRolesChange}|{roomKey}|{openedRoles[i]}"
                         )};
             }
             keyboard[openedRoles.Count+2] = new[]
-            { InlineKeyboardButton.WithCallbackData(strings.run_game, $"{Callback.StartGame}|{userId}") };
+            { InlineKeyboardButton.WithCallbackData(strings.run_game, $"{Callback.StartGame}") };
             return keyboard;
         }
 
@@ -368,21 +364,21 @@ namespace MafiaTelegramBot.Resources
             );
         }
 
-        public static InlineKeyboardMarkup PackKeyboard(long userId)
+        public static InlineKeyboardMarkup PackKeyboard()
         {
             return new InlineKeyboardMarkup(new[]
             {
-                new[]{ InlineKeyboardButton.WithCallbackData(strings.pack_open, $"{Callback.PackOpen}|{userId}") },
-                new[]{ InlineKeyboardButton.WithCallbackData(strings.pack_info, $"{Callback.PackInfo}|{userId}") },
-                new[] { InlineKeyboardButton.WithCallbackData(strings.back_to_profile, $"{Callback.BackToProfile}|{userId}") }
+                new[]{ InlineKeyboardButton.WithCallbackData(strings.pack_open, $"{Callback.PackOpen}") },
+                new[]{ InlineKeyboardButton.WithCallbackData(strings.pack_info, $"{Callback.PackInfo}") },
+                new[]{ InlineKeyboardButton.WithCallbackData(strings.back_to_profile, $"{Callback.BackToProfile}") }
             });
         }
 
-        public static InlineKeyboardMarkup BackButton(long userId)
+        public static InlineKeyboardMarkup BackButton()
         {
             return new InlineKeyboardMarkup(new[]
             {
-                InlineKeyboardButton.WithCallbackData(strings.back_to_profile, $"{Callback.BackToProfile}|{userId}")
+                InlineKeyboardButton.WithCallbackData(strings.back_to_profile, $"{Callback.BackToProfile}")
             });
         }
     }