public async Task <IActionResult> ExternalLoginConfirmation(ExternalLoginViewModel model, string returnUrl = null) { if (ModelState.IsValid) { // Get the information about the user from the external login provider var info = await _signInManager.GetExternalLoginInfoAsync(); if (info == null) { throw new ApplicationException("Error loading external login information during confirmation."); } var user = new LiteDbUser { UserName = model.Email, Email = model.Email }; var result = await _userManager.CreateAsync(user); if (result.Succeeded) { result = await _userManager.AddLoginAsync(user, info); if (result.Succeeded) { await _signInManager.SignInAsync(user, false); _logger.LogInformation("User created an account using {Name} provider.", info.LoginProvider); return(RedirectToLocal(returnUrl)); } } AddErrors(result); } ViewData["ReturnUrl"] = returnUrl; return(View(nameof(ExternalLogin), model)); }
public async Task <ServerSelectedMods[]> FindAllFrom(LiteDbUser liteDbUser) { return((await _liteDb.LiteDatabaseAsync.GetCollection <ServerSelectedMods>("ServerSelectedMods") .Include(x => x.LiteDbUser) .Include(x => x.PavlovServer) .FindAsync(x => x.LiteDbUser.Id == liteDbUser.Id)).ToArray()); }
public async Task <IActionResult> Register(RegisterViewModel model, string returnUrl = null) { ViewData["ReturnUrl"] = returnUrl; if (ModelState.IsValid) { var user = new LiteDbUser { UserName = model.Username, Email = model.Username + "@" + model.Username }; // workeround caus dont like emails as account var result = await _userManager.CreateAsync(user, model.Password); if (result.Succeeded) { _logger.LogInformation("User created a new account with password."); //var code = await _userManager.GenerateEmailConfirmationTokenAsync(user); //var callbackUrl = Url.EmailConfirmationLink(user.Id, code, Request.Scheme); //await _emailSender.SendEmailConfirmationAsync(model.Email, callbackUrl); //await _signInManager.SignInAsync(user, false); _logger.LogInformation("User created a new account with password."); await _userManager.AddToRoleAsync(user, "User"); return(RedirectToUserIndex()); //return RedirectToLocal(returnUrl); } AddErrors(result); } // If we got this far, something failed, redisplay form return(View(model)); }
public void FindByIdAsyncTest() { var manager = services.GetUserManager(); LiteDbUser newUser = SetUpUser(manager); var user = manager.FindByIdAsync(newUser.Id.ToString()).GetAwaiter().GetResult(); user.Should().NotBeNull(); user.Should().Match <LiteDbUser>(u => u.Id == newUser.Id); }
public void FindByNameAsyncTest() { var manager = services.GetUserManager(); LiteDbUser newUser = SetUpUser(manager); var user = manager.FindByNameAsync(newUser.NormalizedUserName).GetAwaiter().GetResult(); user.Should().NotBeNull(); user.Should().Match <LiteDbUser>(u => u.NormalizedUserName == newUser.NormalizedUserName); }
public void GetUserIdAsyncTest() { var manager = services.GetUserManager(); LiteDbUser newUser = SetUpUser(manager); var id = manager.GetUserIdAsync(newUser).GetAwaiter().GetResult(); id.Should().NotBeNull(); id.Should().Match(newUser.Id.ToString()); }
public void GetUserNameAsyncTest() { var manager = services.GetUserManager(); LiteDbUser newUser = SetUpUser(manager); var userName = manager.GetUserNameAsync(newUser).GetAwaiter().GetResult(); userName.Should().NotBeNull(); userName.Should().Match(newUser.UserName); }
public void DeleteAsyncTest() { var manager = services.GetUserManager(); LiteDbUser newUser = SetUpUser(manager); var result = manager.DeleteAsync(newUser).GetAwaiter().GetResult(); var user = manager.FindByNameAsync(newUser.NormalizedUserName).GetAwaiter().GetResult(); result.Should().Be(IdentityResult.Success); user.Should().BeNull(); }
private LiteDbUser SetUpUser(UserManager <LiteDbUser> manager) { var user = new LiteDbUser() { UserName = "******", Email = "*****@*****.**", }; manager.CreateAsync(user).GetAwaiter().GetResult(); return(user); }
public async Task <IActionResult> LoginCallback(string returnUrl = null, string remoteError = null) { returnUrl ??= Url.Content("~/"); if (remoteError != null) { ViewBag.ErrorMessage = $"快速登录失败: {remoteError}"; return(RedirectToAction("Login", new { ReturnUrl = returnUrl })); } var info = await _signInManager.GetExternalLoginInfoAsync(); if (info == null) { ViewBag.ErrorMessage = "获取快速登录信息失败"; return(RedirectToAction("Login", new { ReturnUrl = returnUrl })); } var result = await _signInManager.ExternalLoginSignInAsync(info.LoginProvider, info.ProviderKey, isPersistent : false, bypassTwoFactor : true); if (result.Succeeded) { return(LocalRedirect(returnUrl)); } if (result.IsLockedOut) { ViewBag.ErrorMessage = "用户已被锁定,无法登录"; return(RedirectToAction("Login", new { ReturnUrl = returnUrl })); } if (info.Principal.HasClaim(c => c.Type == ClaimTypes.Email)) { var email = info.Principal.FindFirstValue(ClaimTypes.Email); var user = new LiteDbUser { UserName = email, Email = email }; var result1 = await _userManager.CreateAsync(user); if (result1.Succeeded) { result1 = await _userManager.AddLoginAsync(user, info); if (result1.Succeeded) { await _signInManager.SignInAsync(user, isPersistent : false, info.LoginProvider); return(LocalRedirect(returnUrl)); } } ViewBag.ErrorMessage = string.Join("<br />", result1.Errors.Select(x => x.Description).ToArray()); } else { ViewBag.ErrorMessage = "登录信息非邮箱,无法登录"; } return(RedirectToAction("Login", new { ReturnUrl = returnUrl })); }
public static LiteDbUser SetUpUser(UserManager <LiteDbUser> manager, string name = "Test", string email = "*****@*****.**") { var user = new LiteDbUser { UserName = name, Email = email }; manager.CreateAsync(user).GetAwaiter().GetResult(); return(user); }
private void CreateAndInitializeATeamWithAMember(out LiteDbUser user, out SteamIdentity steamIdentity, out Team team) { user = ServerSelectedModServiceTests.InsertUserAndSteamIdentity(_steamIdentityService, _userManager); steamIdentity = _steamIdentityService.FindAll().GetAwaiter().GetResult().First(); team = CreateTeam(_teamService); _teamSelectedSteamIdentityService.Insert(new TeamSelectedSteamIdentity { Team = team, SteamIdentity = steamIdentity, RoleOverwrite = "" }); }
public void SetUserNameAsyncTest() { var manager = services.GetUserManager(); LiteDbUser newUser = SetUpUser(manager); var newName = "NewTestName"; var result = manager.SetUserNameAsync(newUser, newName).GetAwaiter().GetResult(); var user = manager.FindByNameAsync(newUser.NormalizedUserName).GetAwaiter().GetResult(); result.Should().Be(IdentityResult.Success); user.Should().NotBeNull(); user.Should().Match <LiteDbUser>(u => u.UserName == newName); }
public void CreateAsyncTest() { var manager = services.GetUserManager(); LiteDbUser newUser = new LiteDbUser() { UserName = "******", Email = "*****@*****.**", }; var result = manager.CreateAsync(newUser).GetAwaiter().GetResult(); var user = manager.FindByNameAsync(newUser.NormalizedUserName).GetAwaiter().GetResult(); result.Should().Be(IdentityResult.Success); user.Should().NotBeNull(); user.Should().Match <LiteDbUser>(u => u.UserName == newUser.UserName && u.Email == newUser.Email); }
public async Task <bool> IsModSomeWhere(LiteDbUser user, ServerSelectedModsService serverSelectedModsService) { var servers = (await FindAll()).ToArray(); var isModSomeWhere = false; foreach (var pavlovServer in servers) { if (isModSomeWhere || await RightsHandler.IsModOnTheServer(serverSelectedModsService, pavlovServer, user.Id)) { isModSomeWhere = true; } } return(isModSomeWhere); }
public void UpdateAsyncTest() { var manager = services.GetUserManager(); LiteDbUser newUser = SetUpUser(manager); newUser.UserName = "******"; newUser.Email = "*****@*****.**"; var result = manager.UpdateAsync(newUser).GetAwaiter().GetResult(); var user = manager.FindByNameAsync(newUser.NormalizedUserName).GetAwaiter().GetResult(); result.Should().Be(IdentityResult.Success); user.Should().NotBeNull(); user.Should().Match <LiteDbUser>(u => u.UserName == "NewTestNameV2"); user.Should().Match <LiteDbUser>(u => u.Email == "*****@*****.**"); }
private static PavlovServer[] InsertToPavlovServer(LiteDbUser user, SshServerSerivce sshServerSerivce, PavlovServerService pavlovServerService, ServerSelectedModsService serverSelectedModsService, bool withInsert = true) { var pavlovServers = PavlovServerServiceTests.InitializePavlovServer(sshServerSerivce, pavlovServerService); if (withInsert) { serverSelectedModsService.Insert(new ServerSelectedMods { LiteDbUser = user, PavlovServer = pavlovServers.First() }).GetAwaiter().GetResult(); } return(pavlovServers); }
public void UserInRole(LiteDbUser user, ServerSelectedModsService serverSelectedModsService, PavlovServerService pavlovServerService, out bool isAdmin, out bool isCaptain, out bool isMod, out bool isOnPremise, out bool isServerRent, out bool isModSomeWhere, out bool Premium) { isAdmin = false; isCaptain = false; isMod = false; isOnPremise = false; isServerRent = false; isModSomeWhere = false; Premium = false; if (user == null) { return; } isAdmin = _userManager.IsInRoleAsync(user, "Admin").GetAwaiter().GetResult(); isCaptain = _userManager.IsInRoleAsync(user, "Captain").GetAwaiter().GetResult(); isMod = _userManager.IsInRoleAsync(user, "Mod").GetAwaiter().GetResult(); isOnPremise = _userManager.IsInRoleAsync(user, "OnPremise").GetAwaiter().GetResult(); isServerRent = _userManager.IsInRoleAsync(user, "ServerRent").GetAwaiter().GetResult(); Premium = _userManager.IsInRoleAsync(user, "Premium").GetAwaiter().GetResult(); isModSomeWhere = pavlovServerService.IsModSomeWhere(user, serverSelectedModsService).GetAwaiter() .GetResult(); }
public async Task <Team[]> FindAllTeamsWhereTheUserHasRights(ClaimsPrincipal cp, LiteDbUser user) { var steamIdentities = await _selectedSteamIdentityService.FindAllFrom(user.Id); var allTeams = steamIdentities.Where(x => x.Team != null).Select(x => x.Team).Distinct().ToArray(); foreach (var team in allTeams) { team.TeamSelectedSteamIdentities = (await _selectedSteamIdentityService.FindAllFrom(team.Id)).ToList(); } if (cp.IsInRole("Admin") || cp.IsInRole("Mod") || cp.IsInRole("Captain")) { var tmpTeams = (await FindAll()).ToArray(); foreach (var tmpTeam in tmpTeams) { tmpTeam.TeamRole = "Admin"; } return(tmpTeams.ToArray()); } //Team Admins and Mods get added as mods to the server. So they don't need to get handled here. var tmpServer = new List <Team>(); var ownSteamIdentityTeamSelectedSteamIdentity = steamIdentities.FirstOrDefault(x => x.SteamIdentity.LiteDbUser.Id == user.Id); if (ownSteamIdentityTeamSelectedSteamIdentity == null) { return(tmpServer.ToArray()); } var ownSteamIdentity = ownSteamIdentityTeamSelectedSteamIdentity.SteamIdentity; foreach (var singleTeam in allTeams) { singleTeam.TeamRole = singleTeam.TeamSelectedSteamIdentities? .FirstOrDefault(x => x.SteamIdentity != null && x.SteamIdentity.Id == ownSteamIdentity.Id)?.RoleOverwrite; } return(allTeams.Where(x => x.TeamRole == "Admin" || x.TeamRole == "Captain" || x.TeamRole == "Mod").ToArray()); }
public async Task <SshServer[]> FindAllWithRightsCheck(ClaimsPrincipal principal, LiteDbUser user) { var query = _liteDb.LiteDatabaseAsync.GetCollection <SshServer>("SshServer") .Include(x => x.Owner).Query(); var list = new List <SshServer>(); var rental = principal.IsInRole("ServerRent"); if (principal.IsInRole("Admin")) { list.AddRange(await query.Where(x => true).ToListAsync()); } else { if (principal.IsInRole("OnPremise")) { list.AddRange(await query.Where(x => x.Owner != null && x.Owner.Id == user.Id).ToListAsync()); } } //var list = ( // .FindAllAsync()).ToArray(); foreach (var single in list) { single.PavlovServers = (await _pavlovServerService.FindAllFrom(single.Id)).ToList(); } if (rental) { var all = await FindAll(); foreach (var single in all) { single.PavlovServers = (await _pavlovServerService.FindAllFrom(single.Id)) .Where(x => x.Owner != null && x.Owner.Id == user.Id).ToList(); } return(all.Where(x => x.PavlovServers.Any()).ToArray()); } return(list.ToArray()); }
public async Task <IActionResult> ExternalLoginConfirmation(ExternalLoginViewModel model, string returnUrl = null) { if (ModelState.IsValid) { // Get the information about the user from the external login provider var info = await _signInManager.GetExternalLoginInfoAsync(); if (info == null) { throw new ApplicationException("Error loading external login information during confirmation."); } var email = GetEmailFromExternalProvider(info); var emailAlreadyExist = await _userService.GetUserByEmail(email); if (emailAlreadyExist != null) { ModelState.AddModelError("UserName", "Your email already exist. If you already have an account please remove it first or contact the Administrator for help."); } else { LiteDbUser user = null; if (info.LoginProvider.ToLower() == "paypal") { user = new LiteDbUser { UserName = model.UserName, Email = email }; } else { user = new LiteDbUser { UserName = model.UserName }; } var result = await _userManager.CreateAsync(user); if (result.Succeeded) { result = await _userManager.AddLoginAsync(user, info); if (result.Succeeded) { //GetSteamID if (info.LoginProvider.ToLower() == "steam") { await OverWriteExistingSteamIdOrSaveNewOne(info, user); } await _signInManager.SignInAsync(user, false); await _userManager.AddToRoleAsync(user, "User"); //todo add Steam identity _logger.LogInformation("User created an account using {Name} provider.", info.LoginProvider); return(RedirectToLocal(returnUrl)); } } AddErrors(result); } } ViewData["ReturnUrl"] = returnUrl; return(View(nameof(ExternalLogin), model)); }
private async Task OverWriteExistingSteamIdOrSaveNewOne(ExternalLoginInfo info, LiteDbUser user) { var steam = CrawlSteamIdentity(info); //Todo get existing one and give it to the player or save it as a new one var realSteamIdentity = await _steamIdentityService.FindOne(steam.Id); if (realSteamIdentity != null) { realSteamIdentity.LiteDbUser = user; await _steamIdentityService.Upsert(realSteamIdentity); } else { steam.LiteDbUser = user; await _steamIdentityService.Upsert(steam); } }
public async Task <PavlovServer[]> FindAllServerWhereTheUserHasRights(ClaimsPrincipal cp, LiteDbUser user) { //Team Admins and Mods get added as mods to the server. So they don't need to get handled here. var tmpServer = new List <PavlovServer>(); var allServer = _liteDb.LiteDatabaseAsync.GetCollection <PavlovServer>("PavlovServer") .Include(x => x.SshServer) .Include(x => x.SshServer.Owner) .Include(x => x.Owner) .Query(); if (cp.IsInRole("Admin")) { return(await allServer.ToArrayAsync()); } if (cp.IsInRole("Mod") || cp.IsInRole("Captain")) { tmpServer.AddRange((await allServer.Where(x => x.Owner == null && x.SshServer.Owner == null).ToArrayAsync()).Where(y => !tmpServer.Select(c => c.Id).Contains(y.Id))); } if (cp.IsInRole("ServerRent")) { tmpServer.AddRange((await allServer.Where(x => x.Owner != null && x.Owner.Id == user.Id).ToArrayAsync()).Where(y => !tmpServer.Select(c => c.Id).Contains(y.Id))); } if (cp.IsInRole("OnPremise")) { tmpServer.AddRange((await allServer.Where(x => x.SshServer.Owner != null && x.SshServer.Owner.Id == user.Id).ToArrayAsync()).Where(y => !tmpServer.Select(c => c.Id).Contains(y.Id))); } if (await IsModSomeWhere(user, _serverSelectedModsService)) { var serversIds = (await _serverSelectedModsService.FindAllFrom(user)).Select(x => x.PavlovServer.Id).ToArray(); tmpServer.AddRange((await allServer.Where(x => serversIds.Contains(x.Id)).ToArrayAsync()).Where(y => !tmpServer.Select(c => c.Id).Contains(y.Id))); } return(tmpServer.ToArray()); }
public async Task <bool> IsUserInRole(string role, LiteDbUser user) { return(await _userManager.IsInRoleAsync(user, role)); }