Exemplo n.º 1
0
        public async Task ExecuteAsync(UserMessage message)
        {
            var state       = stateService.GetCurrentState(message.User);
            var eventClient = new BetEventClient("http://localhost:27254");

            if (state is CreateEventCommandState createState)
            {
                switch (createState.State)
                {
                case CreateEventState.Name:
                    if (message.Tail == "")
                    {
                        await client.SendTextMessageAsync(message.TelegramMessage.Chat, "Введите название события");

                        stateService.SaveState(message.User, new CreateEventCommandState()
                        {
                            State = CreateEventState.Name
                        });
                        break;
                    }
                    await client.SendTextMessageAsync(message.TelegramMessage.Chat,
                                                      $"Введите возможные исходы вашего события, каждое с новой строки");

                    stateService.SaveState(message.User, new CreateEventCommandState()
                    {
                        State = CreateEventState.Outcomes, Name = message.Tail
                    });

                    break;

                case CreateEventState.Outcomes:
                    if (message.Tail == "")
                    {
                        await client.SendTextMessageAsync(message.TelegramMessage.Chat, "Введите название события");

                        stateService.SaveState(message.User, new CreateEventCommandState()
                        {
                            State = CreateEventState.Name
                        });
                        break;
                    }
                    if (message.Tail.IndexOf('\n') == -1)
                    {
                        await client.SendTextMessageAsync(message.TelegramMessage.Chat,
                                                          $"Введите, пожалуйста, несколько исходов, каждый с новой строки");

                        break;
                    }
                    await client.SendTextMessageAsync(message.TelegramMessage.Chat,
                                                      $"Введите дату и время окончания события");

                    stateService.SaveState(message.User, new CreateEventCommandState()
                    {
                        State = CreateEventState.Deadline, Name = createState.Name, Outcomes = message.Tail
                    });
                    break;

                case CreateEventState.Deadline:
                    DateTime date;
                    if (!DateTime.TryParse(message.Tail, out date))
                    {
                        await client.SendTextMessageAsync(message.TelegramMessage.Chat,
                                                          $"Введите существующую дату");

                        break;
                    }

                    if (date < DateTime.Now)
                    {
                        await client.SendTextMessageAsync(message.TelegramMessage.Chat,
                                                          $"Введите дату в будущем");

                        break;
                    }
                    await client.SendTextMessageAsync(message.TelegramMessage.Chat,
                                                      $"Напишите описание своего события, если не хотите, поставьте \"-\"");

                    stateService.SaveState(message.User, new CreateEventCommandState()
                    {
                        State = CreateEventState.Description, Name = createState.Name, Outcomes = createState.Outcomes, Deadline = date
                    });
                    break;

                case CreateEventState.Description:
                    if (message.Tail == "")
                    {
                        await client.SendTextMessageAsync(message.TelegramMessage.Chat, "Введите название события");

                        stateService.SaveState(message.User, new CreateEventCommandState()
                        {
                            State = CreateEventState.Name
                        });
                        break;
                    }
                    await eventClient.CreateAsync(new BetEventMeta { Name = createState.Name, BetDeadline = createState.Deadline, Outcomes = createState.Outcomes, Description = message.Tail, CreatorId = message.TelegramMessage.From.Id });

                    await client.SendTextMessageAsync(message.TelegramMessage.Chat,
                                                      $"Ваше событие сохранено");

                    stateService.DeleteState(message.User);
                    break;
                }
            }
            else
            {
                await client.SendTextMessageAsync(message.TelegramMessage.Chat, "Введите название события");

                stateService.SaveState(message.User, new CreateEventCommandState()
                {
                    State = CreateEventState.Name
                });
            }
        }
