public async Task <IActionResult> Edit(EditAccountViewModel model)
{
if (ModelState.IsValid)
{
User user = await _userManager.FindByIdAsync(model.Id);
var passwordValidator =
HttpContext.RequestServices.GetService(
typeof(IPasswordValidator <User>)) as IPasswordValidator <User>;
var passwordHasher =
HttpContext.RequestServices.GetService(typeof(IPasswordHasher <User>)) as IPasswordHasher <User>;
if (user != null)
{
user.Email = model.Email;
user.UserName = model.UserName;
if (passwordValidator != null && !string.IsNullOrEmpty(model.Password))
{
IdentityResult result =
await passwordValidator.ValidateAsync(_userManager, user, model.Password);
if (result.Succeeded)
{
if (passwordHasher != null)
{
user.PasswordHash = passwordHasher.HashPassword(user, model.Password);
}
await _userManager.UpdateAsync(user);
return(RedirectToAction("Index", "Home"));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
}
}
return(View(model));
}
public ActionResult Edit(EditAccountViewModel model)
{
string userId = User.Identity.GetUserId();
var user = db.Users.FirstOrDefault(u => u.Id == userId);
if (db.Users.Where(u => u.MobileNumber == model.MobileNumber).ToList().Count > 1)
{
TempData["Message"] = "<strong>Update Account info failed.</strong> Mobile Number in the system already exists.";
return(RedirectToAction("Index"));
}
else
{
user.MobileNumber = model.MobileNumber;
db.SaveChanges();
TempData["Message"] = "<strong>Account info updated successfully.</strong>";
return(RedirectToAction("Index"));
}
}
public async Task Initialize_AccountLoaded()
{
// Arrange
const int accountId = 99;
var editAccountVm = new EditAccountViewModel(mediatorMock.Object,
mapperMock.Object,
settingsFacadeMock.Object,
backupServiceMock.Object,
dialogServiceMock.Object,
navigationServiceMock.Object);
// Act
editAccountVm.AccountId = accountId;
await editAccountVm.InitializeCommand.ExecuteAsync();
// Assert
mediatorMock.Verify(x => x.Send(It.IsAny <GetAccountByIdQuery>(), default), Times.Once);
}
public EditAccount(IAccount account = null)
{
this.InitializeComponent();
if (account == null)
{
ViewModel = new EditAccountViewModel(MainPage.GlobalSettings.Storages.AccountStorage);
_saveAccountAction = delegate { ViewModel.CreateNewAccount(); };
Title = "Create Account";
PrimaryButtonText = "Create Account";
SecondaryButtonText = "Cancel";
}
else
{
ViewModel = new EditAccountViewModel(MainPage.GlobalSettings.Storages.AccountStorage, account);
_saveAccountAction = delegate { ViewModel.UpdateAccount(); };
Title = "Edit Account";
PrimaryButtonText = "Save";
SecondaryButtonText = "Cancel";
}
}
public EditAccountViewModel MapEditAccountViewModel(int id)
{
var account = FinancialPlannerRepository.GetAccounts()
.FirstOrDefault(m => m.Id == id);
if (account == null)
{
return(null);
}
var vm = new EditAccountViewModel
{
Id = account.Id,
Name = account.Name,
Amount = account.Amount,
UserName = account.UserName
};
return(vm);
}
public ActionResult EditAccount(EditAccountViewModel vm, bool isDone = false)
{
var username = User.Identity.Name;
var saved = FinancialPlannerAccountService.EditAccount(vm, username);
if (!saved)
{
return(PartialView("Error"));
}
ViewBag.Title = "Edit Account";
if (isDone)
{
return(RedirectToAction("Index", new { accountId = vm.Id }));
}
return(PartialView("EditAccount", vm));
}
// GET: /Manage/Edit
public async Task <ActionResult> Edit(string id)
{
if (id == null)
{
_logger.Trace("No parameters passed for Edit");
return(new HttpStatusCodeResult(System.Net.HttpStatusCode.BadRequest));
}
var gymUser = await _accountService.GetUser(id);
if (gymUser == null)
{
_logger.Info($"Parameter {id} was passed for Edit but did not return a result");
return(HttpNotFound());
}
var viewModel = new EditAccountViewModel(gymUser);
return(View(viewModel));
}
public ActionResult Edit(EditAccountViewModel viewModel)
{
Account account = _accountRepository.FindAll(a => a.Email == User.Identity.Name).FirstOrDefault();
if (account == null)
{
return(RedirectToAction("Index", "Home", null));
}
account.FirstName = viewModel.FirstName;
account.LastName = viewModel.LastName;
account.Company = viewModel.Company;
account.RegistrationNumber = viewModel.RegistrationNumber;
account.Address = viewModel.Address;
account.Phone = viewModel.Phone;
_accountRepository.Save(account);
return(RedirectToAction("View"));
}
public void UpdateAccountTest()
{
var storage = new MemoryAccountStorage(new RegularAccountFactory());
var account = storage.CreateAccount("New Account", "Old description", "UAH");
var viewModel = new EditAccountViewModel(storage, account);
viewModel.Name = TestAccount;
viewModel.Description = Description;
viewModel.Currency = Usd;
viewModel.UpdateAccount();
var newAccount = storage.GetAllAccounts().FirstOrDefault();
Assert.IsNotNull(newAccount);
Assert.AreEqual(account.Id, newAccount.Id);
Assert.AreEqual(TestAccount, newAccount.Name);
Assert.AreEqual(Description, newAccount.Description);
Assert.AreEqual(Usd, newAccount.Currency);
}
public async Task <IActionResult> Edit()
{
var account = await _userManager.GetUserAsync(User);
if (account != null)
{
EditAccountViewModel model = new EditAccountViewModel()
{
Avatar = account.Avatar,
Email = account.Email,
FirstName = account.FirstName,
MiddleName = account.MiddleName,
LastName = account.LastName,
PhoneNumber = account.PhoneNumber,
UserName = account.UserName
};
return(View(model));
}
return(RedirectToAction(actionName: "Login"));
}
public ActionResult EditAccount(EditAccountViewModel model)
{
using (var context = new Entities())
{
int id = (int)Session["Id"];
var person = context.Person.FirstOrDefault(s => s.Id == id);
if (person != null)
{
person.Name = model.Name;
person.NickName = model.NickName;
person.DrivingHabits = model.DrivingHabits;
person.DriverExperience = model.DriverExperience;
person.Password = model.NewPassword;
context.SaveChanges();
}
return(RedirectToAction("Index"));
}
}
public async Task <ActionResult> EditPasswordAsync(EditAccountViewModel model)
{
if (ModelState.IsValid)
{
var user = await _userManager.GetUserAsync(HttpContext.User);
var oldAccount = _accountService.VerifyAccount(user.UserName, model.OldPassword);
if (oldAccount != null)
{
oldAccount.PasswordHash = PasswordHash.GenerateSHA512String(model.NewPassword);
oldAccount.UpdatedUserId = user.UserId;
_accountService.Update(oldAccount);
return(RedirectToAction("Index", "Home", new { Area = "Admin" }));
}
ModelState.AddModelError("", Constants.InvalidOldPassword);
return(RedirectToAction("Index"));
}
ModelState.AddModelError("", Constants.UnknowErrorMessage);
return(RedirectToAction("Index"));
}
public async Task <IActionResult> PasswordRecoveryPage(EditAccountViewModel acc)
{
HttpClient client = _client.Initiale();
client.DefaultRequestHeaders.Accept.Clear();
var response = await client.PostAsJsonAsync("https://comptes-api.azurewebsites.net/api/ComptesAPI/PasswordRecoveryPage", acc);
if (response.IsSuccessStatusCode)
{
//var data = await response.Content.ReadAsStringAsync();
//var targetAccount = JsonConvert.DeserializeObject<Account>(data);
return(RedirectToAction("login"));
}
else if (response.StatusCode == System.Net.HttpStatusCode.BadRequest || response.StatusCode == System.Net.HttpStatusCode.NotFound)
{
ViewBag.Error = "Invalid Information";
return(View());
}
return(BadRequest());
}
public async Task <IActionResult> Edit()
{
var user = await GetCurrentUserAsync();
if (user == null)
{
throw new Exception("Current user not found");
}
var model = new EditAccountViewModel
{
FirstName = user.FirstName,
LastName = user.LastName,
Email = user.Email,
Phone = user.Phone,
OfficeId = user.OfficeId,
OfficeSelectList = await _dal.GetOfficesSelectListAsync(),
};
return(View(model));
}
// GET: Account/Edit/{guid}
public async Task <ActionResult> Edit(string id)
{
if (id == null)
{
return(RedirectToAction("BadRequest", "Error"));
}
// Can only edit myself
var currentId = User.Identity.GetUserId();
if (id != currentId)
{
return(RedirectToAction("Forbidden", "Error"));
}
var account = await UserManager.FindByIdAsync(id);
var model = new EditAccountViewModel(account);
return(View(model));
}
public bool EditAccount(EditAccountViewModel vm, string username)
{
var account = FinancialPlannerRepository.GetAccounts().FirstOrDefault(m => m.Id == vm.Id);
if (account == null)
{
return(false);
}
account.InitialAmount = account.InitialAmount + (vm.Amount - account.Amount);
account.Name = vm.Name;
account.Amount = vm.Amount;
account.UserName = username;
FinancialPlannerRepository.EditAccount(account);
FinancialPlannerRepository.Save();
AdjustTransactionBalances(account);
return(true);
}
public ActionResult ViewUser()
{
string id = HttpContext.User.Identity.GetUserId();
ApplicationUser user = UserManager.FindById(id);
ViewBag.Edit = RoleManager.FindById(user.Roles.First().RoleId).Name == "Administrator";
EditAccountViewModel userViewModel = new EditAccountViewModel
{
UserId = user.Id,
UserName = user.UserName,
Email = user.Email,
Gender = user.Gender,
Age = user.Age,
Country = user.Country,
RoleName = RoleManager.FindById(user.Roles.First().RoleId).Name
};
return(View(userViewModel));
}
public ActionResult Edit(string userId)
{
List <SelectListItem> roles = new List <SelectListItem>();
foreach (var item in RoleManager.Roles)
{
roles.Add(new SelectListItem()
{
Value = item.Name,
Text = item.Name
});
}
ViewBag.Roles = roles;
ViewBag.Gender = new List <SelectListItem>()
{
new SelectListItem {
Value = "Male", Text = "Male"
},
new SelectListItem {
Value = "Female", Text = "Female"
}
};
ApplicationUser user = UserManager.FindById(userId);
EditAccountViewModel userViewModel = new EditAccountViewModel
{
UserId = user.Id,
UserName = user.UserName,
Email = user.Email,
Gender = user.Gender,
Age = user.Age,
Country = user.Country,
RoleName = RoleManager.FindById(user.Roles.First().RoleId).Name
};
return(View(userViewModel));
}
public IActionResult Edit(EditAccountViewModel model)
{
AccountEntity account;
if (!model.Id.HasValue)
{
account = new AccountEntity();
_reserveBotContext.Accounts.Add(account);
_reserveBotContext.SaveChanges();
}
else
{
account = _reserveBotContext.Accounts.Single(x => x.Id == model.Id);
}
account.Name = model.Name;
account.TelegramLogin = model.TelegramLogin;
var inTeams = new List <AccountInTeamEntity>();
_reserveBotContext.AccountInTeams.RemoveRange(
_reserveBotContext.AccountInTeams.Where(x => x.AccountId == account.Id));
_reserveBotContext.SaveChanges();
if (model.Teams != null)
{
foreach (var selectListItem in model.Teams.Where(selectListItem => selectListItem.Selected))
{
inTeams.Add(new AccountInTeamEntity()
{
AccountId = account.Id, TeamId = Guid.Parse(selectListItem.Value)
});
_reserveBotContext.AccountInTeams.AddRange(inTeams);
}
}
_reserveBotContext.SaveChanges();
return(RedirectToAction("Index"));
}
public async Task <object> Edit(EditAccountViewModel model)
{
if (ModelState.IsValid)
{
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
return(Json(new { success = false, errors = new[] { new { message = "Account doesn't exist." } } }));
}
if (model.Email != user.UserName)
{
var setUserNameResult = await _userManager.SetUserNameAsync(user, model.Email);
if (!setUserNameResult.Succeeded)
{
return(Json(new { success = false, errors = setUserNameResult.Errors.Select(e => new { message = e.Description }) }));
}
}
if (model.Email != user.Email)
{
var setEmailResult = await _userManager.SetEmailAsync(user, model.Email);
if (!setEmailResult.Succeeded)
{
return(Json(new { success = false, errors = setEmailResult.Errors.Select(e => new { message = e.Description }) }));
}
}
user.FirstName = model.FirstName;
user.LastName = model.LastName;
await _userManager.UpdateAsync(user);
return(Json(new { success = true, data = user }));
}
return(Json(new { success = false, errors = ModelState.Values.SelectMany(v => v.Errors).Select(e => new { message = e.ErrorMessage }) }));
}
public async Task <IActionResult> Manage()
{
var model = new EditAccountViewModel()
{
User = await _userManager.GetUserAsync(this.User),
Decorations = _context.Decorations.Select(x => new SelectListItem()
{
Value = x.Id.ToString(),
Text = x.Name
}).ToList(),
Titles = titles.Select(x => new SelectListItem()
{
Value = x.Id.ToString(),
Text = x.Value
})
};
model.DecorationId = model.User.DecorationId;
model.TitleId = model.TitleId;
return(View(model));
}
public async Task AmountStringSetOnInitialize()
{
// Arrange
const int accountId = 99;
mapperMock.Setup(x => x.Map <AccountViewModel>(It.IsAny <Account>()))
.Returns(new AccountViewModel {
CurrentBalance = 99
});
var editAccountVm = new EditAccountViewModel(mediatorMock.Object,
mapperMock.Object,
dialogServiceMock.Object,
navigationServiceMock.Object);
// Act
editAccountVm.AccountId = accountId;
await editAccountVm.InitializeCommand.ExecuteAsync();
// Assert
editAccountVm.AmountString.ShouldEqual("99.00");
}
public async Task AmountCorrectlyFormattedOnSave(string cultureString, string amountString, decimal expectedAmount)
{
// Arrange
var cultureInfo = new CultureInfo(cultureString);
Thread.CurrentThread.CurrentCulture = cultureInfo;
Thread.CurrentThread.CurrentUICulture = cultureInfo;
var editAccountVm = new EditAccountViewModel(mediatorMock.Object,
mapperMock.Object,
dialogServiceMock.Object,
navigationServiceMock.Object);
editAccountVm.SelectedAccount.Name = "Foo";
// Act
editAccountVm.AmountString = amountString;
await editAccountVm.SaveCommand.ExecuteAsync();
// Assert
editAccountVm.SelectedAccount.CurrentBalance.ShouldEqual(expectedAmount);
}
public ActionResult editUser(EditAccountViewModel model)
{
if (ModelState.IsValid)
{
string userId = Request.Form["userId"];
ApplicationUser user = _context.Users.FirstOrDefault(u => u.Id == userId);
user.Email = model.Email;
user.FirstName = model.FirstName;
user.LastName = model.LastName;
user.UserName = model.Email;
_context.Entry(user).State = System.Data.Entity.EntityState.Modified;
_context.SaveChanges();
TempData["success"] = "Successfully edited user";
return(RedirectToAction("allUsers"));
}
return(View(model));
}//editUser()
// -----------------
// Edit Account
// -----------------
public async Task <IActionResult> EditAccount()
{
// Get authenticated user
var user = await _contextFacade.GetAuthenticatedUserAsync();
// Ensure user is authenticated
if (user == null)
{
return(Unauthorized());
}
// Return Url for authentication & canonical url purposes
ViewData["ReturnUrl"] = _contextFacade.GetRouteUrl(new RouteValueDictionary()
{
["area"] = "Plato.Users",
["controller"] = "Home",
["action"] = "EditAccount"
});
// Breadcrumb
_breadCrumbManager.Configure(builder =>
{
builder.Add(S["Home"], home => home
.Action("Index", "Home", "Plato.Core")
.LocalNav()
).Add(S["Your Account"]);
});
// Build view model
var viewModel = new EditAccountViewModel()
{
Id = user.Id,
UserName = user.UserName,
Email = user.Email
};
// Return view
return(View((LayoutViewModel)await _editAccountViewProvider.ProvideEditAsync(viewModel, this)));
}
public async Task <IActionResult> Edit(string userId)
{
AppIdentityUser user = await _userManager.FindByIdAsync(userId);
if (user == null)
{
return(NotFound());
}
EditAccountViewModel editUser = new EditAccountViewModel()
{
UserId = user.Id,
FirstName = user.FirstName,
LastName = user.LastName,
MiddleName = user.MiddleName,
Email = user.Email,
ClassId = user.ClassId,
PhoneNumber = user.PhoneNumber,
Classes = _context.Classes.Select(e => e).ToList()
};
return(View(editUser));
}
public async Task <ActionResult> Edit(EditAccountViewModel model)
{
if (ModelState.IsValid)
{
var account = await UserManager.FindByIdAsync(model.Id);
var currentId = User.Identity.GetUserId();
if (model.Id != currentId)
{
return(RedirectToAction("Forbidden", "Error"));
}
account.GivenName = model.GivenName;
account.FamilyName = model.FamilyName;
account.About = model.About;
account.BirthDate = model.BirthDate;
account.Address1 = model.Address1;
account.Address2 = model.Address2;
account.City = model.City;
account.State = model.State;
account.Postal = model.Postal;
account.Country = model.Country;
await account.UpdateLatLong(Geocoder);
account.PhoneNumber = model.PhoneNumber;
account.Email = model.Email;
account.UserName = model.Email;
var result = await UserManager.UpdateAsync(account);
if (result.Succeeded)
{
return(RedirectToAction("Details", new { Id = account.Id }));
}
AddErrors(result);
}
return(View(model));
}
public IActionResult Edit(EditAccountViewModel model)
{
if (ModelState.IsValid)
{
var account = context.Account
.Where(x => x.AccountGuid == model.AccountGuid)
.SingleOrDefault();
if (account == null)
{
NotFound();
}
account.BankName = model.BankName;
account.AccountName = model.AccountName;
account.AccountNumber = model.AccountNumber;
account.CardNumber = model.CardNumber;
account.Credit = Convert.ToInt64(model.Credit);
account.ModifiedDate = DateTime.Now;
if (Convert.ToBoolean(context.SaveChanges() > 0))
{
TempData["ToasterState"] = ToasterState.Success;
TempData["ToasterType"] = ToasterType.Message;
TempData["ToasterMessage"] = Messages.EditAccountSuccessful;
}
else
{
TempData["ToasterState"] = ToasterState.Error;
TempData["ToasterType"] = ToasterType.Message;
TempData["ToasterMessage"] = Messages.EditAccountFailed;
}
return(RedirectToAction("Index"));
}
return(BadRequest());
}
public async Task <ActionResult> EditAccount(EditAccountViewModel model)
{
if (User.IsInRole("DemoAcc"))
{
return(View(model));
}
if (!ModelState.IsValid)
{
return(View(model));
}
var user = UserManager.FindById(User.Identity.GetUserId());
user.FirstName = model.UserFirstName;
user.LastName = model.UserLastName;
user.DisplayName = model.UserDisplayName;
user.PhoneNumber = model.PhoneNumber;
var result = await UserManager.UpdateAsync(user);
if (result != null)
{
}
return(RedirectToAction("Index", new { Message = ManageMessageId.EditAccountSuccess }));
}
public ActionResult details(EditAccountViewModel model)
{
if (ModelState.IsValid)
{
string id = User.Identity.GetUserId();
var user = db.Users.Find(id);
if (user == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
user.Email = model.Email;
user.Address = model.Address;
user.ClassifiedsPhone = model.ClassifiedsPhone;
user.Sex = model.Sex;
user.DOB = model.DOB;
user.Alias = model.Alias;
db.Entry(user).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
ViewBag.message = "Changes successfully saved.";
//return RedirectToAction("index", "listing");
}
return(View(model));
}
public ActionResult Edit(EditAccountViewModel model)
{
try
{
User Theuser = service.GetUserByID(CurrentUserID);
Theuser.FirstName = model.FirstName;
Theuser.LastName = model.LastName;
Theuser.Address = model.Address;
Theuser.City = model.City;
Theuser.EmailAddress = model.EmailAddress;
Theuser.FaxNumber = model.FaxNumber;
Theuser.GSTInformation = model.GSTInformation;
Theuser.PhoneNumber = model.PhoneNumber;
Theuser.PostalCode = model.PostalCode;
Theuser.Province = model.Province;
service.Save(Theuser);
model = Mapper.Map<User, EditAccountViewModel>(Theuser);
return RedirectToAction("Index", "Assessment");
}
catch (Exception)
{
ModelState.AddModelError("", "There was a problem creating your account");
return PartialView(model);
}
}
