public static void DeserializeAll()
        {
            if (!Directory.Exists(LOCAL))
            {
                return;
            }

            var ids = new DirectoryInfo(LOCAL)
                      .GetDirectories()
                      .Select <DirectoryInfo, UInt64>(di =>
            {
                if (UInt64.TryParse(di.Name, out UInt64 id))
                {
                    return(id);
                }
                return(0);
            }).Where(v => v != 0);

            foreach (var id in ids)
            {
                if (!DutyBot.IsKnownChatId((long)id))
                {
                    DutyBot.groups.Add(DeserializeGroup(id));
                }
            }
        }
        public async override Task ExecuteWith(TelegramBotClient client, Message message)
        {
            var chatId  = message.Chat.Id;
            var platoon = DutyBot.GetGroupByChatId(chatId)?.Platoon;

            if (platoon == null)
            {
                throw new InvalidIdException("Взаимодействие с данной группой не было инициировано.");
            }

            var queue = platoon.DutyQueue;

            try
            {
                queue.PushCurrent(Student.ToString());
            }
            catch (Exception ex)
            {
                await client.SendTextMessageAsync(message.Chat.Id, ex.Message);

                LastStatus = CommandStatus.Failure;
                return;
            }

            var current = queue.GetCurrentDuty();

            await client.SendTextMessageAsync(message.Chat.Id,
                                              $"Теперь дежурит {current}.");

            LastStatus = CommandStatus.Success;
        }
        public override Task ExecuteWith(TelegramBotClient client, Message message)
        {
            var platoon = DutyBot.GetGroupByChatId(message.Chat.Id).Platoon;

            platoon.DutyQueue.ExcludeAll();

            return(base.ExecuteWith(client, message));
        }
        public async override Task ExecuteWith(TelegramBotClient client, Message message)
        {
            var chatId  = message.Chat.Id;
            var platoon = DutyBot.GetGroupByChatId(chatId)?.Platoon;

            if (platoon == null)
            {
                throw new InvalidIdException("Взаимодействие с данной группой не было инициировано.");
            }

            await this.AddTo(platoon.DutyQueue, client, message);
        }
Example #5
0
        public async override Task Execute(TelegramBotClient client, Message message)
        {
            var chatId = message.Chat.Id;

            if (!DutyBot.IsKnownChatId(chatId))
            {
                DutyBot.CreateGroupFor(chatId);

                await client.SendTextMessageAsync(chatId,
                                                  "Начнём) Для получения списка команд используйте /help");
            }
        }
        public async override Task Execute(TelegramBotClient client, Message message)
        {
            var chatId = message.Chat.Id;

            if (message.ReplyToMessage != null)
            {
                var userId = message.ReplyToMessage.From.Id;

                if (userId == (await client.GetMeAsync()).Id)
                {
                    await client.SendTextMessageAsync(chatId, "Я дежурный бот)");

                    LastStatus = CommandStatus.Success;
                    return;
                }

                if (message.ReplyToMessage.From.IsBot)
                {
                    await client.SendTextMessageAsync(chatId, "Это один из ботов, который нам помогает)");

                    LastStatus = CommandStatus.Success;
                    return;
                }

                var platoon = DutyBot.GetGroupByChatId(chatId)?.Platoon;
                var student = platoon.FirstOrDefault(s => s.UserId == userId);

                if (student == null)
                {
                    await client.SendTextMessageAsync(chatId, "Указанный пользователь не был проассоциирован((");

                    LastStatus = CommandStatus.Failure;
                    return;
                }

                await client.SendTextMessageAsync(chatId, $"\"{message.ReplyToMessage.From.FirstName}\" это {student}");

                LastStatus = CommandStatus.Success;
            }
            else
            {
                await client.SendTextMessageAsync(chatId,
                                                  "Для выполнения данной команды необходимо ответить на сообщение студента, которого хочешь узнать!");

                LastStatus = CommandStatus.Failure;
                return;
            }
        }
        protected void Application_Start()
        {
            AreaRegistration.RegisterAllAreas();
            GlobalConfiguration.Configure(WebApiConfig.Register);
            RouteConfig.RegisterRoutes(RouteTable.Routes);
            HostingEnvironment.RegisterObject(new HostingEnvironmentRegisteredObject());

            if (!SerializeHelper.LoadConfiguration())
            {
                HomeController.Message = "Configuration not found!";
                return;
            }

            DutyBot.Init();
            SerializeHelper.DeserializeAll();
        }
        public async override Task ExecuteWith(TelegramBotClient client, Message message)
        {
            var chatId  = message.Chat.Id;
            var platoon = DutyBot.GetGroupByChatId(chatId)?.Platoon;

            if (platoon == null)
            {
                throw new InvalidIdException("Взаимодействие с данной группой не было инициировано.");
            }

            try
            {
                foreach (var user in DataList)
                {
                    var splitData = user.Trim().Split(' ');

                    if (splitData.Length != 2)
                    {
                        await client.SendTextMessageAsync(message.Chat.Id,
                                                          "Пришли список в формате \"Фамилия Имя\" тех, кого нужно добавить)");

                        LastStatus = CommandStatus.AwaitNextMessage;
                        return;
                    }

                    var student = platoon.CreateStudent(splitData[0], splitData[1]);
                }
            }
            catch (Exception ex)
            {
                await client.SendTextMessageAsync(message.Chat.Id,
                                                  ex.Message);

                LastStatus = CommandStatus.Failure;
                return;
            }


            await client.SendTextMessageAsync(message.Chat.Id,
                                              "Список студентов обновлён, теперь он выглядит так:");

            await DutyBot.Commands.Single(
                c => c.GetType() == typeof(ListCommand))
            .Execute(client, message);

            LastStatus = CommandStatus.Success;
        }
