Esempio n. 1
0
        public async Task <IActionResult> Login()
        {
            if (User.Identity.IsAuthenticated)
            {
                return(RedirectToAction("Index", "Home"));
            }

            try
            {
                if (!await _roleManager.RoleExistsAsync("Admin"))
                {
                    var role = new BotUserRole("Admin");
                    await _roleManager.CreateAsync(role);
                }
                if (!await _roleManager.RoleExistsAsync("LogViewer"))
                {
                    var role = new BotUserRole("LogViewer");
                    await _roleManager.CreateAsync(role);
                }
            }
            catch (Exception exc)
            {
                this._logger.LogError(LoggingEvents.IdentityOperationException, exc, "Unable to create roles");
            }

            return(View());
        }
Esempio n. 2
0
        public async Task AddUserRole(ulong userId, BotRoleType roleType)
        {
            var botUserRole = new BotUserRole()
            {
                UserId      = userId,
                BotRoleType = roleType
            };

            await _dbContext.AddAsync(botUserRole);

            await _dbContext.SaveChangesAsync();
        }
Esempio n. 3
0
        public async Task <IActionResult> Register(RegisterViewModel model)
        {
            if (ModelState.IsValid)
            {
                var secret = await this._secretProvider.CheckSecretCode(model.SecretCode);

                if (secret != null)
                {
                    try
                    {
                        var user = new BotUser {
                            UserName = model.UserName, ChatId = Convert.ToInt64(model.Token), IsEnabled = true
                        };
                        var result = await _userManager.CreateAsync(user, model.Password);

                        if (result.Succeeded)
                        {
                            if (secret.AdminPrivileges)
                            {
                                if (!await _roleManager.RoleExistsAsync("Admin"))
                                {
                                    var role = new BotUserRole("Admin");
                                    await _roleManager.CreateAsync(role);
                                }

                                var assignResult = await _userManager.AddToRoleAsync(user, "Admin");

                                if (!assignResult.Succeeded)
                                {
                                    var msg = string.Empty;
                                    foreach (var error in assignResult.Errors)
                                    {
                                        msg += $"Code[{error.Code}]: {error.Description}";
                                    }

                                    _logger.LogError($"Unable to assign user to admin role: \r\n {msg}");
                                }
                            }

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

                            _logger.LogInformation(3, "User created a new account with password.");
                            return(RedirectToAction("Index", "Home"));
                        }
                        AddErrors(result);
                    }
                    catch (Exception exc)
                    {
                        _logger.LogError(LoggingEvents.RegisterAttemptFailed, exc, "Unable to register new user.");
                        ModelState.AddModelError(string.Empty, "Unable to register new user.");
                    }
                }
                else
                {
                    _logger.LogWarning(LoggingEvents.RegisterAttemptFailedWithWrongSecurityCode, $"Somebody tried to register with wrong secret code. Register parameters: " +
                                       $"user name [{model.UserName}]; token: [{model.Token}]; secret code: [{model.SecretCode}]");
                    ModelState.AddModelError("SecretCode", "Unrecognized secret code provided");
                }
            }

            ViewData["Token"] = model.Token;
            return(View(model));
        }