Exemplo n.º 2
0
        public async Task ExecuteAsync(UserMessage message)
        {
            var state       = stateService.GetCurrentState(message.User);
            var eventClient = new BetEventClient("http://localhost:27254");
            var betClient   = new BetClient("http://localhost:27254");
            var userClient  = new UserClient("http://localhost:27254");

            if (state is PlaceBetCommandState betState)
            {
                switch (betState.State)
                {
                case PlaceBetState.EventNumber:
                    var allEvents = await eventClient.GetAllAsync();

                    int chosenEventNumber;
                    if (!Int32.TryParse(message.Tail, out chosenEventNumber))
                    {
                        await client.SendTextMessageAsync(message.TelegramMessage.Chat,
                                                          "введите, пожалуйста, номер цифрами");

                        break;
                    }
                    if (chosenEventNumber < 1 || chosenEventNumber > allEvents.Length)
                    {
                        await client.SendTextMessageAsync(message.TelegramMessage.Chat,
                                                          "Введите, пожалуйста, существующий номер события");

                        break;
                    }
                    var chosenEvent = await eventClient.GetAsync((betState.IdDictionary[chosenEventNumber]));

                    await client.SendTextMessageAsync(message.TelegramMessage.Chat,
                                                      $"Событие {chosenEventNumber}  - {chosenEvent.Name}\n" +
                                                      $"Исходы:\n" +
                                                      $"{chosenEvent.Outcomes}\n" +
                                                      $"Дедлайн: {chosenEvent.BetDeadline}\n" +
                                                      $"Описание: {chosenEvent.Description}\n" +
                                                      $"----------------\n" +
                                                      $" Введите исход, на которую вы хотите сделать ставку");

                    stateService.SaveState(message.User, new PlaceBetCommandState()
                    {
                        State = PlaceBetState.Outcome, EventId = chosenEvent.Id
                    });
                    break;

                case PlaceBetState.Outcome:
                    var chosenOutcome = message.Tail;
                    var myEvent       = await eventClient.GetAsync(betState.EventId);

                    var myEventOutcomes = myEvent.Outcomes.Split('\n');
                    if (!myEventOutcomes.Contains(chosenOutcome))
                    {
                        await client.SendTextMessageAsync(message.TelegramMessage.Chat,
                                                          "Введите, пожалуйста, существующий исход");

                        break;
                    }
                    await client.SendTextMessageAsync(message.TelegramMessage.Chat,
                                                      "Введите размер ставки");

                    stateService.SaveState(message.User, new PlaceBetCommandState()
                    {
                        State = PlaceBetState.BetAmount, EventId = betState.EventId, Outcome = chosenOutcome
                    });
                    break;

                case PlaceBetState.BetAmount:
                    int betAmount;
                    if (!Int32.TryParse(message.Tail, out betAmount))
                    {
                        await client.SendTextMessageAsync(message.TelegramMessage.Chat,
                                                          "введите, пожалуйста, номер цифрами");

                        break;
                    }
                    var user = await userClient.GetByTelegramIdAsync(message.TelegramMessage.From.Id);

                    var balance = user.Balance;
                    if (betAmount < 1 || balance < betAmount)
                    {
                        await client.SendTextMessageAsync(message.TelegramMessage.Chat,
                                                          "Вы ввели некорректный размер ставки, размер ставки не должен превышать ваш баланс");

                        break;
                    }
                    var bet = await betClient.CreateAsync(new BetMeta { BetSize = betAmount, EventId = betState.EventId, UserId = user.Id, Outcome = betState.Outcome });    //поправить юзер айди

                    await client.SendTextMessageAsync(message.TelegramMessage.Chat,
                                                      "Ваша ставка сохранена");

                    stateService.DeleteState(message.User);
                    break;
                }
            }
            else
            {
                var allEvents = await eventClient.GetAllAsync();

                var allEventsString = new StringBuilder();
                var i              = 1;
                var dictionary     = new ConcurrentDictionary <int, Guid>();
                var overduedEvents = allEvents.Where(oneEvent => oneEvent.BetDeadline < DateTime.Now).ToList();
                allEvents = allEvents.Where(val => !overduedEvents.Contains(val)).ToArray();
                if (allEvents.Length == 0)
                {
                    await client.SendTextMessageAsync(message.TelegramMessage.Chat,
                                                      $"Событий пока нет, чтобы предложить свое событие, напиши /createevent");

                    return;
                }
                foreach (var oneEvent in allEvents)
                {
                    dictionary[i] = oneEvent.Id;
                    allEventsString.Append($"{i} - {oneEvent.Name}\n" +
                                           $"Исходы: \n" +
                                           $"{oneEvent.Outcomes}\n" +
                                           $"Дедлайн: {oneEvent.BetDeadline}\n" +
                                           $"Описание: {oneEvent.Description}\n" +
                                           $"----------------\n");
                    i++;
                }
                await client.SendTextMessageAsync(message.TelegramMessage.Chat,
                                                  $"{allEventsString.ToString()} \n Введите номер события, на которое хотите сделать ставку");

                stateService.SaveState(message.User, new PlaceBetCommandState()
                {
                    State = PlaceBetState.EventNumber, IdDictionary = dictionary
                });
            }
        }
