public async Task <ActionResult> ChangeUsername(ChangeUserNameViewModel model)
{
_logger.Info("Changing Username! Params: " + model.ToJson());
if (!ModelState.IsValid)
{
_logger.Error("Changing Username Form Invalid! Errors: " + ModelState.ToJson());
return(Json(ModelState.ToDictionary()));
}
try
{
var user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
user.UserName = model.UserName;
await UserManager.UpdateAsync(user);
_logger.Info("Changing Username Successfully!");
return(Json(user.UserName));
}
catch (Exception ex)
{
_logger.Error(ex, "Changing Username Failed!");
throw;
}
}
public IActionResult ChangeUserName(ChangeUserNameViewModel model)
{
if (ModelState.IsValid)
{
var user = _userManager.GetUserAsync(HttpContext.User).Result;
//var user = await _userManager.FindByNameAsync(HttpContext.User.Identity.Name);
if (user != null)
{
var result = _userManager.SetUserNameAsync(user, model.UserName).Result;
if (result.Succeeded)
{
ViewData["message"] = "User Changed Successfully";
return(View());
}
else
{
foreach (var err in result.Errors)
{
string errDesc = err.Description;
ModelState.AddModelError(string.Empty, errDesc);
}
//ViewData["message"] = "Error in changing Username";
}
}
}
return(View());
}
public async Task <ActionResult> ChangeName(ChangeUserNameViewModel model)
{
if (ModelState.IsValid)
{
var user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
if (user == null)
{
return(HttpNotFound());
}
user.UserName = model.NewName;
var result = await UserManager.UpdateAsync(user);
if (result.Succeeded)
{
return(RedirectToAction("Index"));
}
AddErrors(result);
return(View());
}
ModelState.AddModelError("", "Ha ocurrido un error.");
return(View());
}
public async Task <ActionResult> ChangeUserName(ChangeUserNameViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var user = await _userManager.GetUserAsync(HttpContext.User);
if (user != null)
{
user.UserName = model.NewUserName;
var result = await _userManager.UpdateAsync(user);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, isPersistent : false);
return(RedirectToAction("Manage", new { Message = ManageMessageId.ChangeUserNameSuccess }));
}
else
{
return(RedirectToAction("Manage", new { Message = ManageMessageId.Error }));
}
}
else
{
return(NotFound());
}
}
public IActionResult ChangeUserName(ChangeUserNameViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
User user = userManager.FindByIdAsync(model.Id).Result;
IdentityResult userNameResult = userManager.SetUserNameAsync(user, model.NewUserName).Result;
if (!userNameResult.Succeeded)
{
foreach (var error in userNameResult.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
return(BadRequest(model));
}
}
bool passwordResult = userManager.CheckPasswordAsync(user, model.Password).Result;
if (!passwordResult)
{
return(BadRequest("Incorrect password"));
}
return(Ok(new { Status = "Success" }));
}
public async Task <ActionResult> ChangeUserName(ChangeUserNameViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var user = UserManager.FindById(User.Identity.GetUserId());
user.Email = model.NewUserName;
user.UserName = model.NewUserName;
var updateResult = await UserManager.UpdateAsync(user);
if (updateResult.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.ChangeUserNameSuccess }));
}
AddErrors(updateResult);
return(View(model));
}
public async Task <IActionResult> ChangeUserName(ChangeUserNameViewModel 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 result = await _userManager.SetUserNameAsync(user, model.NewUserName);
if (!result.Succeeded)
{
AddErrors(result);
return(View(model));
}
await _signInManager.SignInAsync(user, isPersistent : false);
TempData["Status"] = "Your Username has been changed.";
return(RedirectToAction(nameof(ChangeUserName)));
}
public async Task <IActionResult> ChangeUserName(ChangeUserNameViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
User user = await userManager.FindByIdAsync(model.Id);
IdentityResult userNameResult = await userManager.SetUserNameAsync(user, model.NewUserName);
if (!userNameResult.Succeeded)
{
foreach (var error in userNameResult.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
return(View(model));
}
}
bool passwordResult = await userManager.CheckPasswordAsync(user, model.Password);
if (!passwordResult)
{
ModelState.AddModelError(string.Empty, "Incorrect password");
return(View(model));
}
await signInManager.RefreshSignInAsync(user);
return(RedirectToAction("Index", "Home"));
}
public async Task <ActionResult> ChangeUserName(ChangeUserNameViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
IdentityResult result;
var user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
if (user != null)
{
user.UserName = model.UserName;
result = await UserManager.UpdateAsync(user);
if (result.Succeeded)
{
return(RedirectToAction("Index", new { Message = ManageMessageId.ChangeUserNameSuccess }));
}
}
else
{
result = new IdentityResult(new string[1] {
"User not found"
});
}
AddErrors(result);
return(View(model));
}
public async Task <ActionResult> ChangeUserName(ChangeUserNameViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
ApplicationUser userDb = new ApplicationUser();
using (var database = new BlogDbContext())
{
var authorId = database.Users.Where(u => u.Name == this.User.Identity.Name).First().Id;
userDb = database.Users.Where(u => u.Id == authorId).First();
}
model.OldUserName = userDb.Name;
var result = await UserManager.ChangePhoneNumberAsync(User.Identity.GetUserId(), model.OldUserName, model.NewUserName);
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", "Manage"));
}
AddErrors(result);
return(View(model));
}
public ActionResult ChangeUserName()
{
ChangeUserNameViewModel model = new ChangeUserNameViewModel {
OldUserName = User.Identity.Name
};
return(View(model));
}
public ActionResult ChangeUsername()
{
var model = new ChangeUserNameViewModel {
UserID = Guid.Parse(User.Identity.GetUserId())
};
return(View(model));
}
public IActionResult ChangeUserName()
{
ChangeUserNameViewModel model = new ChangeUserNameViewModel();
var userName = _userManager.GetUserName(HttpContext.User);
model.UserName = userName;
return(View(model));
}
//
// GET: /Manage/ChangeAge
public ActionResult ChangeUserName()
{
var model = new ChangeUserNameViewModel()
{
OldEmail = UserManager.FindById(User.Identity.GetUserId()).Email
};
return(View(model));
}
public IActionResult Get()
{
ChangeUserNameViewModel model = new ChangeUserNameViewModel();
var userId = _caller.Claims.Single(c => c.Type == "id");
var OnlineUser = _userManager.FindByIdAsync(userId.Value).Result;
model.UserName = OnlineUser.UserName;
model.Id = OnlineUser.Id;
return(new OkObjectResult(model));
}
public async Task <IActionResult> ChangeUserName(ChangeUserNameViewModel model)
{
#region Валидация на стороне сервера
if (string.IsNullOrEmpty(model.OldUserName))
{
ModelState.AddModelError("OldUserName", "Укажите текущий никнейм.");
}
if (string.IsNullOrEmpty(model.NewUserName))
{
ModelState.AddModelError("NewUserName", "Укажите никнейм.");
}
if (!string.IsNullOrEmpty(model.NewUserName) && !string.IsNullOrEmpty(model.OldUserName))
{
if (model.NewUserName.Equals(model.OldUserName))
{
ModelState.AddModelError("NewUserName", "Новый никнейм не может совпадать с старым.");
}
}
if (ModelState.ErrorCount != 0)
{
return(View(model));
}
#endregion
if (ModelState.IsValid)
{
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
return(View("Error"));
}
var changeUserNameResult = await _userManager.SetUserNameAsync(user, model.NewUserName);
if (!changeUserNameResult.Succeeded)
{
foreach (var error in changeUserNameResult.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
return(View(model));
}
await _userManager.UpdateNormalizedUserNameAsync(user);
await _signInManager.RefreshSignInAsync(user);
return(RedirectToAction("Index", new { Message = ManageMessageId.ChangeUserNameSuccess }));
}
return(View(model));
}
public ActionResult ChangeUsernameFunc(ChangeUserNameViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var asvc = new AccountService(new Guid(), UserManager);
if (asvc.ChangeUsername(model.UserID, model.NewUsername))
{
return(RedirectToAction("Index"));
}
return(View(model));
}
public async Task <IActionResult> ChangeAccountName(ChangeUserNameViewModel model)
{
if (ModelState.IsValid)
{
ApplicationUser user = await userManager.GetUserAsync(User);
user.AcconutName = model.Name;
await userManager.UpdateAsync(user);
return(View("ChangeAccountNameConfirmation", model));
}
return(View());
}
public async Task <IActionResult> ChangeUserName(string id)
{
User user = await userManager.FindByIdAsync(id);
if (user == null)
{
return(NotFound());
}
ChangeUserNameViewModel model = new ChangeUserNameViewModel {
Id = user.Id, Email = user.Email
};
return(View(model));
}
public async Task <ActionResult> ChangeUserName(ChangeUserNameViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
using (ApplicationDbContext db = new ApplicationDbContext())
{
var userId = User.Identity.GetUserId();
var user = db.Users.FirstOrDefault(x => x.Id == userId);
user.FIO = model.NewUserName;
db.Entry(user).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index", new { Message = ManageMessageId.ChangeUserNameSuccess }));
}
}
public async Task <IActionResult> ChangeUserName()
{
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'.");
}
var model = new ChangeUserNameViewModel
{
CurrentUserName = user.UserName,
NewUserName = ""
};
return(View(model));
}
public async Task <IActionResult> ChangeUserName()
{
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
return(View("Error"));
}
var userRoles = await _userManager.GetRolesAsync(user);
var model = new ChangeUserNameViewModel {
UserRole = userRoles[0], OldUserName = user.UserName
};
return(View(model));
}
public async Task <ActionResult> ChangeUserName(ChangeUserNameViewModel model)
{
if (ModelState.IsValid)
{
var currentUser = await UserManager.FindByIdAsync(User.Identity.GetUserId());
if (currentUser != null)
{
currentUser.Email = model.NewEmail;
currentUser.UserName = model.NewEmail;
await UserManager.UpdateAsync(currentUser);
}
return(RedirectToAction("Index", new { Message = ManageMessageId.ChangeAgeSuccess }));
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public ActionResult ChangeUserName(ChangeUserNameViewModel model)
{
try
{
// TO-DO: Either extend the membership provider to support username changes
// or create a new user and copy all the data as per
// http://stackoverflow.com/questions/1001491/is-it-possible-to-change-the-username-with-the-membership-api
//
var user = Membership.GetUser();
//user.UserName = model.UserName;
// Update the User profile in the database
Membership.UpdateUser((System.Web.Security.MembershipUser)user);
return(RedirectToCurrentUmbracoPage());
}
catch (Exception ex)
{
logger.Error(ex);
return(RedirectToCurrentUmbracoPage());
}
}
//public ActionResult ChangeUserName(ChangeUserNameViewModel model, string returnUrl)
public async Task <ActionResult> ChangeUserName(ChangeUserNameViewModel model)
{
if (ModelState.IsValid)
{
var user = await UserManager.FindByNameAsync(User.Identity.Name);
user.UserName = model.UserName;
await UserManager.UpdateAsync(user);
return(RedirectToAction("Index", "Home"));
}
//if (ModelState.IsValid)
//{
// ApplicationDbContext db = new ApplicationDbContext();
// var user = db.Users.FirstOrDefault(u => u.UserName == User.Identity.Name);
// user.UserName = model.UserName;
// db.SaveChanges();
// return RedirectToAction("Index", "Home");
//}
return(View(model));
}
public async Task <JsonResult> ChangeUserName(ChangeUserNameViewModel model)
{
if (ModelState.IsValid)
{
var result = new Result()
{
Errors = new System.Collections.Generic.List <string>()
};
var loggedUser = Person.GetLoggedPerson(User, _db);
var oldDisplayName = loggedUser.DisplayName;
loggedUser.DisplayName = model.UserName;
_db.SaveChanges();
result.Succeeded = true;
await UserManager.SendEmailAsync(loggedUser.InviterID, "Zmiana nazwy wyświetlania przez podopiecznego",
string.Format("Użytkownik organizacji {0} o Id {1} i nazwie wyświetlania {2} (stara nazwa) zmienił swoją nazwę na {3}", loggedUser.Organization.Name, loggedUser.Id, oldDisplayName, loggedUser.DisplayName));
return(Json(result));
}
return(getErrorsFromModel());
}
public ActionResult ChangeUserName(ChangeUserNameViewModel model)
{
if (TravelExpertsData.IsUniqueUserName(model.NewUserName))
{
Customer curr = GetCurrentCustomer();
// make sure we found customer
if (curr == null)
{
ModelState.AddModelError(String.Empty, "Sorry an error occured while trying to find you. Please try log in again.");
return(View());
}
curr.UserName = model.NewUserName;
if (TravelExpertsData.UpdateCustomerUserName(curr) && TravelExpertsData.UpdateAccountUserName(curr))
{
return(RedirectToAction("Index", new { Message = ManageMessageId.EditUserNameSuccess }));
}
// something went wrong
return(RedirectToAction("Index", new { Message = ManageMessageId.Error }));
}
ModelState.AddModelError(String.Empty, "Account is already linked to this user name.");
return(View());
}
public IActionResult Put(string id, [FromBody] ChangeUserNameViewModel model)
{
if (model == null)
{
return(null);
}
var admin = _userManager.FindByIdAsync(id).Result;
if (admin == null)
{
return(NotFound());
}
admin.UserName = model.UserName;
var result = _userManager.UpdateAsync(admin).Result;
if (!result.Succeeded)
{
return(BadRequest());
}
return(Ok());
}
