Esempio n. 1
0
 public bool Equals(LfgUser other)
 {
     return(other != null &&
            Username.Equals(other.Username) &&
            Discriminator.Equals(other.Discriminator) &&
            DiscordId.Equals(other.DiscordId));
 }
Esempio n. 2
0
        public async Task <bool> StartTriviaAsync(int questionsToPlay, SocketCommandContext context)
        {
            // Create a combination of guildID and channelID to form a unique identifier for each trivia instance
            var id = new DiscordId(context.Guild.Id, context.Channel.Id, null);

            if (!trivias.ContainsKey(id))
            {
                _ = trivias.TryAdd(id, new OTDBTriviaInstance(context, dbContext, clientFactory));
            }
            return(trivias.TryGetValue(id, out OTDBTriviaInstance instance)
                ? await instance.StartTriviaAsync(questionsToPlay).ConfigureAwait(false)
                : false);
        }
Esempio n. 3
0
        /// <summary>
        /// Gets the current global high scores for the guild
        /// </summary>
        /// <param name="context">Context of the channel where the high score was requested</param>
        /// <returns></returns>
        public async Task <string> GetGlobalHighScoresAsync(int amount, SocketCommandContext context)
        {
            var id = new DiscordId(context.Guild.Id, context.Channel.Id, null);

            if (id.GuildId == null || !trivias.ContainsKey(id))
            {
                using var trivia = new OTDBTriviaInstance(context, dbContext, clientFactory);
                return(await trivia.GetGlobalHighScoresAsync(amount, id.GuildId.Value).ConfigureAwait(false));
            }
            else
            {
                return(await trivias[id].GetGlobalHighScoresAsync(amount, id.GuildId.Value).ConfigureAwait(false));
            }
        }
Esempio n. 4
0
        /// <summary>
        /// Stops the trivia in the specified guild's channel if a trivia is running, otherwise returns false
        /// </summary>
        /// <param name="id">Combined Id of the Discord Guild and channel for the trivia</param>
        /// <returns>success</returns>
        public async Task <bool> StopTriviaAsync(DiscordId id)
        {
            if (!trivias.ContainsKey(id))
            {
                return(false);
            }
            else
            {
                var result = await trivias[id].StopTriviaAsync().ConfigureAwait(false);
                if (trivias.TryRemove(id, out var instance))
                {
                    instance.Dispose();
                }

                return(result);
            }
        }
Esempio n. 5
0
 /// <summary>
 /// Skips the trivia in the specified guild's channel if a trivia is running, otherwise returns false
 /// </summary>
 /// <param name="id">Combined Id of the Discord Guild and channel for the trivia</param>
 /// <returns>success</returns>
 public async Task <bool> SkipQuestionAsync(DiscordId id)
 {
     return(trivias.ContainsKey(id) ? await trivias[id].SkipQuestionAsync().ConfigureAwait(false) : false);
 }
        public async Task <IActionResult> LoginWithBot([FromQuery] string token)
        {
            string DiscordIdFromLink;
            bool   isValid;

            // Validate the token.
            try
            {
                string decryptedToken = StringCipher.Decrypt(token, _configuration["TokenPassword"]);
                if (Hmac.VerifyMessage(decryptedToken, _configuration["TokenKey"]))
                {
                    isValid           = true;
                    DiscordIdFromLink = Hmac.DecodeMessage(decryptedToken);
                }
                else
                {
                    return(BadRequest());
                }
            }
            catch
            {
                return(BadRequest());
            }

            // Handle login.
            if (isValid)
            {
                StreamNightUser user = await _userManager.FindByNameAsync(DiscordIdFromLink);

                bool signInUser = true;

                if (user == null)
                {
                    signInUser = false;
                    // User doesn't have an account, let's transparently create one and log them in.
                    ulong.TryParse(DiscordIdFromLink, out ulong DiscordId);
                    user = new StreamNightUser {
                        UserName = DiscordId.ToString(), DiscordId = DiscordId
                    };
                    var result = await _userManager.CreateAsync(user);

                    if (result.Succeeded)
                    {
                        signInUser = true;
                        _logger.LogInformation("Created a new user from a Discord link.");
                    }
                }

                if (signInUser)
                {
                    // Check if the user should be in the administrator role
                    try
                    {
                        bool hasStreamRole = false;
                        bool hasAdminRole  = false;
                        // Get the user's roles from the Discord bot
                        DSharpPlus.Entities.DiscordMember member = await _discordBot.DiscordClient.GetMemberById(user.DiscordId);

                        foreach (DSharpPlus.Entities.DiscordRole discordRole in member.Roles)
                        {
                            // If the user has the stream role
                            if (discordRole.Name == _discordBot.DiscordClient.StreamRole)
                            {
                                hasStreamRole = true;
                            }
                            if (discordRole.Name == _discordBot.DiscordClient.AdminRole)
                            {
                                hasAdminRole = true;
                            }
                        }

                        // Check if the user is in the stream role already
                        bool userInStreamRole = await _userManager.IsInRoleAsync(user, "StreamController");

                        if (!userInStreamRole && hasStreamRole)
                        {
                            // Add the stream role to the user
                            await _userManager.AddToRoleAsync(user, "StreamController");
                        }
                        else if (userInStreamRole && !hasStreamRole)
                        {
                            // Remove the stream role from the user
                            await _userManager.RemoveFromRoleAsync(user, "StreamController");
                        }

                        // Check if the user is in the admin role already
                        bool userInAdmin = await _userManager.IsInRoleAsync(user, "Administrator");

                        if (!userInAdmin && hasAdminRole)
                        {
                            // Add the admin role to the user
                            await _userManager.AddToRoleAsync(user, "Administrator");
                        }
                        else if (userInAdmin && !hasAdminRole)
                        {
                            // Remove the admin role from the user
                            await _userManager.RemoveFromRoleAsync(user, "Administrator");
                        }
                    }
                    // The user might not exist, catch the exception and do nothing
                    catch (NullReferenceException) { }

                    await _signInManager.SignInAsync(user, isPersistent : false, authenticationMethod : "DiscordLink");

                    _logger.LogInformation("User logged in using a Discord link.");
                }

                return(LocalRedirect(returnUrl));
            }

            return(BadRequest());
        }
