예제 #1
0
        protected override async Task Handle(LeaveRequest request, CancellationToken cancellationToken)
        {
            var message = request.Message;
            var room    = await _context.Rooms.Include(x => x.Users).FirstOrDefaultAsync(x => x.TelegramChatId == message.Chat.Id, cancellationToken);

            if (room == null)
            {
                _logger.LogWarning("User {User} tries to leave game from unknown chat:{ChatId}", message.From, message.Chat.Id);
                return;
            }

            var user = await _context.RoomUsers
                       .FirstOrDefaultAsync(x => x.User.TelegramUserId == message.From.Id && x.Room.TelegramChatId == message.Chat.Id,
                                            cancellationToken);

            if (user == null)
            {
                _logger.LogWarning("User {User} tries to leave in chat:{ChatId}, but it doesn't play game", message.From, message.Chat.Id);

                await _response.SendAsync(message.Chat.Id, "UserLeftFailed", message.From.Mention());
            }
            else
            {
                room.Users.Remove(user);
                await _context.SaveChangesAsync(cancellationToken);

                _logger.LogInformation("User {User} left the game in chat:{ChatId}", message.From, message.Chat.Id);

                await _response.SendAsync(message.Chat.Id, "UserLeftGame", message.From.Mention());
            }
        }
예제 #2
0
        protected override async Task Handle(TrollRequest request, CancellationToken cancellationToken)
        {
            var message = request.Message;
            var room    = await _context.Rooms.Include(x => x.Users).FirstOrDefaultAsync(x => x.TelegramChatId == message.Chat.Id, cancellationToken);

            if (room == null)
            {
                _logger.LogWarning("User {User} tries to play game in unknown chat:{ChatId}", message.From, message.Chat.Id);
                return;
            }

            var user = await _context.RoomUsers
                       .FirstOrDefaultAsync(x => x.User.TelegramUserId == message.From.Id && x.Room.TelegramChatId == message.Chat.Id,
                                            cancellationToken);

            if (user == null)
            {
                _logger.LogWarning("User {User} tries to play game in chat:{ChatId}, but it doesn't play game", message.From, message.Chat.Id);
                await _response.SendAsync(message.Chat.Id, "UserCantTroll", message.From.Mention());
            }
            else
            {
                var rnd         = new Random();
                var winnerIndex = rnd.Next(0, room.Users.Count);
                var winner      = await _context.Users.FirstOrDefaultAsync(x => x.Id == room.Users[winnerIndex].UserId, cancellationToken);

                _logger.LogWarning("User {User} wins game in chat:{ChatId}", winner.Username, winner.TelegramUserId, message.Chat.Id);

                var userStats = await _context.UserStats.FirstOrDefaultAsync(x => x.RoomId == room.Id && x.UserId == winner.Id, cancellationToken);

                if (userStats == null)
                {
                    userStats = new UserStats {
                        Room = room, User = winner
                    };
                    _context.UserStats.Attach(userStats);
                }

                room.Trolls++;
                userStats.Wins++;

                await _context.SaveChangesAsync(cancellationToken);

                var topUser = await _context.UserStats.Include(x => x.User).Where(x => x.RoomId == room.Id).OrderByDescending(x => x.Wins).FirstAsync();

                var member = await _telegram.GetChatMemberAsync(message.Chat.Id, winner.TelegramUserId, cancellationToken);

                await _response.SendAsync(message.Chat.Id, "UserWinGame", member.User.Mention(), topUser.User.Mention());
            }
        }
예제 #3
0
        protected override async Task Handle(StatsRequest request, CancellationToken cancellationToken)
        {
            var message = request.Message;
            var room    = await _context.Rooms.FirstOrDefaultAsync(x => x.TelegramChatId == message.Chat.Id, cancellationToken);

            if (room == null)
            {
                room = new Room
                {
                    TelegramChatId = message.Chat.Id,
                    Title          = message.Chat.Title
                };

                _context.Rooms.Add(room);
                await _context.SaveChangesAsync(cancellationToken);

                _logger.LogInformation("Chat:{ChatId} was created by user {User})", message.Chat.Id, message.From);

                await _response.SendAsync(message.Chat.Id, "EmptyRoomStats");
            }
            else
            {
                var userStats = await _context.UserStats.Include(x => x.User).Where(x => x.RoomId == room.Id).OrderByDescending(x => x.Wins).ToListAsync(cancellationToken);

                if (!userStats.Any())
                {
                    await _response.SendAsync(message.Chat.Id, "EmptyRoomStats");

                    return;
                }

                var sb = new StringBuilder();

                for (int i = 0; i < userStats.Count; i++)
                {
                    var userStat = userStats[i];
                    var rate     = userStat.Wins / (double)room.Trolls;
                    sb.Append(i + 1).Append(". ").Append(userStat.User.Mention())
                    .Append(" - ").Append(userStat.Wins)
                    .Append(" (").Append(rate.ToString("P")).Append(")").AppendLine();
                }

                await _response.SendAsync(message.Chat.Id, "StatsInfo", sb.ToString(), userStats.First().User.Mention());
            }
        }
예제 #4
0
        protected override async Task Handle(JoinRequest request, CancellationToken cancellationToken)
        {
            var message = request.Message;
            var room    = await _context.Rooms.FirstOrDefaultAsync(x => x.TelegramChatId == message.Chat.Id, cancellationToken);

            if (room == null)
            {
                room = new Room
                {
                    TelegramChatId = message.Chat.Id,
                    Title          = message.Chat.Title
                };

                _context.Rooms.Add(room);
                await _context.SaveChangesAsync(cancellationToken);

                _logger.LogInformation("Chat:{ChatId} was created by user {User})", message.Chat.Id, message.From);
            }

            var user = await _context.Users.FirstOrDefaultAsync(x => x.TelegramUserId == message.From.Id,
                                                                cancellationToken);

            if (user == null)
            {
                user = new User
                {
                    TelegramUserId = message.From.Id,
                    Username       = message.From.Username,
                    FirstName      = message.From.FirstName,
                    LastName       = message.From.LastName
                };

                _context.Users.Add(user);
                await _context.SaveChangesAsync(cancellationToken);

                _logger.LogInformation("User {User} has been created and joined to game in chat:{ChatId}", message.From, room.TelegramChatId);
            }

            var roomUser = await _context.RoomUsers
                           .FirstOrDefaultAsync(x => x.User.TelegramUserId == message.From.Id && x.Room.TelegramChatId == message.Chat.Id, cancellationToken);

            if (roomUser == null)
            {
                roomUser = new RoomUser
                {
                    Room = room,
                    User = user
                };

                _context.RoomUsers.Add(roomUser);
                await _context.SaveChangesAsync(cancellationToken);

                _logger.LogInformation("User {User} joined to play in chat:{ChatId}", message.From, message.Chat.Id);

                await _response.SendAsync(message.Chat.Id, "UserJoined", message.From.Mention());
            }
            else
            {
                _logger.LogWarning("User {User} has already been joined to play in chat:{ChatId}", message.From, message.Chat.Id);

                await _response.SendAsync(message.Chat.Id, "UserAlreadyJoined", message.From.Mention());
            }
        }