Exemplo n.º 3
0
        public async Task ExecuteAsync(UserMessage message)
        {
            var state       = stateService.GetCurrentState(message.User);
            var eventClient = new BetEventClient("http://localhost:27254");
            var betClient   = new BetClient("http://localhost:27254");

            if (state is CloseEventCommandState closeState)
            {
                switch (closeState.State)
                {
                case CloseEventState.EventChoosing:
                    var allEvents = await eventClient.GetAllEventsFromCreatorAsync(message.TelegramMessage.From.Id);

                    int chosenEventNumber;
                    if (!Int32.TryParse(message.Tail, out chosenEventNumber))
                    {
                        await client.SendTextMessageAsync(message.TelegramMessage.Chat,
                                                          "введите, пожалуйста, номер цифрами");

                        break;
                    }
                    if (chosenEventNumber < 1 || chosenEventNumber > allEvents.Length)
                    {
                        await client.SendTextMessageAsync(message.TelegramMessage.Chat,
                                                          "Введите, пожалуйста, существующий номер ставки");

                        break;
                    }
                    var chosenEvent = await eventClient.GetAsync((closeState.IdDictionary[chosenEventNumber]));

                    await client.SendTextMessageAsync(message.TelegramMessage.Chat,
                                                      $"Событие {chosenEventNumber}  - {chosenEvent.Name}\n" +
                                                      $"Исходы:\n" +
                                                      $"{chosenEvent.Outcomes}\n" +
                                                      $"Дедлайн: {chosenEvent.BetDeadline}\n" +
                                                      $"Описание: {chosenEvent.Description}\n" +
                                                      $"----------------\n" +
                                                      $" Выберите произошедший исход");

                    stateService.SaveState(message.User, new CloseEventCommandState()
                    {
                        State = CloseEventState.WinningOutcome, ChosenEventId = chosenEvent.Id
                    });
                    break;

                case CloseEventState.WinningOutcome:
                    var chosenOutcome = message.Tail;
                    var myEvent       = await eventClient.GetAsync(closeState.ChosenEventId);

                    var myEventOutcomes = myEvent.Outcomes.Split('\n');
                    if (!myEventOutcomes.Contains(chosenOutcome))
                    {
                        await client.SendTextMessageAsync(message.TelegramMessage.Chat,
                                                          "Введите, пожалуйста, существующий исход");

                        break;
                    }

                    await eventClient.CloseEventAsync(closeState.ChosenEventId, chosenOutcome);

                    stateService.DeleteState(message.User);
                    await client.SendTextMessageAsync(message.TelegramMessage.Chat,
                                                      "Событие успешно закрыто");

                    break;
                }
            }
            else
            {
                var allEvents = await eventClient.GetAllEventsFromCreatorAsync(message.TelegramMessage.From.Id);

                var allEventsString = new StringBuilder();
                var i          = 1;
                var dictionary = new ConcurrentDictionary <int, Guid>();
                if (allEvents.Length == 0)
                {
                    await client.SendTextMessageAsync(message.TelegramMessage.Chat,
                                                      $"Событий пока нет, чтобы предложить свое событие, напиши /createevent");

                    return;
                }
                foreach (var oneEvent in allEvents)
                {
                    dictionary[i] = oneEvent.Id;
                    allEventsString.Append($"{i} - {oneEvent.Name}\n" +
                                           $"Исходы: {oneEvent.Outcomes}\n" +
                                           $"Дедлайн: {oneEvent.BetDeadline}\n" +
                                           $"Описание: {oneEvent.Description}\n" +
                                           $"----------------\n");
                    i++;
                }
                await client.SendTextMessageAsync(message.TelegramMessage.Chat,
                                                  $"{allEventsString.ToString()} \n Введите номер события, которое хотите закрыть");

                stateService.SaveState(message.User, new CloseEventCommandState()
                {
                    State = CloseEventState.EventChoosing, IdDictionary = dictionary
                });
            }
        }