public async Task <ActionResult> SetPassword(SetPasswordViewModel model)
{
if (ModelState.IsValid)
{
var result = await UserManager.AddPasswordAsync(User.Identity.GetUserId(), model.NewPassword);
if (result.Succeeded)
{
var user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
if (user != null)
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
}
return(RedirectToAction("Index", new { Message = ManageMessageId.SetPasswordSuccess }));
}
AddErrors(result);
}
// Se chegamos até aqui, algo falhou, mostrar formulário novamente
return(View(model));
}
public async Task <ActionResult> SetPassword(SetPasswordViewModel model)
{
if (ModelState.IsValid)
{
var result = await UserManager.AddPasswordAsync(User.Identity.GetUserId(), model.NewPassword);
if (result.Succeeded)
{
var user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
if (user != null)
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
}
return(RedirectToAction("Index", new { Message = ManageMessageId.SetPasswordSuccess }));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <ActionResult> SetPassword(SetPasswordViewModel model)
{
if (ModelState.IsValid)
{
var result = await UserManager.AddPasswordAsync(User.Identity.GetUserId(), model.NewPassword);
if (result.Succeeded)
{
var user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
if (user != null)
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
}
return(RedirectToAction("Index", new { Message = ManageMessageId.SetPasswordSuccess }));
}
AddErrors(result);
}
// Это сообщение означает наличие ошибки; повторное отображение формы
return(View(model));
}
public async Task <ActionResult> SetPassword(SetPasswordViewModel model)
{
if (ModelState.IsValid)
{
var result = await UserManager.AddPasswordAsync(User.Identity.GetUserId(), model.NewPassword);
if (result.Succeeded)
{
var user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
if (user != null)
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
}
return(RedirectToAction("Index", new { Message = ManageMessageId.SetPasswordSuccess }));
}
AddErrors(result);
}
//Si nous sommes arrivés là, quelque chose a échoué, réafficher le formulaire
return(View(model));
}
public async Task <ActionResult> SetPassword(SetPasswordViewModel model)
{
if (ModelState.IsValid)
{
var result = await UserManager.AddPasswordAsync(User.Identity.GetUserId(), model.NewPassword);
if (result.Succeeded)
{
var user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
if (user != null)
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
}
return(RedirectToAction("Index", new { Message = ManageMessageId.SetPasswordSuccess }));
}
AddErrors(result);
}
// Si llegamos a este punto, es que se ha producido un error, volvemos a mostrar el formulario
return(View(model));
}
public async Task <ActionResult> SetPassword(SetPasswordViewModel model)
{
if (ModelState.IsValid)
{
var result = await UserManager.AddPasswordAsync(User.Identity.GetUserId(), model.NewPassword);
if (result.Succeeded)
{
var user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
if (user != null)
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
}
return(RedirectToAction("Index", new { Message = ManageMessageId.SetPasswordSuccess }));
}
AddErrors(result);
}
// Jeśli dotarliśmy tak daleko, oznacza to, że wystąpił błąd. Wyświetl ponownie formularz
return(View(model));
}
public async Task <ActionResult> SetPassword(SetPasswordViewModel model)
{
if (ModelState.IsValid)
{
var result = await UserManager.AddPasswordAsync(User.Identity.GetUserId(), model.NewPassword);
if (result.Succeeded)
{
var user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
if (user != null)
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
}
return(RedirectToAction("ShopManage", new { Message = ManageMessageId.SetPasswordSuccess }));
}
AddErrors(result);
}
// 如果我们进行到这一步时某个地方出错，则重新显示表单
return(View(model));
}
public async Task <ActionResult> SetPassword(SetPasswordViewModel model)
{
if (ModelState.IsValid)
{
var result = await UserManager.AddPasswordAsync(User.Identity.GetUserId(), model.NewPassword);
if (result.Succeeded)
{
var user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
if (user != null)
{
await SignInAsync(user, isPersistent : false);
}
return(RedirectToAction("Index", new { Message = ManageMessageId.SetPasswordSuccess }));
}
AddErrors(result);
}
// No caso de falha, reexibir a view.
return(View(model));
}
public async Task <ActionResult> SetPassword(SetPasswordViewModel model)
{
var correo = User.Identity.Name;
var idPersona = DbModel.Personas.FirstOrDefault(x => x.Correo == correo);
var cantidadCarrito = DbModel.CarritoCompras.Where(X => X.idPersona == idPersona.idPersona).ToList();
ViewBag.cantidadCarrito = cantidadCarrito.Count;
if (ModelState.IsValid)
{
var result = await UserManager.AddPasswordAsync(User.Identity.GetUserId(), model.NewPassword);
var gmail = User.Identity.GetUserName();
using (this.DbModel = new ApplicationDbContext())
{
Usuario usuario = new Usuario();
usuario = DbModel.Usuarios.FirstOrDefault(x => x.User == gmail);
usuario.Password = model.NewPassword;
DbModel.Usuarios.AddOrUpdate(usuario);
DbModel.SaveChanges();
}
if (result.Succeeded)
{
var user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
if (user != null)
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
}
return(RedirectToAction("Index", new { Message = ManageMessageId.SetPasswordSuccess }));
}
AddErrors(result);
}
// Si llegamos a este punto, es que se ha producido un error, volvemos a mostrar el formulario
return(View(model));
}
public async Task <ActionResult> SetPassword(SetPasswordViewModel model)
{
if (ModelState.IsValid)
{
var result = await UserManager.AddPasswordAsync(model.Id, model.NewPassword);
if (result.Succeeded)
{
var user = await UserManager.FindByIdAsync(model.Id);
if (user != null && User.Identity.GetUserId().Equals(model.Id))
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
}
TempData["Code"] = "success";
TempData["Head"] = "Done";
TempData["Messages"] = new List <string>()
{
"Password has been set."
};
}
else
{
TempData["Code"] = "danger";
TempData["Head"] = "Error";
TempData["Messages"] = result.Errors.ToList();
}
}
else
{
var errors = ModelState.Values.SelectMany(a => a.Errors);
TempData["Code"] = "danger";
TempData["Head"] = "Error";
TempData["Messages"] = errors.Select(a => a.ErrorMessage).ToList();
}
return(RedirectToAction("Index", new { id = model.Id }));
}
public async Task<IdentityResult> AddPasswordAsync(Guid userId, string password)
{
var result = await _userManager.AddPasswordAsync(userId, password);
return result;
}
public async Task <ActionResult> CompleteRegistration(CompleteRegistrationViewModel model)
{
if (ModelState.IsValid)
{
// Get the current user through their UserID
var user = await UserManager.FindByIdAsync(model.UserID);
// If the user isn't null, we found a match, so update the account
if (user != null)
{
// Update it with the values from the view model
user.FirstName = model.FirstName;
user.LastName = model.LastName;
user.UserName = model.UserName;
user.EmailConfirmed = true;
// Assign the password to this user account
var addPassword = await UserManager.AddPasswordAsync(model.UserID, model.Password);
var result = await UserManager.UpdateAsync(user);
if (result.Succeeded)
{
// Apply the changes
UserManager.Update(user);
// Create the entry for the UserProfile table
UserProfile newUser = new UserProfile
{
UserID = model.UserID,
FullName = model.FirstName + " " + model.LastName,
UserName = model.UserName,
Email = user.Email,
IsCaller = false,
CallsRemaining = 0,
DonationsRaised = 0
};
// Set all Standard users to be callers -- Admins will not be counted as callers for now
var userEntry = await UserManager.FindAsync(newUser.Email, model.Password);
var roles = await UserManager.GetRolesAsync(user.Id);
if (roles.Contains("Standard"))
{
newUser.IsCaller = true;
}
// Add them to the table and save the changes
db.UserProfiles.Add(newUser);
db.SaveChanges();
// Redirect to the login page (TO-DO: UPDATE THIS TO THE APPROPRIATE DASHBOARD BASED ON THE USER'S ROLE)
return(RedirectToAction("Login", "Account"));
}
// Display any errors
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error);
}
// The password wasn't added successfully -- don't update the account and return the view
return(View(model));
}
// There was no match -- just return the view
return(View(model));
}
// Invalid model state -- return the view
return(View(model));
}
public Task <IdentityResult> AddPasswordAsync(string userId, string password)
{
return(UserManager.AddPasswordAsync(userId, password));
}
public async Task <ActionResult> Register(RegisterViewModel model, string returnUrl)
{
RegisterViewModel registerViewModel = model;
Logger.Current.Informational("Are these RegisterViewModel fields valid : " + ModelState.IsValid);
if (ModelState.IsValid)
{
try
{
var user = new IdentityUser()
{
Id = registerViewModel.UserId,
Password = registerViewModel.Password,
UserName = registerViewModel.Email,
Email = new Email()
{
EmailId = registerViewModel.AccountId + "|" + registerViewModel.Email,
IsVerified = false
},
AccountID = registerViewModel.AccountId
};
IdentityResult result = await UserManager.AddPasswordAsync(user.Id, user.Password);
if (result.Succeeded)
{
var userName = registerViewModel.Email + "|" + registerViewModel.AccountId;
var newUser = await UserManager.FindByNameAsync(userName);
int userID;
int.TryParse(model.UserId, out userID);
string IP = Request.UserHostAddress;
UserManager.InsertLoginAudit(userID, model.AccountId, IP, SignInActivity.SignIn);
UserManager.InsertUserProfileAudit(userID, UserAuditType.PasswordChange, userID, model.Password);
AddCookie("IsFirstLogin", 0.ToString(), 1);
bool showTC = accountService.ShowTC(new ShowTCRequest()
{
AccountId = (int)model.AccountId
}).ShowTC;
UserSettings userSettings = accountService.GetFirstLoginUserSettings(new GetFirstLoginUserSettingsRequest()
{
RequestedBy = userID
}).UserSettings;
if (userSettings != null && !userSettings.HasAcceptedTC && showTC)
{
AddCookie("ShowTC", "1", 1);
}
else
{
AddCookie("ShowTC", "0", 1);
}
await SignInAsync(user, registerViewModel.RememberMe);
return(RedirectToLocal(returnUrl, newUser.RoleID, model.AccountId, "", ""));
}
else
{
Logger.Current.Informational("Adding password for the user failed" + result.Errors);
AddErrors(result);
}
}
catch (Exception ex)
{
ExceptionHandler.Current.HandleException(ex, DefaultExceptionPolicies.LOG_ONLY_POLICY);
ModelState.AddModelError("", "[|An error occurred, please try again later.|]");
return(View(model));
}
}
return(View(model));
}
public async Task<ActionResult> Edit(UserDetailsViewModel model)
{
if (ModelState.IsValid)
{
using (var db = new ApplicationDbContext())
{
MyUser user = db.Users.Find(model.UserId);
user.Id = model.UserId;
user.UserName = model.UserName;
user.Email = model.EmailAddress;
user.EmailConfirmed = model.EmailAddressConfirmed;
user.AccessFailedCount = model.AccessFailedCount;
user.LockoutEnabled = model.LockoutEnabled;
user.LockoutEndDateUtc = model.LockoutEndDate;
user.UserDetails.FirstName = model.FirstName;
user.UserDetails.LastName = model.LastName;
user.UserDetails.Age = model.Age;
user.UserDetails.Address = model.Address;
user.UserDetails.City = model.City;
user.UserDetails.Country = model.Country;
MyUserRole currentRole = db.Users.FirstOrDefault(m => m.Id == model.UserId)
.Roles.FirstOrDefault();
db.Users.FirstOrDefault(m => m.Id == model.UserId)
.Roles.Remove(currentRole);
db.Users.FirstOrDefault(m => m.Id == model.UserId)
.Roles.Add(new MyUserRole { RoleId = int.Parse(model.Role), UserId = model.UserId });
db.Entry(user).State = EntityState.Modified;
await db.SaveChangesAsync();
ApplicationUserManager userManager = new ApplicationUserManager(new MyUserStore(new ApplicationDbContext()));
// Dodati da se novi password salje ;)
await userManager.RemovePasswordAsync(model.UserId);
await userManager.AddPasswordAsync(model.UserId, model.Password);
}
return RedirectToAction("Index", new { Message = UserMessageId.ChangeUser });
}
ViewBag.Roles = new SelectList(db.Roles.AsEnumerable().ToList(),
"Id", "Name", db.Roles.FirstOrDefault(m => m.Id.ToString() == model.Role));
ViewBag.Id = new SelectList(db.UserDetails, "Id", "Role", model.Role);
return View(model);
}
public async Task<IHttpActionResult> SetPassword(SetPasswordBindingModel model)
{
if (!ModelState.IsValid)
return BadRequest(ModelState);
var manager = new ApplicationUserManager(new MySqlUserStore<ApplicationUser>());
IdentityResult result = await manager.AddPasswordAsync(User.Identity.GetUserId(), model.NewPassword);
if (!result.Succeeded)
return GetErrorResult(result);
return Ok();
}
