public async Task <IActionResult> SetPassword(SetPasswordViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'.");
}
var addPasswordResult = await _userManager.AddPasswordAsync(user, model.NewPassword);
var addPasswordReturnResult = new Microsoft.AspNetCore.Identity.IdentityResult
{
};
if (!addPasswordResult.Succeeded)
{
IdentityResultWeb addPasswordRes = new IdentityResultWeb(addPasswordReturnResult);
AddErrors(addPasswordRes);
return(View(model));
}
await _signInManager.SignInAsync(user, isPersistent : false);
StatusMessage = "Your password has been set.";
return(RedirectToAction(nameof(SetPassword)));
}
private async Task <User> createUserAsync(AddUserViewModel model)//Debe retornar el usuario
{
//2. Creamos el objeto user con los atributos capturados del modelo
User user = new User
{
Address = model.Address,
Document = model.Document,
Email = model.Username,
FirstName = model.FirstName,
LastName = model.LastName,
PhoneNumber = model.PhoneNumber,
UserName = model.Username
};
//3. Creamos el usuario usando el userHelper y el user que acabamos de crear
Microsoft.AspNetCore.Identity.IdentityResult result = await _userHelper.AddUserAsync(user, model.Password);
if (result.Succeeded)//4. Si lo pudo crear lo traemos de nuevo en nuestra variable user
{
user = await _userHelper.GetUserByEmailAsync(model.Username);
//5. Ahora le agregamos el rol a este usuario
await _userHelper.AddUserToRoleAsync(user, "Owner");
//6. retornamos el usuario
return(user);
}
//7. si falla retornamos null
return(null);
}
/// <summary>
/// Adds some default values to the Database
/// </summary>
public void SeedData()
{
using var scope = _scopeFactory.CreateScope();
var dbInitializer = scope.ServiceProvider.GetRequiredService <DbInitializerService>();
var createAdminResult = dbInitializer.CreateAdminUserAsync().Result;
if (createAdminResult == (null, IdentityResult.Failed()))
{
throw new InvalidOperationException(createAdminResult.Item2.DumpErrors());
}
using var db = scope.ServiceProvider.GetRequiredService <BehlogContext>();
if (!db.Roles.Any())
{
db.Add(new Role(Consts.Role_Admin));
db.SaveChanges();
}
var adminUser = createAdminResult.Item1;
var defaultLanguage = _languageSvc
.CreateDefaultLanguagesAndReturnDefaultLanguageAsync()
.Result;
dbInitializer.CreateDefaultWebsite(
db,
adminUser,
defaultLanguage.Adapt <Language>()
);
}
private async Task <User> CreateUserAsync(AddUserViewModel model)
{
User user = new User
{
Address = model.Address,
Document = model.Document,
Email = model.Username,
FirstName = model.FirstName,
LastName = model.LastName,
PhoneNumber = model.PhoneNumber,
UserName = model.Username
};
Microsoft.AspNetCore.Identity.IdentityResult result = await _userHelper.AddUserAsync(user, model.Password);
if (result.Succeeded)
{
user = await _userHelper.GetUserByEmailAsync(model.Username);
await _userHelper.AddUserToRoleAsync(user, "Owner");
return(user);
}
return(null);
}
public async Task <IActionResult> ResetPassword(ResetPasswordViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var user = await _userManager.FindByEmailAsync(model.Email);
if (user == null)
{
// Don't reveal that the user does not exist
return(RedirectToAction(nameof(ResetPasswordConfirmation)));
}
var result = await _userManager.ResetPasswordAsync(user, model.Code, model.Password);
var returnResult = new Microsoft.AspNetCore.Identity.IdentityResult
{
};
if (result.Succeeded)
{
return(RedirectToAction(nameof(ResetPasswordConfirmation)));
}
IdentityResultWeb res = new IdentityResultWeb(returnResult);
AddErrors(res);
return(View());
}
public async Task <IActionResult> ChangePasswordMVC(ChangePasswordViewModel model)
{
if (ModelState.IsValid)
{
UserEntity user = await _userHelper.GetUserAsync(User.Identity.Name);
if (user != null)
{
Microsoft.AspNetCore.Identity.IdentityResult result = await _userHelper.ChangePasswordAsync(user, model.OldPassword, model.NewPassword);
if (result.Succeeded)
{
return(RedirectToAction("ChangeUser"));
}
else
{
ModelState.AddModelError(string.Empty, result.Errors.FirstOrDefault().Description);
}
}
else
{
ModelState.AddModelError(string.Empty, "User no found.");
}
}
return(View(model));
}
public async Task <IActionResult> ChangePassword(ChangePasswordViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'.");
}
var changePasswordResult = await _userManager.ChangePasswordAsync(user, model.OldPassword, model.NewPassword);
var changePasswordReturnResult = new Microsoft.AspNetCore.Identity.IdentityResult
{
};
if (!changePasswordResult.Succeeded)
{
IdentityResultWeb changePasswordRes = new IdentityResultWeb(changePasswordReturnResult);
AddErrors(changePasswordRes);
return(View(model));
}
await _signInManager.SignInAsync(user, isPersistent : false);
_logger.LogInformation("User changed their password successfully.");
StatusMessage = "Your password has been changed.";
return(RedirectToAction(nameof(ChangePassword)));
}
public async Task <IActionResult> Create(AddUserViewModel model)
{
if (ModelState.IsValid)
{
Userstbl user = new Userstbl
{
Pro_Lote = model.PRO_LOTE,
Pro_Nombres = model.PRO_NOMBRES,
Pro_Apellidos = model.PRO_APELLIDOS,
TipViv = await _context.TiposViviendatbls.FindAsync(model.TVId),
TipPer = await _context.TipoPersonastbls.FindAsync(model.TPId),
Pro_Observaciones = model.PRO_OBSERVACIONES,
Pro_Telefono = model.PRO_TELEFONO,
TipIde = await _context.TipoIdentificaciontbls.FindAsync(model.TIId),
Pro_Identificacion = model.PRO_IDENTIFICACION,
Email = model.Username,
UserName = model.Username
};
Microsoft.AspNetCore.Identity.IdentityResult response = await _userHelper.AddUserAsync(user, model.Password);
if (response.Succeeded)
{
Userstbl userInDB = await _userHelper.GetUserByEmailAsync(model.Username);
await _userHelper.AddUserToRoleAsync(userInDB, "Customer");
var propietario = new Propietariostbl
{
Vehiculos = new List <Vehiculostbl>(),
Negocio = new List <Negociostbl>(),
Pagos = new List <Pagostbl>(),
User = userInDB,
};
_context.Propietariostbls.Add(propietario);
try
{
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
catch (Exception ex)
{
ModelState.AddModelError(string.Empty, ex.ToString());
return(View(model));
}
}
ModelState.AddModelError(string.Empty, response.Errors.FirstOrDefault().Description);
}
model.TipoViviendaVM = _combosHelper.GetComboTipoVivienda();
model.TipoIdentificacionVM = _combosHelper.GetComboTipoIdentificacion();
model.TipoPersonaVM = _combosHelper.GetComboTipoPersona();
return(View(model));
}
public async Task Update_User_Mongo_Test()
{
// Arrange
LetPortal.Identity.Stores.UserStore userStore = _context.GetUserStore();
// Act
Microsoft.AspNetCore.Identity.IdentityResult result = await userStore.UpdateAsync(_context.GenerateUser(), new System.Threading.CancellationToken());
userStore.Dispose();
// Assert
Assert.True(result.Succeeded);
}
public async Task <IActionResult> Register(RegisterViewModel model, string returnUrl = null)
{
ViewData["ReturnUrl"] = returnUrl;
if (ModelState.IsValid)
{
var user = new User
{
UserName = model.Username,
Email = model.Email,
Name = model.Name
};
var result = await _userManager.CreateAsync(user, model.Password);
var returnResult = new Microsoft.AspNetCore.Identity.IdentityResult
{
};
if (result.Succeeded && user.IsApproved)
{
_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);
var signInUser = new User
{
UserName = model.Username,
Email = model.Email,
Name = model.Name
};
await _signInManager.SignInAsync(signInUser, isPersistent : false);
_logger.LogInformation("User created a new account with password.");
return(RedirectToLocal(returnUrl));
}
else
{
IdentityResultWeb res = new IdentityResultWeb(returnResult);
AddErrors(res);
return(RedirectToAction(nameof(AccountController.Login), "Account"));
}
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <IActionResult> Register([FromBody] RegisterModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.ToBadRequestErrorModel()));
}
var user = new User
{
UserName = model.Username,
Email = model.Email,
Name = model.Name
};
var result = await _userManager.CreateAsync(user, model.Password);
var returnResult = new Microsoft.AspNetCore.Identity.IdentityResult {
};
if (result.Succeeded && user.IsApproved)
{
_logger.LogInformation("User created a new account with password.");
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var signInUser = new User
{
UserName = model.Username,
Email = model.Email,
Name = model.Name
};
await _signInManager.SignInAsync(signInUser, isPersistent : false);
_logger.LogInformation("User created a new account with password.");
return(Ok());
}
else
{
IdentityResultWeb res = new IdentityResultWeb(returnResult);
return(Ok());
}
}
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 User {
UserName = model.Email, Email = model.Email
};
var result = await _userManager.CreateAsync(user);
var returnResult = new Microsoft.AspNetCore.Identity.IdentityResult
{
};
if (result.Succeeded)
{
result = await _userManager.AddLoginAsync(user, info);
if (result.Succeeded)
{
var signInUser = new User {
UserName = model.Email, Email = model.Email
};
await _signInManager.SignInAsync(signInUser, isPersistent : false);
_logger.LogInformation("User created an account using {Name} provider.", info.LoginProvider);
return(RedirectToLocal(returnUrl));
}
}
IdentityResultWeb res = new IdentityResultWeb(returnResult);
AddErrors(res);
}
ViewData["ReturnUrl"] = returnUrl;
return(View(nameof(ExternalLogin), model));
}
public async Task <IActionResult> ResetPassword(ResetPasswordViewModel model)
{
UserEntity user = await _userHelper.GetUserAsync(model.UserName);
if (user != null)
{
Microsoft.AspNetCore.Identity.IdentityResult result = await _userHelper.ResetPasswordAsync(user, model.Token, model.Password);
if (result.Succeeded)
{
ViewBag.Message = "Password reseteado correctamente.";
return(View());
}
ViewBag.Message = "Error mientras se reseteaba el password.";
return(View(model));
}
ViewBag.Message = "Usuario no encontrado.";
return(View(model));
}
public async Task <IActionResult> ResetPassword(ResetPasswordViewModel model)
{
UserEntity user = await _userHelper.GetUserAsync(model.UserName);
if (user != null)
{
Microsoft.AspNetCore.Identity.IdentityResult result = await _userHelper.ResetPasswordAsync(user, model.Token, model.Password);
if (result.Succeeded)
{
ViewBag.Message = "Password reset successful.";
return(View());
}
ViewBag.Message = "Error while resetting the password.";
return(View(model));
}
ViewBag.Message = "User not found.";
return(View(model));
}
public async Task <IActionResult> ResetPassword(ResetPasswordViewModel model)
{
UserEntity user = await _userHelper.GetUserAsync(model.UserName);
if (user != null)
{
Microsoft.AspNetCore.Identity.IdentityResult result = await _userHelper.ResetPasswordAsync(user, model.Token, model.Password);
if (result.Succeeded)
{
ViewBag.Message = "La contraseña se reestableció satisfactoriamente.";
return(View());
}
ViewBag.Message = "Error al reestablecer la contraseña.";
return(View(model));
}
ViewBag.Message = "Usuario no encontrado.";
return(View(model));
}
public async Task <IActionResult> ConfirmEmail(string userId, string token)
{
if (string.IsNullOrEmpty(userId) || string.IsNullOrEmpty(token))
{
return(NotFound());
}
UserEntity user = await _userHelper.GetUserAsync(new Guid(userId));
if (user == null)
{
return(NotFound());
}
Microsoft.AspNetCore.Identity.IdentityResult result = await _userHelper.ConfirmEmailAsync(user, token);
if (!result.Succeeded)
{
return(NotFound());
}
return(View());
}
public static IdentityResult ToApplicationResult(this Microsoft.AspNetCore.Identity.IdentityResult result)
{
return(result.Succeeded
? IdentityResult.Success()
: IdentityResult.Failure(result.Errors.Select(e => e.Description)));
}
public async Task <IActionResult> UpdateUser([FromBody] Common.DataSvc.Models.UserDo entity)
{
return(await this.ControllerResult(async (Web.Models.ResultData result) =>
{
bool currentUser = this.User.Identity.Name == entity.UserName;
bool changePassword = (entity.Password != FAKE_PASSWORD);
entity.UpdateDate = Utils.IOUtil.GetCurrentDateTimeTH;
entity.UpdateUser = this.User.Identity.Name;
Web.Models.User.ApplicationUser user = await this._userManager.FindByNameAsync(entity.UserName);
if (user != null)
{
user.GroupID = entity.GroupID;
user.FlagActive = entity.FlagActive;
user.FlagSystemAdmin = entity.FlagSystemAdmin;
user.PasswordAge = entity.PasswordAge;
user.Remark = entity.Remark;
if (changePassword && entity.Password != null)
{
user.LastUpdatePasswordDate = entity.UpdateDate;
Web.Validator.UserPasswordValidator <Web.Models.User.ApplicationUser> validator
= new Web.Validator.UserPasswordValidator <Web.Models.User.ApplicationUser>();
Microsoft.AspNetCore.Identity.IdentityResult pres = await validator.ValidateAsync(_userManager, user, entity.Password);
if (!pres.Succeeded)
{
foreach (var error in pres.Errors)
{
result.AddError(error.Code, error.Description);
}
}
else
{
await this._userManager.RemovePasswordAsync(user);
pres = await this._userManager.AddPasswordAsync(user, entity.Password);
if (!pres.Succeeded)
{
foreach (var error in pres.Errors)
{
result.AddError(error.Code, error.Description);
}
}
}
}
if (result.Errors.Count == 0)
{
var res = await this._userManager.UpdateAsync(user);
if (!res.Succeeded)
{
foreach (var error in res.Errors)
{
result.AddError(error.Code, error.Description);
}
}
else
{
entity.UserID = user.Id;
Common.DataSvc.Models.UserCriteriaDo criteria = new DataSvc.Models.UserCriteriaDo();
criteria.UserName = entity.UserName;
result.Data = await Task.Run(() =>
{
this._commonSvcDbContext.UpdateUserInfo(entity);
DataSvc.Models.UserDo nuser = this._commonSvcDbContext.GetUser(criteria);
nuser.Password = FAKE_PASSWORD;
return new
{
IsCurrentUser = currentUser,
User = nuser,
Permissions = this._commonSvcDbContext.GetUserPermission(criteria)
};
});
}
}
}
}));
}
public async Task <(User, IdentityResult)> CreateAdminUserAsync()
{
var adminUser = await _userManager.FindByNameAsync(AdminUserSeedInfo.Username);
if (adminUser != null)
{
_logger.LogInformation($"{AdminUserSeedInfo.Username} already existed.");
return(adminUser,
IdentityResult.Success
);
}
var adminRole = await _roleManager.FindByNameAsync(AdminUserSeedInfo.RoleName);
if (adminRole != null)
{
_logger.LogInformation($"{AdminUserSeedInfo.RoleName} role already existed.");
}
else
{
adminRole = new Role(AdminUserSeedInfo.RoleName);
var roleResult = await _roleManager.CreateAsync(adminRole);
if (roleResult == IdentityResult.Failed())
{
_logger.LogError($"'{adminRole.Name}' role creating has failed. {roleResult.DumpErrors()}");
return(null,
IdentityResult.Failed()
);
}
}
adminUser = new User {
UserName = AdminUserSeedInfo.Username,
Email = AdminUserSeedInfo.Email,
EmailConfirmed = true,
RegisterDate = _dateSvc.UtcNow(),
Title = AdminUserSeedInfo.Title,
LockoutEnabled = true,
Status = UserStatus.Enabled
};
var result = await _userManager.CreateAsync(adminUser, AdminUserSeedInfo.Password);
if (result == IdentityResult.Failed())
{
_logger.LogError($"'{AdminUserSeedInfo.Username}; user creation has failed. {result.DumpErrors()}");
return(null,
IdentityResult.Failed()
);
}
var setLockoutResult = await _userManager.SetLockoutEnabledAsync(adminUser, enabled : false);
if (setLockoutResult == IdentityResult.Failed())
{
_logger.LogError($"'{AdminUserSeedInfo.Username}' setLockout on user has failed. {setLockoutResult.DumpErrors()}");
return(null,
IdentityResult.Failed()
);
}
var addRoleResult = await _userManager.AddToRoleAsync(adminUser, AdminUserSeedInfo.RoleName);
if (addRoleResult == IdentityResult.Failed())
{
_logger.LogError($"Adding user:'******' to role:'{AdminUserSeedInfo.RoleName}' has failed. {addRoleResult.DumpErrors()}");
return(null,
IdentityResult.Failed()
);
}
return(
adminUser,
IdentityResult.Success
);
}