Example #9
0
        public async override Task ExecuteWith(TelegramBotClient client, Message message)
        {
            var chatId  = message.Chat.Id;
            var platoon = DutyBot.GetGroupByChatId(chatId)?.Platoon;

            if (platoon == null)
            {
                throw new InvalidIdException("Взаимодействие с данной группой не было инициировано.");
            }

            var queue = platoon.DutyQueue;

            if (Data.Trim().ToLower() == "all")
            {
                platoon.DutyQueue.ExcludeAll();

                await client.SendTextMessageAsync(message.Chat.Id,
                                                  "Все студенты были исключены из списка дежурных)\nТеперь список дежурных пуст!");

                LastStatus = CommandStatus.Success;
                return;
            }

            try
            {
                queue.Exclude(Student.ToString());
            }
            catch (Exception ex)
            {
                await client.SendTextMessageAsync(message.Chat.Id,
                                                  ex.Message);

                LastStatus = CommandStatus.Failure;
                return;
            }

            var exStudent = platoon.GetStudent(Data);

            await client.SendTextMessageAsync(message.Chat.Id,
                                              $"Студент {exStudent} исключён из списка дежурных.");

            LastStatus = CommandStatus.Success;
        }
Example #10
0
        public async override Task Execute(TelegramBotClient client, Message message)
        {
            var chatId = message.Chat.Id;
            var userId = message.From.Id;

            var platoon = DutyBot.GetGroupByChatId(chatId).Platoon;

            var student = platoon.FirstOrDefault(s => s.UserId == userId);

            if (student == null)
            {
                await client.SendTextMessageAsync(chatId, "Ты не был проассоциирован!\n" +
                                                  $"Используй /{nameof(AssociateCommand).Replace("Command", "").ToLower()} для выполнения этого)",
                                                  replyToMessageId : message.MessageId);

                LastStatus = CommandStatus.Failure;
                return;
            }

            var number = platoon.DutyQueue.ToList().IndexOf(student);

            if (number == -1)
            {
                await client.SendTextMessageAsync(chatId, "Тебя нет в очереди на дежурство!\nПоздравляю)",
                                                  replyToMessageId : message.MessageId);

                LastStatus = CommandStatus.Success;
                return;
            }

            var target = DateTime.UtcNow
                         .AddHours(3)
                         .GetNextDate(platoon.TagetDay)
                         .AddDays(7 * number)
                         .ToLocalStringFormat();

            await client.SendTextMessageAsync(chatId, $"Ты дежуришь <b>{target}</b>)\nНе забудь подготовиться!", ParseMode.Html,
                                              replyToMessageId : message.MessageId);

            LastStatus = CommandStatus.Success;
        }
        public async override Task ExecuteWith(TelegramBotClient client, Message message)
        {
            var chatId  = message.Chat.Id;
            var platoon = DutyBot.GetGroupByChatId(chatId)?.Platoon;

            if (platoon == null)
            {
                throw new InvalidIdException("Взаимодействие с данной группой не было инициировано.");
            }

            if (Data.Trim().ToLower() == "all")
            {
                platoon.RemoveAll();

                await client.SendTextMessageAsync(chatId, "Все студенты были удалены из списка!");

                LastStatus = CommandStatus.Success;
                return;
            }

            try
            {
                platoon.RemoveStudent(Student.ToString());
            }
            catch (Exception ex)
            {
                await client.SendTextMessageAsync(message.Chat.Id,
                                                  ex.Message);

                LastStatus = CommandStatus.Success;
                return;
            }

            await client.SendTextMessageAsync(message.Chat.Id,
                                              $"Студент {Student} был успешно исключен.");

            LastStatus = CommandStatus.Success;
        }
        public override async Task Execute(TelegramBotClient client, Message message)
        {
            var sb = new StringBuilder("<b>Список дежурных</b>");

            var chatId  = message.Chat.Id;
            var platoon = DutyBot.GetGroupByChatId(chatId)?.Platoon;

            if (platoon == null)
            {
                throw new InvalidIdException("Взаимодействие с данной группой не было инициировано.");
            }

            if (platoon.DutyQueue.IsEmpty)
            {
                sb.Append("<b> пуст!</b>");
            }
            else
            {
                sb.Append("<b>:</b>\n\n");

                var pivot = DateTime.UtcNow.AddHours(3).GetNextDate(platoon.TagetDay);

                foreach (var student in platoon.DutyQueue)
                {
                    sb.Append($"<b>{pivot.ToLocalStringFormat()}</b> {student};\n");
                    pivot = pivot.AddDays(7);
                }

                sb.Remove(sb.Length - 2, 2);
                sb.Append(".");
            }

            await client.SendTextMessageAsync(message.Chat.Id, sb.ToString(), ParseMode.Html);

            LastStatus = CommandStatus.Success;
        }
        public async override Task OnTextData(TelegramBotClient client, Message message)
        {
            var chatId  = message.Chat.Id;
            var platoon = DutyBot.GetGroupByChatId(chatId)?.Platoon;

            if (platoon == null)
            {
                throw new InvalidIdException("Взаимодействие с данной группой не было инициировано.");
            }

            if (_keyboardShown)
            {
                var markupMessage = await client.SendTextMessageAsync(chatId, $"Выбран {message.Text}",
                                                                      replyMarkup : new ReplyKeyboardRemove());

                await client.DeleteMessageAsync(chatId, markupMessage.MessageId);

                _keyboardShown = false;
            }

            if (Data.Trim().ToLower() == "all")
            {
                if (IgnoreAllArgument)
                {
                    Student    = null;
                    LastStatus = CommandStatus.AwaitExecuting;
                    return;
                }
                else
                {
                    await client.SendTextMessageAsync(chatId, "Данная команда не поддерживает \"all\"!\n" +
                                                      "Введите имя или фамилию студента)");

                    LastStatus = CommandStatus.AwaitNextMessage;
                    return;
                }
            }

            Student[] students = null;

            if (_students == null)
            {
                students = _students = platoon.GetStudents(Data);
            }
            else
            {
                students = _students.Where(s => s.RecognizeSelf(Data)).ToArray();
            }

            if (students.Length == 0)
            {
                await client.SendTextMessageAsync(message.Chat.Id, $"{Data} отсутсвует в списке студентов!");

                LastStatus = CommandStatus.AwaitNextMessage;
                _students  = null;
                return;
            }

            if (students.Length != 1)
            {
                var studentsMessage = new StringBuilder("По введённым данным невозможно однозначно определить студента!\n" +
                                                        "Кого именно имели в виду?\n");

                foreach (var student in students)
                {
                    studentsMessage.Append($"{student},\n");
                }

                studentsMessage
                .Remove(studentsMessage.Length - 2, 2)
                .Append('.');

                bool equalsName = true;

                if (students[0].Surname == students[1].Surname)
                {
                    equalsName = false;
                }

                var keyboard = new ReplyKeyboardMarkup(students
                                                       .Select(s => new KeyboardButton(equalsName ? s.Surname : s.Name)), true, true)
                {
                    Selective = true
                };

                await client.SendTextMessageAsync(message.Chat.Id,
                                                  $"{studentsMessage}", replyMarkup : keyboard, replyToMessageId : message.MessageId);

                _keyboardShown = true;

                LastStatus = CommandStatus.AwaitNextMessage;
                return;
            }

            _students  = null;
            Student    = students.Single();
            LastStatus = CommandStatus.AwaitExecuting;
        }