Esempio n. 7
0
        public async Task <IActionResult> OnPostConfirmationAsync(string returnUrl = null)
        {
            returnUrl ??= Url.Content("~/");
            // Get the information about the user from the external login provider
            var info = await _signInManager.GetExternalLoginInfoAsync();

            if (info == null)
            {
                ErrorMessage = "Error loading external login information during confirmation.";
                return(RedirectToPage("./Login", new { ReturnUrl = returnUrl }));
            }

            if (ModelState.IsValid)
            {
                ulong.TryParse(info.Principal.FindFirstValue(ClaimTypes.NameIdentifier), out ulong DiscordId);
                var user = new StreamNightUser {
                    UserName = DiscordId.ToString(), DiscordId = DiscordId
                };
                var result = await _userManager.CreateAsync(user);

                if (result.Succeeded)
                {
                    try
                    {
                        // Get the user's roles from the Discord bot
                        DSharpPlus.Entities.DiscordMember member = await _discordBot.DiscordClient.GetMemberById(user.DiscordId);

                        foreach (DSharpPlus.Entities.DiscordRole discordRole in member.Roles)
                        {
                            // If the user has the stream role
                            if (discordRole.Name == _discordBot.DiscordClient.StreamRole)
                            {
                                await _userManager.AddToRoleAsync(user, "StreamController");
                            }
                            if (discordRole.Name == _discordBot.DiscordClient.AdminRole)
                            {
                                await _userManager.AddToRoleAsync(user, "Administrator");
                            }
                        }
                    }
                    // The user might not exist, catch the exception and do nothing
                    catch (NullReferenceException) { }

                    result = await _userManager.AddLoginAsync(user, info);

                    if (result.Succeeded)
                    {
                        await _signInManager.SignInAsync(user, isPersistent : false);

                        _logger.LogInformation("User created an account using {Name} provider.", info.LoginProvider);
                        return(LocalRedirect(returnUrl));
                    }
                }
                else if (result.Errors.Where(e => e.Code == "DuplicateUserName").Any())
                {
                    var existingUser = await _userManager.FindByNameAsync(DiscordId.ToString());

                    var addLoginResult = await _userManager.AddLoginAsync(existingUser, info);

                    if (addLoginResult.Succeeded)
                    {
                        await _signInManager.SignInAsync(existingUser, isPersistent : false);

                        return(LocalRedirect(returnUrl));
                    }
                }
                else
                {
                    ViewData["ResultMessage"] = "Couldn't sign in with Discord. Try logging in with a DM instead.";
                }

                foreach (var error in result.Errors)
                {
                    ModelState.AddModelError(string.Empty, error.Description);
                }
            }

            LoginProvider = info.LoginProvider;
            ReturnUrl     = returnUrl;
            return(Page());
        }
Esempio n. 8
0
 public string Echo(DiscordId id)
 {
     return(id.ToString());
 }