public async Task <ActionResult> ChangeUsername(ChangeUsernameViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var user = UserManager.FindById(User.Identity.GetUserId <int>());
if (UserManager.CheckPassword(user, model.CurrentPassword))
{
user.UserName = model.NewUsername;
IdentityResult result = await UserManager.UpdateAsync(user);
if (result.Succeeded)
{
return(RedirectToAction("Index", "Settings", new { area = "Account", Message = ManageMessageId.ChangeUsernameSuccess }));
}
AddErrors(result);
return(View());
}
else
{
IdentityResult uncorrectPassword = IdentityResult.Failed("You entered a wrong password.");
AddErrors(uncorrectPassword);
model.CurrentPassword = "";
return(View(model));
}
}
public async Task <ActionResult> ChangeUsername(ChangeUsernameViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
if (user != null)
{
var db = new ApplicationDbContext();
var allUsers = db.Users.ToList();
var username = model.newUsername;
foreach (var u in allUsers)
{
if (username == u.ToString())
{
return(RedirectToAction("ChangeUsername", "Manage"));
}
}
user.UserName = model.newUsername;
await UserManager.UpdateAsync(user);
}
return(RedirectToAction("Index", new { Message = ManageMessageId.ChangeUsernameSuccess }));
}
public async Task <ActionResult> ChangeUsername(ChangeUsernameViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
if (UserManager.FindByName(model.NewUserName) != null)
{
TempData["UserNameTaken"] = "Username is already taken";
return(RedirectToAction("ChangeUsername"));
}
User user = UserManager.FindById(User.Identity.GetUserId());
user.UserName = model.NewUserName;
var result = await UserManager.UpdateAsync(user);
if (result.Succeeded)
{
var u = await UserManager.FindByIdAsync(User.Identity.GetUserId());
if (u != null && u.UserName == model.NewUserName)
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
return(RedirectToAction("Index", new { Message = ManageMessageId.ChangeUserNameSuccess }));
}
}
return(View(model));
}
public ActionResult ChangeUsername(ChangeUsernameViewModel model)
{
return(this.RedirectToAction("ExternalNotify", "Account", new { area = string.Empty }));
if (Regex.IsMatch(this.UserProfile.UserName, "^[a-zA-Z]([/._]?[a-zA-Z0-9]+)+$") && this.UserProfile.UserName.Length >= 5 && this.UserProfile.UserName.Length <= 15)
{
return(this.RedirectToAction(GlobalConstants.Index, new { controller = "Profile", area = "Users" }));
}
if (this.ModelState.IsValid)
{
if (this.Data.Users.All().Any(x => x.UserName == model.Username))
{
this.ModelState.AddModelError("Username", "This username is not available");
return(this.View(model));
}
this.UserProfile.UserName = model.Username;
this.Data.SaveChanges();
this.TempData[GlobalConstants.InfoMessage] = Resources.Account.Views.ChangeUsernameView.Username_changed;
this.AuthenticationManager.SignOut();
return(this.RedirectToAction("Login", new { controller = "Account", area = string.Empty }));
}
return(this.View(model));
}
public ActionResult ChangeUsername(ChangeUsernameViewModel newUsername)
{
m.isUserBanned();
if (!ModelState.IsValid)
{
return(View(newUsername));
}
if (!m.IsUsernameSpace(newUsername.userName))
{
ModelState.AddModelError("", "No spaces/special characters in username");
return(View(newUsername));
}
bool isDup = m.IsDupUserName(newUsername);
if (isDup == false)
{
ModelState.AddModelError("", "Username taken");
return(View(newUsername));
}
bool error = m.ChangeUsername(newUsername);
if (error == false)
{
ModelState.AddModelError("", "Error with username");
return(View(newUsername));
}
else
{
return(Redirect("UserDashboard"));
}
}
public ActionResult ChangeUsername()
{
m.isUserBanned();
ChangeUsernameViewModel username = new ChangeUsernameViewModel();
username.userName = "";
return(View(username));
}
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"));
}
return(View(model));
}
public void ChangeUsernameClickedCommandTest()
{
//Arrange
var vm = new ChangeUsernameViewModel();
vm.newUsername = "******";
//Act
vm.ChangeUsername.Execute(null);
//Assert
Assert.IsTrue(vm.GetType().Name == "ChangeUsernameViewModel", "viewmodel");// Correct result
}
public async Task <ActionResult> ChangeUsername(ChangeUsernameViewModel model)
{
if (ModelState.IsValid)
{
var user = UserManager.FindById(User.Identity.GetUserId());
user.UserName = model.NewUsername;
await UserManager.UpdateAsync(user);
await SignInAsync(user, true);
TempData["UpdatedAccountDetail"] = "username";
return(RedirectToAction("Index", "Account"));
}
return(View(model));
}
public async Task <IActionResult> ChangeUserName()
{
var model = new ChangeUsernameViewModel();
var user = await GetCurrentUserAsync();
if (user == null)
{
_logger.LogError($"Username '{HttpContext.User.Identity.Name}' not found in repository");
ModelState.AddModelError(string.Empty, _localizer["'{0}' not found", _metaData.GetDisplayName <ChangeUsernameViewModel>(nameof(ChangeUsernameViewModel.Username))]);
return(PartialView(ViewNames.Manage._ChangeUsernameModalPartial, model));
}
model.Username = user.Name;
return(PartialView(ViewNames.Manage._ChangeUsernameModalPartial, model));
}
public ActionResult ChangeUsername(ChangeUsernameViewModel model)
{
try
{
CompanyName = Request.Cookies["companyCookie"].Value;
User user = db.Users.Where(u => u.username == User.Identity.Name && u.company == CompanyName).FirstOrDefault();
user.username = model.newUsername;
db.SaveChanges();
AuthenticationManager.SignOut(DefaultAuthenticationTypes.ApplicationCookie);
ViewBag.ChangePassword = "******";
return(RedirectToAction("Index", "Home"));
}catch (Exception e)
{
ViewBag.ChangePassword = "******";
return(RedirectToAction("Index", "Home"));
}
}
public async Task <ActionResult> ChangeUsername(ChangeUsernameViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
var username = model.NewUsername;
if (user != null)
{
user.UserName = username;
await UserManager.UpdateAsync(user);
this.AddNotification("Username changed successfully.", NotificationType.INFO);
}
return(RedirectToAction("Index"));
}
public async Task <IActionResult> ChangeUsername(ChangeUsernameViewModel model)
{
if (!User.Identity.IsAuthenticated)
{
return(View(HttpStatusCode.Forbidden));
}
// HttpContextAccessor DI works when Singelton (Scoped injects null)
var id = _context.HttpContext.User.GetUserId();
ChatUser user = _repository.GetUserById(id);
string oldUsername = user.Name; //user.UserName
try
{
if (ModelState.IsValid)
{
var result = await _signInManager.CheckPasswordSignInAsync(user, model.password, false);
if (result.Succeeded)
{
user.UserName = model.username;
user.Name = model.username;
_repository.CommitChanges();
// _notificationService.OnUserNameChanged(user, oldUsername, model.username);
return(RedirectToAction(nameof(Index), new { Message = ManageMessageId.ChangeUsernameSuccess }));
}
else
{
return(new RedirectResult(Url.Action("Index", new { Message = ManageMessageId.WrongPassword }) + "#changeUsername"));
}
}
}
catch (Exception ex)
{
return(RedirectToAction(nameof(Index), new { Message = ManageMessageId.Error }));
}
return(new RedirectResult(Url.Action("Index", new { Message = ManageMessageId.ErrorChangeUsername }) + "#changeUsername"));
}
public ActionResult ChangeUsername(ChangeUsernameViewModel CUVM)
{
if (ModelState.IsValid)
{
var putter = db.Putters.FirstOrDefault(p => p.Paswoord == CUVM.Paswoord &&
p.Gebruikersnaam == CUVM.Gebruikersnaam);
putter.Gebruikersnaam = CUVM.NewUsername;
db.Entry(putter).State = EntityState.Modified;
db.SaveChanges();
FormsAuthentication.SetAuthCookie(putter.Gebruikersnaam, true);
TempData["succesboodschap"] = "Welkom, <b>" + putter.Gebruikersnaam + "</b><br />Je gebruikersnaam werd gewijzigd";
//return RedirectToAction("Index", "Home");
return(View(CUVM));
}
else
{
return(View(CUVM));
}
}
public async Task <IActionResult> ChangeUserName(ChangeUsernameViewModel model)
{
if (!ModelState.IsValid)
{
return(PartialView(ViewNames.Manage._ChangeUsernameModalPartial, model));
}
var user = await GetCurrentUserAsync();
if (user != null)
{
if (user.NormalizedUserName == _userManager.KeyNormalizer.NormalizeName(model.Username))
{
// do nothing and display success
TempData.Put <ManageMessage>(nameof(ManageMessage), new ManageMessage {
AlertType = SiteAlertTagHelper.AlertType.Success, MessageId = MessageId.ChangeUsernameSuccess
});
return(JsonAjaxRedirectForModal(Url.Action(nameof(Index), nameof(Manage), new { Organization = _siteContext.UrlSegmentValue })));
}
user.UserName = model.Username;
var result = await _userManager.UpdateAsync(user);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, isPersistent : false);
_logger.LogInformation($"User '{user.Id}' changed the username successfully.");
TempData.Put <ManageMessage>(nameof(ManageMessage), new ManageMessage {
AlertType = SiteAlertTagHelper.AlertType.Success, MessageId = MessageId.ChangeUsernameSuccess
});
return(JsonAjaxRedirectForModal(Url.Action(nameof(Index), nameof(Manage), new { Organization = _siteContext.UrlSegmentValue })));
}
AddErrors(result);
//return View(model);
return(PartialView(ViewNames.Manage._ChangeUsernameModalPartial, model));
}
TempData.Put <ManageMessage>(nameof(ManageMessage), new ManageMessage {
AlertType = SiteAlertTagHelper.AlertType.Danger, MessageId = MessageId.ChangeUsernameFailure
});
return(JsonAjaxRedirectForModal(Url.Action(nameof(Index), nameof(Manage), new { Organization = _siteContext.UrlSegmentValue })));
}
public async Task <ActionResult> ChangeUserName(ChangeUsernameViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var user = UserManager.FindById(User.Identity.GetUserId());
user.UserName = model.UserName;
var result = await UserManager.UpdateAsync(user);
if (result.Succeeded)
{
if (user != null)
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
}
return(RedirectToAction("Index"));
}
AddErrors(result);
return(View(model));
}
public async Task <ActionResult> ChangeUsername(ChangeUsernameViewModel model)
{
if (ModelState.IsValid)
{
var user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
if (user != null)
{
user.UserName = model.NewUsername;
var result = await UserManager.UpdateAsync(user);
if (!result.Succeeded)
{
AddErrors(result);
}
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
}
return(RedirectToAction("Index", new { Message = ManageMessageId.ChangeUsernameSucces }));
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <IActionResult> changeUsername([FromBody] ChangeUsernameViewModel model)
{
//correct login check
var result = await _signInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, lockoutOnFailure : false);
if (result.Succeeded)
{
// checks username validation in model
if (ModelState.IsValid)
{
var user = this.GetCurrentUserAsync();
// swap username
var swap = await _userManager.SetUserNameAsync(user.Result, model.Username);
if (swap.Succeeded)
{
return(Ok());
}
else
{
// something went wrong with swap username
return(BadRequest(this.ModelState));
}
}
else
{
// something went wrong with username validation
return(BadRequest(this.ModelState)); // model state not valid
}
}
else
{
// something went wrong with login
ModelState.AddModelError(string.Empty, "Invalid login attempt."); // wrong username or password
return(BadRequest(this.ModelState));
}
}
public IActionResult ChangeUsername([FromBody] ChangeUsernameViewModel changeRequest)
{
if (ModelState.IsValid)
{
//token heeft geen id => fout met token!!
if (User.FindFirst("userId")?.Value == null)
{
return(BadRequest(new { error = "De voorziene token voldoet niet aan de eisen." }));
}
if (CheckUsernameExists(changeRequest.Username))
{
return(BadRequest(new { error = "Deze gebruikersnaam is reeds in gebruik." }));
}
ChangeUsername(int.Parse(User.FindFirst("userId")?.Value), changeRequest.Username);
return(Ok(new { bericht = "Uw gebruikersnaam werd succesvol gewijzigd." }));
}
//Als we hier zijn is is modelstate niet voldaan dus stuur error 400, slechte aanvraag
string errorMsg = string.Join(" | ", ModelState.Values.SelectMany(v => v.Errors).Select(e => e.ErrorMessage));
return(BadRequest(new { error = "De ingevoerde waarden zijn onvolledig of voldoen niet aan de eisen voor het wijzigen van uw gebruikersnaam. Foutboodschap: " + errorMsg }));
}
public async Task <ActionResult> ChangeUsername(ChangeUsernameViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
bool checkUSN = false;
if (model.NewUsername != User.Identity.GetUserName())
{
checkUSN = true;
}
else
{
checkUSN = false;
}
if (checkUSN)
{
var user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
if (user != null)
{
user.UserName = model.NewUsername;
var result = await UserManager.UpdateAsync(user);
if (result.Succeeded)
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
return(RedirectToAction("Index", new { Message = ManageMessageId.ChangeUsernameSuccess }));
}
}
}
return(View(model));
}
public async Task<ActionResult> ChangeUsername(ChangeUsernameViewModel model)
{
if (!ModelState.IsValid)
{
return View(model);
}
var user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
user.DisplayName = model.NewUsername;
if (user != null)
{
await SignInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false);
}
return RedirectToAction("Index", new { Message = ManageMessageId.ChangeUsernameSuccess });
}
public ActionResult ChangeUsername()
{
ChangeUsernameViewModel CUVM = new ChangeUsernameViewModel();
return(View(CUVM));
}
