public async Task <IActionResult> LoginWith2fa(LoginWith2faViewModel model, bool rememberMe, string returnUrl = null)
{
if (!ModelState.IsValid)
{
return(View(model));
}
MongoIdentityUser user = await loginService.GetTwoFactorAuthenticationUserAsync();
if (user == null)
{
throw new Exception($"Unable to load user with ID '{_userManager.GetUserId(User)}'.");
}
var authenticatorCode = model.TwoFactorCode.Replace(" ", string.Empty).Replace("-", string.Empty);
Microsoft.AspNetCore.Identity.SignInResult result = await loginService.TwoFactorAuthenticatorSignInAsync(authenticatorCode, rememberMe, model.RememberMachine);
if (result.Succeeded)
{
_logger.LogInformation("User with ID {UserId} logged in with 2fa.", user.Id);
return(RedirectToLocal(returnUrl));
}
else if (result.IsLockedOut)
{
_logger.LogWarning("User with ID {UserId} account locked out.", user.Id);
return(RedirectToAction(nameof(Lockout)));
}
else
{
_logger.LogWarning("Invalid authenticator code entered for user with ID {UserId}.", user.Id);
ModelState.AddModelError(string.Empty, "Invalid authenticator code.");
return(View());
}
}
public async Task <IActionResult> Register(RegisterViewModel model, string returnUrl = null)
{
ViewData["ReturnUrl"] = returnUrl;
if (ModelState.IsValid)
{
var user = new MongoIdentityUser(model.Email, model.Email);
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
// For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=532713
// Send an email with this link
//var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
//var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: HttpContext.Request.Scheme);
//await _emailSender.SendEmailAsync(model.Email, "Confirm your account",
// $"Please confirm your account by clicking this link: <a href='{callbackUrl}'>link</a>");
await _signInManager.SignInAsync(user, isPersistent : false);
_logger.LogInformation(3, "User created a new account with password.");
return(RedirectToLocal(returnUrl));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <IActionResult> LoginWithRecoveryCode(LoginWithRecoveryCodeViewModel model, string returnUrl = null)
{
if (!ModelState.IsValid)
{
return(View(model));
}
MongoIdentityUser user = await loginService.GetTwoFactorAuthenticationUserAsync();
if (user == null)
{
throw new ApplicationException($"Unable to load two-factor authentication user.");
}
var recoveryCode = model.RecoveryCode.Replace(" ", string.Empty);
Microsoft.AspNetCore.Identity.SignInResult result = await loginService.TwoFactorRecoveryCodeSignInAsync(recoveryCode);
if (result.Succeeded)
{
_logger.LogInformation("User with ID {UserId} logged in with a recovery code.", user.Id);
return(RedirectToLocal(returnUrl));
}
if (result.IsLockedOut)
{
_logger.LogWarning("User with ID {UserId} account locked out.", user.Id);
return(RedirectToAction(nameof(Lockout)));
}
else
{
_logger.LogWarning("Invalid recovery code entered for user with ID {UserId}", user.Id);
ModelState.AddModelError(string.Empty, "Invalid recovery code entered.");
return(View());
}
}
public async Task <IActionResult> Register([FromBody] RegistrationUser model)
{
if (ModelState.IsValid)
{
var user = new MongoIdentityUser
{
FirstName = model.FirstName,
LastName = model.LastName,
City = model.City,
UserName = model.Email,
Email = model.Email
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, false);
var token = TokenService.GenerateJwtToken(model.Email, user, _configuration);
var rootData = new RegistrationResponse(token, user.UserName, user.Email);
return(Created("api/v1/authentication/register", rootData));
}
return(Ok(string.Join(",", result.Errors?.Select(error => error.Description))));
}
string errorMessage = string.Join(", ", ModelState.Values.SelectMany(x => x.Errors).Select(x => x.ErrorMessage));
return(BadRequest(errorMessage ?? "Bad Request"));
}
public async Task <IActionResult> ExternalLoginConfirmation(ExternalLoginConfirmationViewModel 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)
{
return(View("ExternalLoginFailure"));
}
var user = new MongoIdentityUser(model.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, isPersistent : false);
_logger.LogInformation(6, "User created an account using {Name} provider.", info.LoginProvider);
return(RedirectToLocal(returnUrl));
}
}
AddErrors(result);
}
ViewData["ReturnUrl"] = returnUrl;
return(View(model));
}
public async Task <Token> Handle(RegisterUserCommand request, CancellationToken cancellationToken)
{
var identityUser = new MongoIdentityUser(request.Email, request.Email);
identityUser.AddClaim(new MongoUserClaim("Email", request.Email));
identityUser.AddClaim(new MongoUserClaim("Type", EUserType.Committee.ToString()));
var result = await _userManager.CreateAsync(identityUser, request.Password);
if (!result.Succeeded)
{
foreach (int er in result.Errors.Select(x => Convert.ToInt32(x.Code)))
{
_notificationContext.PushNotification((ReturnCode)er);
}
return(null);
}
var user = new Person()
{
IdentityUserId = identityUser.Id,
Name = request.Name,
Email = request.Email,
Type = EUserType.Committee,
Approved = true,
ArticlesCount = 0
};
await _repository.AddAsync <Person>(user);
await _signInManager.SignInAsync(identityUser, false);
return(await GerarJwt(identityUser));
}
public async Task <IActionResult> VerifyCode(string provider, bool rememberMe, string returnUrl = null)
{
// Require that the user has already logged in via username/password or external login
MongoIdentityUser user = await loginService.GetTwoFactorAuthenticationUserAsync();
if (user == null)
{
return(View("Error"));
}
return(View(new VerifyCodeViewModel {
Provider = provider, ReturnUrl = returnUrl, RememberMe = rememberMe
}));
}
public async Task CanCreateAndDeleteUser()
{
var user = new MongoIdentityUser("test_account", "*****@*****.**");
var createResult = await _userStore.CreateAsync(user, CancellationToken.None);
createResult.ShouldNotBeNull();
createResult.Succeeded.ShouldBeTrue();
var deleteResult = await _userStore.DeleteAsync(user, CancellationToken.None);
deleteResult.ShouldNotBeNull();
deleteResult.Succeeded.ShouldBeTrue();
}
public async Task ValidateAsync(ResourceOwnerPasswordValidationContext context)
{
MongoIdentityUser user = await loginService.FindByUsername(context.UserName);
if (await loginService.ValidateCredentials(user, context.Password))
{
context.Result = new GrantValidationResult(user.Id, OidcConstants.AuthenticationMethods.Password);
}
else
{
context.Result = new GrantValidationResult(TokenRequestErrors.InvalidGrant, "invalid credential");
}
}
public async Task <IActionResult> UseRecoveryCode(string returnUrl = null)
{
// Require that the user has already logged in via username/password or external login
MongoIdentityUser user = await loginService.GetTwoFactorAuthenticationUserAsync();
if (user == null)
{
return(View("Error"));
}
return(View(new UseRecoveryCodeViewModel {
ReturnUrl = returnUrl
}));
}
public async Task <IActionResult> LoginWithRecoveryCode(string returnUrl = null)
{
// Ensure the user has gone through the username & password screen first
MongoIdentityUser user = await loginService.GetTwoFactorAuthenticationUserAsync();
if (user == null)
{
throw new ApplicationException($"Unable to load two-factor authentication user.");
}
ViewData["ReturnUrl"] = returnUrl;
return(View());
}
#pragma warning restore SCS0029 // Potential XSS vulnerability
private async Task LoadSharedKeyAndQrCodeUriAsync(MongoIdentityUser user, EnableAuthenticatorViewModel model)
{
var unformattedKey = await _userManager.GetAuthenticatorKeyAsync(user);
if (string.IsNullOrEmpty(unformattedKey))
{
await _userManager.ResetAuthenticatorKeyAsync(user);
unformattedKey = await _userManager.GetAuthenticatorKeyAsync(user);
}
model.SharedKey = FormatKey(unformattedKey);
model.AuthenticatorUri = GenerateQrCodeUri(unformattedKey, user.NormalizedEmail);
}
public async Task <IActionResult> ConfirmEmail(string userId, string code)
{
if (userId == null || code == null)
{
return(View("Error"));
}
MongoIdentityUser user = await _userManager.FindByIdAsync(userId);
if (user == null)
{
return(View("Error"));
}
IdentityResult result = await _userManager.ConfirmEmailAsync(user, code);
return(View(result.Succeeded ? nameof(ConfirmEmail) : "Error"));
}
public async Task MongoUserStore_ShouldPutThingsIntoUsersCollectionByDefault()
{
var user = new MongoIdentityUser(TestUtils.RandomString(10));
using (var store = new MongoUserStore <MongoIdentityUser>(options))
{
// ACT
var result = await store.CreateAsync(user, CancellationToken.None);
// ASSERT
Assert.True(result.Succeeded);
Assert.Equal(1, await store.GetUserCountAsync());
}
}
public async Task CreateAsync_ShouldCreateUser()
{
// ARRANGE
MongoIdentityUser user;
using (var userStore = new MongoUserStore <MongoIdentityUser>(options) as IUserStore <MongoIdentityUser>)
{
user = new MongoIdentityUser(TestUtils.RandomString(10));
await userStore.CreateAsync(user, CancellationToken.None);
var retrievedUser = await userStore.FindByIdAsync(user.Id, CancellationToken.None);
Assert.NotNull(retrievedUser);
Assert.Equal(user.UserName, retrievedUser.UserName);
Assert.Equal(user.NormalizedUserName, retrievedUser.NormalizedUserName);
}
}
public async Task CanCreateMultipleUsers()
{
var user1 = new MongoIdentityUser("test_account_1", "*****@*****.**");
var createResult1 = await _userStore.CreateAsync(user1, CancellationToken.None);
createResult1.ShouldNotBeNull();
createResult1.Succeeded.ShouldBeTrue();
var user2 = new MongoIdentityUser("test_account_2", "*****@*****.**");
var createResult2 = await _userStore.CreateAsync(user2, CancellationToken.None);
createResult2.ShouldNotBeNull();
createResult2.Succeeded.ShouldBeTrue();
await _userStore.DeleteAsync(user1, CancellationToken.None);
await _userStore.DeleteAsync(user2, CancellationToken.None);
}
public async Task <IActionResult> LoginWith2fa(bool rememberMe, string returnUrl = null)
{
// Ensure the user has gone through the username & password screen first
MongoIdentityUser user = await loginService.GetTwoFactorAuthenticationUserAsync();
if (user == null)
{
throw new Exception($"Unable to load two-factor authentication user.");
}
var model = new LoginWith2faViewModel {
RememberMe = rememberMe
};
ViewData["ReturnUrl"] = returnUrl;
return(View(model));
}
public async Task MongoUserStore_ShouldPutThingsIntoUsersCollectionByDefault()
{
var user = new MongoIdentityUser(TestUtils.RandomString(10));
using (var dbProvider = MongoDbServerTestUtils.CreateDatabase())
{
var store = await MongoUserStore <MongoIdentityUser> .CreateAsync(dbProvider.Database);
// ACT
var result = await store.CreateAsync(user, CancellationToken.None);
// ASSERT
Assert.True(result.Succeeded);
var collections = await(await dbProvider.Database.ListCollectionsAsync()).ToListAsync();
var collectionExists = collections.Any(x => x["name"].ToString().Equals("users", StringComparison.Ordinal));
Assert.True(collectionExists, "Default collection name should not be changed from the initial collection name ('users') since it will cause breaking change to current users");
}
}
public async Task <ActionResult> SendCode(string returnUrl = null, bool rememberMe = false)
{
MongoIdentityUser user = await loginService.GetTwoFactorAuthenticationUserAsync();
if (user == null)
{
return(View("Error"));
}
System.Collections.Generic.IList <string> userFactors = await _userManager.GetValidTwoFactorProvidersAsync(user);
var factorOptions = userFactors.Select(purpose => new SelectListItem {
Text = purpose, Value = purpose
}).ToList();
return(View(new SendCodeViewModel {
Providers = factorOptions, ReturnUrl = returnUrl, RememberMe = rememberMe
}));
}
public async Task CanCreateUsingUserStore()
{
var serviceProvider = BuildServiceProvider();
var userStore = serviceProvider.GetService <IUserStore <MongoIdentityUser> >();
var user = new MongoIdentityUser
{
Email = "*****@*****.**",
UserName = "******",
PasswordHash = "randomepassword",
Name = "name",
NormalizedName = "USER",
EmailConfirmed = true,
NormalizedEmail = "*****@*****.**"
};
var cancelToken = new CancellationTokenSource();
AssertSucceeded(await userStore.CreateAsync(user, cancelToken.Token));
var found = await userStore.FindByIdAsync(user.Id, cancelToken.Token);
Assert.NotNull(found);
Assert.Equal(user.Email, found.Email);
Assert.Equal(user.UserName, found.UserName);
Assert.Equal(user.PasswordHash, found.PasswordHash);
Assert.Equal(user.Name, found.Name);
Assert.Equal(user.NormalizedName, found.NormalizedName);
Assert.Equal(user.EmailConfirmed, found.EmailConfirmed);
Assert.Equal(user.NormalizedEmail, found.NormalizedEmail);
Assert.Equal("*****@*****.**", found.Email);
Assert.Equal("someone.email", found.UserName);
Assert.Equal("randomepassword", found.PasswordHash);
Assert.Equal("name", found.Name);
Assert.Equal("USER", found.NormalizedName);
Assert.True(found.EmailConfirmed);
Assert.Equal("*****@*****.**", found.NormalizedEmail);
AssertSucceeded(await userStore.DeleteAsync(found, cancelToken.Token));
}
public async Task CreateAsync_ShouldCreateUser()
{
// ARRANGE
using (var dbProvider = MongoDbServerTestUtils.CreateDatabase())
{
var userStore = new MongoUserStore <MongoIdentityUser>(dbProvider.Database) as IUserStore <MongoIdentityUser>;
var user = new MongoIdentityUser(TestUtils.RandomString(10));
// ACT
await userStore.CreateAsync(user, CancellationToken.None);
// ASSERT
var collection = dbProvider.Database.GetDefaultCollection();
var retrievedUser = await collection.FindByIdAsync(user.Id);
Assert.NotNull(retrievedUser);
Assert.Equal(user.UserName, retrievedUser.UserName);
Assert.Equal(user.NormalizedUserName, retrievedUser.NormalizedUserName);
}
}
public async Task <IActionResult> ExternalLoginConfirmation(ExternalLoginConfirmationViewModel model, string returnUrl = null)
{
if (ModelState.IsValid)
{
// Get the information about the user from the external login provider
ExternalLoginInfo info = await loginService.GetExternalLoginInfoAsync();
if (info == null)
{
return(View("ExternalLoginFailure"));
}
var user = new MongoIdentityUser(model.Email, model.Email);
IdentityResult result = await _userManager.CreateAsync(user);
if (result.Succeeded)
{
var addToRoleResult = await _userManager.AddToRoleAsync(user, "user");
await _userManager.ConfirmEmailAsync(user, await _userManager.GenerateEmailConfirmationTokenAsync(user));
//await loginService.SetEmailAsConfirmed(user);
result = await _userManager.AddLoginAsync(user, info);
if (result.Succeeded && addToRoleResult.Succeeded)
{
await loginService.SignInAsync(user, isPersistent : false);
_logger.LogInformation(6, "User created an account using {Name} provider.", info.LoginProvider);
// Update any authentication tokens as well
await loginService.UpdateExternalAuthenticationTokensAsync(info);
return(RedirectToLocal(returnUrl));
}
}
AddErrors(result);
}
ViewData["ReturnUrl"] = returnUrl;
return(View(model));
}
public async Task <IActionResult> SendCode(SendCodeViewModel model)
{
if (!ModelState.IsValid)
{
return(View());
}
MongoIdentityUser user = await loginService.GetTwoFactorAuthenticationUserAsync();
if (user == null)
{
return(View("Error"));
}
if (model.SelectedProvider == "Authenticator")
{
return(RedirectToAction(nameof(VerifyAuthenticatorCode), new { model.ReturnUrl, model.RememberMe }));
}
// Generate the token and send it
var code = await _userManager.GenerateTwoFactorTokenAsync(user, model.SelectedProvider);
if (string.IsNullOrWhiteSpace(code))
{
return(View("Error"));
}
var message = "Your security code is: " + code;
if (model.SelectedProvider == "Email")
{
await _emailSender.SendEmailAsync(await _userManager.GetEmailAsync(user), "Security Code", message);
}
else if (model.SelectedProvider == "Phone")
{
await _smsSender.SendSmsAsync(await _userManager.GetPhoneNumberAsync(user), message);
}
return(RedirectToAction(nameof(VerifyCode), new { Provider = model.SelectedProvider, ReturnUrl = model.ReturnUrl, RememberMe = model.RememberMe }));
}
public async Task <IActionResult> ResetPassword(ResetPasswordViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
MongoIdentityUser user = await _userManager.FindByEmailAsync(model.Email);
if (user == null)
{
// Don't reveal that the user does not exist
return(RedirectToAction(nameof(AccountController.ResetPasswordConfirmation), "Account"));
}
IdentityResult result = await _userManager.ResetPasswordAsync(user, model.Code, model.Password);
if (result.Succeeded)
{
return(RedirectToAction(nameof(AccountController.ResetPasswordConfirmation), "Account"));
}
AddErrors(result);
return(View());
}
public async Task MongoIdentityUser_ShouldSaveAndRetrieveTheFutureOccuranceCorrectly()
{
var lockoutEndDate = new DateTime(2017, 2, 1, 0, 0, 0, DateTimeKind.Utc).AddTicks(8996910);
var user = new MongoIdentityUser(TestUtils.RandomString(10));
user.LockUntil(lockoutEndDate);
using (var dbProvider = MongoDbServerTestUtils.CreateDatabase())
{
var store = await MongoUserStore <MongoIdentityUser> .CreateAsync(dbProvider.Database);
// ACT
var result = await store.CreateAsync(user, CancellationToken.None);
// ASSERT
Assert.True(result.Succeeded);
var collection = dbProvider.Database.GetCollection <MongoIdentityUser>(Constants.DefaultCollectionName);
var retrievedUser = await collection.FindByIdAsync(user.Id);
Assert.Equal(user.LockoutEndDate, retrievedUser.LockoutEndDate);
}
}
public static string GenerateJwtToken(string email, MongoIdentityUser user, IConfiguration configuration)
{
var claims = new List <Claim>
{
new Claim(JwtRegisteredClaimNames.Sub, email),
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
new Claim(ClaimTypes.NameIdentifier, user.Id.ToString())
};
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(configuration["JwtKey"]));
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
var expires = DateTime.Now.AddDays(Convert.ToDouble(configuration["JwtExpireDays"]));
var token = new JwtSecurityToken(
configuration["JwtIssuer"],
configuration["JwtIssuer"],
claims,
expires: expires,
signingCredentials: creds
);
return(new JwtSecurityTokenHandler().WriteToken(token));
}
public async Task <IActionResult> ForgotPassword(ForgotPasswordViewModel model)
{
if (ModelState.IsValid)
{
MongoIdentityUser user = await _userManager.FindByEmailAsync(model.Email);
if (user == null || !(await _userManager.IsEmailConfirmedAsync(user)))
{
// Don't reveal that the user does not exist or is not confirmed
return(View(nameof(ForgotPasswordConfirmation)));
}
// For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=532713
// Send an email with this link
//var code = await _userManager.GeneratePasswordResetTokenAsync(user);
//var callbackUrl = Url.Action("ResetPassword", "Account", new { userId = user.Id, code = code }, protocol: HttpContext.Request.Scheme);
//await _emailSender.SendEmailAsync(model.Email, "Reset Password",
// "Please reset your password by clicking here: <a href=\"" + callbackUrl + "\">link</a>");
//return View("ForgotPasswordConfirmation");
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <bool> Handle(ImportArticlesEvaluatorsCommand request, CancellationToken cancellationToken)
{
var evaluators = new List <EvaluatorsImportAux>();
List <dynamic> evaluatorsDistinct = request.Articles.SelectMany(x =>
{
var ls = new List <object>
{
new
{
Email = x.Email1.Trim(),
Nome = x.Avaliador1.Trim()
}
};
if (!string.IsNullOrEmpty(x.Email2))
{
ls.Add(new
{
Email = x.Email2.Trim(),
Nome = x.Avaliador2.Trim()
});
}
return(ls);
}).Distinct().ToList();
var gen = new PassowordGenerator();
foreach (var avaliador in evaluatorsDistinct)
{
MongoIdentityUser avaliadorSalvo = await _userManager.FindByEmailAsync(avaliador.Email);
if (avaliadorSalvo == null)
{
var identityUser = new MongoIdentityUser(avaliador.Email, avaliador.Email);
identityUser.AddClaim(new MongoUserClaim("Email", avaliador.Email));
identityUser.AddClaim(new MongoUserClaim("Type", EUserType.Evaluator.ToString()));
var senha = gen.Generate();
var result = await _userManager.CreateAsync(identityUser, senha);
if (!result.Succeeded)
{
continue;
}
var person = new Person()
{
IdentityUserId = identityUser.Id,
Name = avaliador.Nome,
IsSei = true,
Email = avaliador.Email,
IsSicite = true,
AttendedModalities = new List <string>(),
Institution = "UTFPR",
Type = EUserType.Evaluator,
Approved = true,
ArticlesCount = 0
};
await _repository.AddAsync(person);
evaluators.Add(new EvaluatorsImportAux()
{
Email = person.Email,
Id = person.Id,
Modalidades = new HashSet <string>(),
Nome = person.Name
});
Debug.WriteLine($"User: {person.Id} - {senha}");
await Task.Delay(100);
}
else
{
var person = (await _repository.GetByFilter(Builders <Person> .Filter.Eq(x => x.IdentityUserId, avaliadorSalvo.Id))).SingleOrDefault();
evaluators.Add(new EvaluatorsImportAux()
{
Email = person.Email,
Id = person.Id,
Modalidades = new HashSet <string>(),
Nome = person.Name
});
}
}
foreach (var artImport in request.Articles.Distinct())
{
var article = await _repository.GetFirstOrDefaultByFilter(
Builders <Article> .Filter.And(
Builders <Article> .Filter.Eq(x => x.SubmissionId, artImport.SubmissionId.ToString()),
Builders <Article> .Filter.Eq(x => x.Event, request.Event)
)
);
if (article == null)
{
Debug.WriteLine($"Artigo: {artImport.SubmissionId} - Não Encontrado no Evento {request.Event.ToString()} - Possível divergência nos arquivos");
continue;
}
article.LocalDetails = artImport.Local;
article.Room = artImport.Sala;
var dataDecomposed = artImport.Data.Trim().Split("/").Select(x => Convert.ToInt32(x)).ToArray();
var horaDecomposed = artImport.Hora.Trim().Split(":").Select(x => Convert.ToInt32(x)).ToArray();
article.StartDate = new DateTime(dataDecomposed[2], dataDecomposed[0], dataDecomposed[1], horaDecomposed[0], horaDecomposed[1], 0);
var evaluator1 = evaluators.FirstOrDefault(x => x.Email == artImport.Email1.Trim());
if (evaluator1 != null)
{
article.EvaluatorId = evaluator1.Id;
evaluator1.Modalidades.Add(article.Modality);
}
if (!string.IsNullOrEmpty(artImport.Email2))
{
var evaluator2 = evaluators.FirstOrDefault(x => x.Email == artImport.Email2.Trim());
if (evaluator2 != null)
{
article.Evaluator2Id = evaluator2.Id;
evaluator2.Modalidades.Add(article.Modality);
}
}
await _repository.SaveOrUpdateAsync(article, article.Id);
await Task.Delay(100);
}
foreach (var evaluat in evaluators)
{
var eval = await _repository.GetByIdAsync <Person>(evaluat.Id);
var modalities = new List <string>(eval.AttendedModalities);
modalities.AddRange(evaluat.Modalidades);
eval.AttendedModalities = modalities.Distinct().ToList();
await _repository.SaveOrUpdateAsync(eval, eval.Id);
await Task.Delay(100);
}
return(true);
}
private IEnumerable <Claim> GetClaimsFromUser(MongoIdentityUser user)
{
var claims = new List <Claim>
{
new Claim(JwtClaimTypes.Subject, user.Id),
new Claim(JwtClaimTypes.PreferredUserName, user.UserName),
new Claim(JwtRegisteredClaimNames.UniqueName, user.UserName)
};
//if (!string.IsNullOrWhiteSpace(user.Name))
// claims.Add(new Claim("name", user.Name));
//if (!string.IsNullOrWhiteSpace(user.LastName))
// claims.Add(new Claim("last_name", user.LastName));
//if (!string.IsNullOrWhiteSpace(user.CardNumber))
// claims.Add(new Claim("card_number", user.CardNumber));
//if (!string.IsNullOrWhiteSpace(user.CardHolderName))
// claims.Add(new Claim("card_holder", user.CardHolderName));
//if (!string.IsNullOrWhiteSpace(user.SecurityNumber))
// claims.Add(new Claim("card_security_number", user.SecurityNumber));
//if (!string.IsNullOrWhiteSpace(user.Expiration))
// claims.Add(new Claim("card_expiration", user.Expiration));
//if (!string.IsNullOrWhiteSpace(user.City))
// claims.Add(new Claim("address_city", user.City));
//if (!string.IsNullOrWhiteSpace(user.Country))
// claims.Add(new Claim("address_country", user.Country));
//if (!string.IsNullOrWhiteSpace(user.State))
// claims.Add(new Claim("address_state", user.State));
//if (!string.IsNullOrWhiteSpace(user.Street))
// claims.Add(new Claim("address_street", user.Street));
//if (!string.IsNullOrWhiteSpace(user.ZipCode))
// claims.Add(new Claim("address_zip_code", user.ZipCode));
if (userManager.SupportsUserEmail)
{
claims.AddRange(new[]
{
new Claim(JwtClaimTypes.Email, user.NormalizedEmail),
new Claim(JwtClaimTypes.EmailVerified, user.EmailConfirmed ? "true" : "false", ClaimValueTypes.Boolean)
});
}
if (userManager.SupportsUserPhoneNumber && !string.IsNullOrWhiteSpace(user.PhoneNumber))
{
claims.AddRange(new[]
{
new Claim(JwtClaimTypes.PhoneNumber, user.PhoneNumber),
new Claim(JwtClaimTypes.PhoneNumberVerified, user.PhoneNumberConfirmed ? "true" : "false", ClaimValueTypes.Boolean)
});
}
return(claims);
}
private async Task <MongoIdentityUser> AutoProvisionUser(string provider, string providerUserId, IEnumerable <Claim> claims)
{
// create a list of claims that we want to transfer into our store
var filtered = new List <Claim>();
// user's display name
var name = claims.FirstOrDefault(x => x.Type == JwtClaimTypes.Name)?.Value ??
claims.FirstOrDefault(x => x.Type == ClaimTypes.Name)?.Value;
if (name != null)
{
filtered.Add(new Claim(JwtClaimTypes.Name, name));
}
else
{
var first = claims.FirstOrDefault(x => x.Type == JwtClaimTypes.GivenName)?.Value ??
claims.FirstOrDefault(x => x.Type == ClaimTypes.GivenName)?.Value;
var last = claims.FirstOrDefault(x => x.Type == JwtClaimTypes.FamilyName)?.Value ??
claims.FirstOrDefault(x => x.Type == ClaimTypes.Surname)?.Value;
if (first != null && last != null)
{
filtered.Add(new Claim(JwtClaimTypes.Name, first + " " + last));
}
else if (first != null)
{
filtered.Add(new Claim(JwtClaimTypes.Name, first));
}
else if (last != null)
{
filtered.Add(new Claim(JwtClaimTypes.Name, last));
}
}
// email
var email = claims.FirstOrDefault(x => x.Type == JwtClaimTypes.Email)?.Value ??
claims.FirstOrDefault(x => x.Type == ClaimTypes.Email)?.Value;
if (email != null)
{
filtered.Add(new Claim(JwtClaimTypes.Email, email));
}
var user = new MongoIdentityUser(Guid.NewGuid().ToString(), email);
var identityResult = await _userManager.CreateAsync(user);
if (!identityResult.Succeeded)
{
throw new Exception(identityResult.Errors.First().Description);
}
if (filtered.Any())
{
identityResult = await _userManager.AddClaimsAsync(user, filtered);
if (!identityResult.Succeeded)
{
throw new Exception(identityResult.Errors.First().Description);
}
}
identityResult = await _userManager.AddLoginAsync(user, new UserLoginInfo(provider, providerUserId, provider));
if (!identityResult.Succeeded)
{
throw new Exception(identityResult.Errors.First().Description);
}
return(user);
}
