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));
}
