public ActionResult Login([Bind(Include = "EmailAddress,UserPassword")] UserAccountViewModel userVM, bool stayLogin, string ReturnUrl)
{
if (ModelState.IsValid)
{
UserAccount userDM = new UserAccount();
AutoMapper.Mapper.Map(userVM, userDM);
var loginSuccess = _accountServices.Login(userDM, stayLogin);
if (loginSuccess == true)
{
TempData["msgSuccess"] = "Log In";
if (Url.IsLocalUrl(ReturnUrl))
{
return(Redirect(ReturnUrl));
}
else
{
return(RedirectToAction("Index", "Home"));
}
}
}
TempData["msgFailed"] = "Log In";
return(View());
}
public async Task <IActionResult> GetUser(string userName)
{
if (string.IsNullOrEmpty(userName))
{
return(ValidationProblem(MessageInfo.User_DidntPassUserName));
}
AppUser user = await userManager.FindByNameAsync(userName);
if (user == null)
{
return(NotFound());
}
var config = new MapperConfiguration(config => config.CreateMap <AppUser, UserAccountViewModel>());
var mapper = new Mapper(config);
UserAccountViewModel showAccount = mapper.Map <UserAccountViewModel>(user);
var survey = context.UserResponses.FirstOrDefault(r => r.SurveyName == MessageInfo.Survey_LifeCircle && r.UserId == user.Id);
if (survey != null)
{
showAccount.IsLifeCircleFilled = true;
}
else
{
showAccount.IsLifeCircleFilled = false;
}
var roles = await userManager.GetRolesAsync(user);
showAccount.Role = roles;
return(Ok(showAccount));
}
private bool DoCreateUser(UserAccountViewModel model)
{
var svc = new UserAppSvcGeneric();
var created = svc.Create(model.GetEntity());
return(created.Id > 0);
}
private bool DoUpdateUser(UserAccountViewModel model)
{
var svc = new UserAppSvcGeneric();
var updated = svc.Update(model.GetEntity());
return(updated != null);
}
// GET: Register
public ActionResult Register()
{
UserAccountViewModel model = new UserAccountViewModel();
ViewBag.Info = false;
return(View());
}
public ActionResult Register(UserAccountViewModel userAccountModel)
{
if (ModelState.IsValid)
{
try
{
UserAccount userAccountObj = dbContext.UserAccount.Find(userAccountModel.UserId);
if (userAccountObj != null)
{
ModelState.AddModelError("", "The Account was created");
}
else
{
UserAccount userAccountNewObj = userAccountModel.ToUserAccount(userAccountObj);
dbContext.UserAccount.Add(userAccountNewObj);
dbContext.SaveChanges();
ModelState.Clear();
ViewBag.Message = userAccountModel.FirstName + " " + userAccountModel.LastName + "succefully register. ";
}
}
catch (RetryLimitExceededException)
{
ModelState.AddModelError("", "Unable to save changes. Try again, Please se Administrator.");
}
}
return(RedirectToAction("LogIn"));
}
public async Task <UserSession> Login(UserAccountViewModel user, AccessTokenModel token)
{
// Saved Session
string cmd = $@"INSERT INTO `user_access_token`
(`user_id`,
`access_token`,
`login_date`,
`expired_date`)
VALUES
({user.Id},
'{token.AccessToken}',
'{token.LoginDate.ToString("yyyy-MM-dd HH:mm-ss")}',
'{token.ExpiredDate.ToString("yyyy-MM-dd HH:mm-ss")}');
SELECT LAST_INSERT_ID();";
var sessionId = (await DALHelper.ExecuteQuery <long>(cmd, dbTransaction: DbTransaction, connection: DbConnection)).First();
return(new UserSession()
{
LoginResult = 0,
SessionId = sessionId,
UserName = user.UserName,
Email = user.Email,
IsSuperAdmin = user.IsSuperAdmin,
IsUsed = user.IsUsed,
Id = user.Id,
Roles = user.Roles.Select(r => r.Name).ToList(),
AccessToken = token.AccessToken
});
}
public async Task <UserSession> LoginAnotherUser(long sessionId, UserAccountViewModel user, AccessTokenModel token)
{
// Saved Session again
string cmd = $@"UPDATE `user_access_token`
SET
`user_id` = {user.Id},
`access_token` = '{token.AccessToken}',
`login_date` = '{token.LoginDate.ToString("yyyy-MM-dd HH:mm-ss")}',
`expired_date` = '{token.ExpiredDate.ToString("yyyy-MM-dd HH:mm-ss")}'
WHERE `id` = {sessionId};";
await DALHelper.Execute(cmd, dbTransaction : DbTransaction, connection : DbConnection);
return(new UserSession()
{
LoginResult = 0,
SessionId = sessionId,
UserName = user.UserName,
Email = user.Email,
IsSuperAdmin = user.IsSuperAdmin,
IsUsed = user.IsUsed,
Id = user.Id,
Roles = user.Roles.Select(r => r.Name).ToList(),
AccessToken = token.AccessToken
});
}
public ActionResult StudentDetails()
{
RegisterViewModel loggedinuser = new RegisterViewModel();
UserAccountViewModel user = new UserAccountViewModel();
string userid = User.Identity.GetUserId();
var person1 = db.AspNetUsers.Where(y => y.Id.ToString() == userid).First();
foreach (Student person in db.Students)
{
if (person1.Email == person.Email)
{
loggedinuser.FirstName = person.FirstName;
loggedinuser.LastName = person.LastName;
loggedinuser.Address = person.Address;
loggedinuser.Gender = person.Gender;
loggedinuser.Contact = person.Contact;
loggedinuser.Guardian = person.Guardian;
loggedinuser.Email = person.Email;
loggedinuser.RegistrationNo = person.RegistrationNo;
loggedinuser.Password = person.Password;
user.listofusers.Add(loggedinuser);
}
}
return(View(user));
}
public async Task <UserSession> LoginAnotherUser(long sessionId, UserAccountViewModel user, AccessTokenModel token)
{
var param = new DynamicParameters();
param.Add("@SessionId", sessionId, System.Data.DbType.Int32, System.Data.ParameterDirection.Input);
param.Add("@UserId", user.Id, System.Data.DbType.Int32, System.Data.ParameterDirection.Input);
param.Add("@AccessToken", token.AccessToken, System.Data.DbType.String, System.Data.ParameterDirection.Input);
param.Add("@LoginDate", token.LoginDate, System.Data.DbType.DateTime, System.Data.ParameterDirection.Input);
param.Add("@ExpiredDate", token.ExpiredDate, System.Data.DbType.DateTime, System.Data.ParameterDirection.Input);
await DalHelper.SPExecute(SP_LOGIN_ANOTHER, param, dbTransaction : DbTransaction, connection : DbConnection);
return(new UserSession()
{
LoginResult = 0,
SessionId = sessionId,
Username = user.Username,
Email = user.Email,
PhoneNumber = user.PhoneNumber,
DisplayName = user.DisplayName,
IsSuperAdmin = user.IsSuperAdmin,
UserId = user.Id,
RoleIds = user.Roles.Select(r => r.Id).ToList(),
AccessToken = token.AccessToken
});
}
public async Task <IActionResult> ProfileEdit(UserAccountViewModel model)
{
if (ModelState.IsValid)
{
var user = await _userManager.GetUserAsync(User);
if ((model.Email.Equals(user.Email) && model.FullName.Equals(user.FullName)) &&
string.IsNullOrEmpty(model.NewPassword))
{
return(Redirect("/my-profile"));
}
user.Email = model.Email;
user.FullName = model.FullName;
if (!string.IsNullOrEmpty(model.NewPassword))
{
await _userManager.RemovePasswordAsync(user);
await _userManager.AddPasswordAsync(user, model.NewPassword);
}
await _userManager.UpdateAsync(user);
return(Json(new { success = true, message = "Profil bilgileri başarıyla güncellendi." }));
}
return(Redirect(nameof(Profile)));
}
public ActionResult ViewStudentList(ClassViewModel collection)
{
string id = User.Identity.GetUserId();
var p = db.AspNetUsers.Where(x1 => x1.Id.ToString() == id).SingleOrDefault(); //Condition to check the Id of specific person to edit only his/her details
string email = p.Email;
var p1 = db.Teachers.Where(x1 => x1.Email == email).SingleOrDefault(); //Condition to check the Id of specific person to edit only his/her details
y.ClassName = collection.ClassName;
y.SectionName = collection.SectionName;
UserAccountViewModel userL = new UserAccountViewModel();
var list = db.StudentClasses.ToList();
foreach (var i in list)
{
if (i.Class.ClassName == collection.ClassName && i.Section.SectionName == collection.SectionName)
{
RegisterViewModel v = new RegisterViewModel();
v.Id = i.Student.StudentID;
v.FirstName = i.Student.FirstName;
v.LastName = i.Student.LastName;
v.Gender = i.Student.Gender;
v.RegistrationNo = i.Student.RegistrationNo;
userL.listofusers.Add(v);
}
}
comboreload();
return(View(userL));
}
public UserAccountView()
{
InitializeComponent();
var userAcountViewModel = new UserAccountViewModel();
userAcountViewModel.OnPasswordBoxClear += userAcountViewModel_OnPasswordBoxClear;
DataContext = userAcountViewModel;
}
public async Task <IActionResult> Login([Bind("Email,Password,RememberMe")] UserAccountViewModel viewModel)
{
string returnUrl = Url.Content("~/");
var result = await _signInManager.PasswordSignInAsync(viewModel.Email, viewModel.Password, viewModel.RememberMe, lockoutOnFailure : true);
if (result.Succeeded)
{
_logger.LogInformation("User logged in.");
return(LocalRedirect("/Home/Index"));
}
else if (result.RequiresTwoFactor)
{
return(RedirectToPage("./LoginWith2fa", new { ReturnUrl = returnUrl, RememberMe = viewModel.RememberMe }));
}
else if (result.IsLockedOut)
{
_logger.LogWarning("User account locked out.");
return(RedirectToPage("./Lockout"));
}
else
{
ModelState.AddModelError(string.Empty, "Invalid login attempt.");
return(View("_AccountError"));
}
}
public ActionResult UpdateUserAccount(UserAccountViewModel model)
{
try {
var user = _userService.GetUserById(model.User.Id);
if (_userService.GetAllUsers().Any(x => x.Username == model.User.Username.ToLower() && x.Id != user.Id))
{
return(Json(new { msg = "That username already exists on another account", error = true }));
}
user.Username = model.User.Username.ToLower();
user.Role = model.User.Role;
user.Unit.ProductKey = model.Unit.ProductKey;
if (!string.IsNullOrEmpty(model.User.PasswordHash))
{
_userService.ChangePassword(user, model.User.PasswordHash);
}
else
{
_userService.Insert(user);
}
return(Json(new { username = user.Username, pkey = user.Unit.ProductKey, msg = "User account successfully updated" }));
} catch (Exception ex) {
return(Json(new { msg = ex.Message, error = true }));
}
}
public ActionResult Create(UserAccountViewModel user)
{
UserAccount tempUser = new UserAccount();
foreach (CurrentUserPermissionListItem cpli in user.vm_rList)
{
if (cpli.IsAssigned == true) //user was not assigned and the box for this role was checked
{
UserProjectRole newRole = new UserProjectRole();
newRole.UserAccountID = tempUser.UserAccountID;
newRole.RoleId = cpli.RoleID;
db.UserProjectRoles.Add(newRole);
}
}
tempUser.UserName = user.vm_UserAccount.UserName;
tempUser.FirstName = user.vm_UserAccount.FirstName;
tempUser.LastName = user.vm_UserAccount.LastName;
tempUser.Email = user.vm_UserAccount.Email;
tempUser.Locked = user.vm_UserAccount.Locked == null ? 0 : user.vm_UserAccount.Locked;
tempUser.UserAccountID = user.vm_UserAccount.UserAccountID;
db.UserAccounts.Add(tempUser);
db.SaveChanges();
TempData["Message"] = "User successfully created";
return(RedirectToAction("Index"));
}
public async Task <object> GetFrame(ITicketHolder ticketHolder, IContext context, CancellationToken cancellationToken = default(CancellationToken))
{
if (!context.User.Identity.IsAuthenticated)
{
return(null);
}
var myState = ticketHolder.GetTicket <UserState>();
// this is our DB poll interval
if (myState != null && (DateTime.UtcNow - myState.Created).TotalSeconds < 10)
{
return(null);
}
// find useraccount
var useraccount = await _userService.FindById(context.User.UserId());
if (useraccount == null)
{
useraccount = UserAccount.Map(context.User);
}
if (myState != null && useraccount.CalculateChecksum() == myState.Checksum)
{
return(null);
}
ticketHolder.UpdateTicket(new UserState {
Created = DateTime.UtcNow, Checksum = useraccount.CalculateChecksum()
});
return(UserAccountViewModel.Map(useraccount));
}
public ActionResult Edit(UserAccountViewModel user)
{
UserAccount tempUser = db.UserAccounts.FirstOrDefault(x => x.UserAccountID == user.vm_UserAccount.UserAccountID);
foreach (CurrentUserPermissionListItem cpli in user.vm_rList)
{
var oldRoleAssignment = tempUser.UserProjectRoles.FirstOrDefault(m => m.RoleId == cpli.RoleID);
if (oldRoleAssignment != null && cpli.IsAssigned == false) //user is currently assigned and the box was unchecked
{
db.UserProjectRoles.Remove(oldRoleAssignment);
}
else if (oldRoleAssignment == null && cpli.IsAssigned == true) //user was not assigned and the box for this role was checked
{
UserProjectRole newRole = new UserProjectRole();
newRole.UserAccountID = user.vm_UserAccount.UserAccountID;
newRole.RoleId = cpli.RoleID;
db.UserProjectRoles.Add(newRole);
}
}
tempUser.UserName = user.vm_UserAccount.UserName;
tempUser.FirstName = user.vm_UserAccount.FirstName;
tempUser.LastName = user.vm_UserAccount.LastName;
tempUser.Email = user.vm_UserAccount.Email;
tempUser.Locked = user.vm_UserAccount.Locked;
tempUser.UserAccountID = user.vm_UserAccount.UserAccountID;
db.Entry(tempUser).State = EntityState.Modified;
db.SaveChanges();
TempData["Message"] = "User successfully updated";
return(RedirectToAction("Index"));
}
public UserAccountViewModel ConvertUserAccountToWeb(AccountDTO UserAccount)
{
UserAccountViewModel UserAccounts = new UserAccountViewModel();
if (UserAccount == null)
{
return(UserAccounts);
}
UserAccounts = new UserAccountViewModel()
{
Server_Date_Time = UserAccount.Server_Date_Time,
Update_DateTime_UTC = UserAccount.Update_DateTime_UTC,
ID = UserAccount.ID,
Account_Number = UserAccount.Account_Number,
Available_Balance = UserAccount.Available_Balance,
Balance = UserAccount.Balance,
Currency = UserAccount.Currency,
DateTime_UTC = UserAccount.DateTime_UTC,
NameAr = UserAccount.NameAr,
Status = UserAccount.Status,
User_ID = UserAccount.User_ID,
};
return(UserAccounts);
}
public async Task <IActionResult> Profile(UserAccountViewModel model)
{
if (ModelState.IsValid)
{
var user = await _userManager.GetUserAsync(User);
if ((model.Email.Equals(user.Email) && model.FullName.Equals(user.FullName)) &&
string.IsNullOrEmpty(model.NewPassword))
{
return(Json(new { success = true, message = "Değişiklik yapmadınız.", redirectUrl = "/Admin/Profile" }));
}
user.Email = model.Email;
user.FullName = model.FullName;
if (!string.IsNullOrEmpty(model.NewPassword))
{
await _userManager.RemovePasswordAsync(user);
await _userManager.AddPasswordAsync(user, model.NewPassword);
}
await _userManager.UpdateAsync(user);
return(Json(new { success = true, message = "Profil başarıyla güncellendi.", redirectUrl = "/Admin/Profile" }));
}
return(Json(new { success = false, message = "Profil güncellemesinde hata yaşandı, tekrar deneyiniz.", redirectUrl = "/Admin/Profile" }));
}
public ActionResult Register(UserAccountViewModel registrationView)
{
UserAccountModel userAccountModel = new UserAccountModel();
bool statusRegistration = false;
string messageRegistration = string.Empty;
if (ModelState.IsValid)
{
Mapper.Map(registrationView, userAccountModel);
DatabaseModel databaseInfoModel = new DatabaseModel();
databaseInfoModel.UserName = "******" + userAccountModel.UserName;
databaseInfoModel = this._IUserAccountOrchestrator.AddNewUser(userAccountModel, databaseInfoModel);
GlobalCachingProvider.Instance.RemoveUserCacheItems();
GlobalCachingProvider.Instance.GetAllUsersAccountsToCache();
messageRegistration = "Your account has been created successfully. ^_^";
statusRegistration = true;
}
else
{
messageRegistration = "Something Wrong!";
}
ViewBag.Message = messageRegistration;
ViewBag.Status = statusRegistration;
return(View(registrationView));
}
public List <UserAccountViewModel> ConvertUserAccountsToWeb(List <AccountDTO> AccountsDto)
{
List <UserAccountViewModel> UserAccountsList = new List <UserAccountViewModel>();
if (AccountsDto == null)
{
return(UserAccountsList);
}
foreach (var UserAccount in AccountsDto)
{
var newUserAccount = new UserAccountViewModel()
{
Server_Date_Time = UserAccount.Server_Date_Time,
Update_DateTime_UTC = UserAccount.Update_DateTime_UTC,
ID = UserAccount.ID,
Account_Number = UserAccount.Account_Number,
Available_Balance = UserAccount.Available_Balance,
Balance = UserAccount.Balance,
Currency = UserAccount.Currency,
DateTime_UTC = UserAccount.DateTime_UTC,
NameAr = UserAccount.NameAr,
Status = UserAccount.Status,
User_ID = UserAccount.User_ID,
};
UserAccountsList.Add(newUserAccount);
}
return(UserAccountsList);
}
public void POST_Login_AccountLockedTemporarily()
{
//Arrange
var viewModel = new UserAccountViewModel
{
UserName = "******",
Password = "******"
};
var account = new UserAccount
{
Id = 123,
UserName = "******",
IsLocked = true,
UnlockDate = DateTime.Today.AddDays(1),
FailedLoginAttempts = 4
};
var lockMessage = Strings.LoginLocked + account.UnlockDate + Strings.LoginLocked2;
_userAccountService.Setup(x => x.IsRegistered(It.IsAny <string>())).Returns(true);
_userAccountService.Setup(x => x.FindByUserName(It.IsAny <string>())).Returns(account);
_userAccountService.Setup(x => x.CheckLock(It.IsAny <UserAccount>())).Returns(true);
_userAccountService.Setup(x => x.LoginFailed(It.IsAny <UserAccount>())).Returns(account);
//Act
var result = (ViewResult)_controller.Login(viewModel, "");
//Assert
Assert.That(result.ViewName, Is.Empty);
Assert.That(_controller.ModelState[string.Empty].Errors[0].ErrorMessage, Is.EqualTo(lockMessage));
}
public async Task <IActionResult> Login(UserAccountViewModel acc)
{
if (!ModelState.IsValid)
{
return(View(acc));
}
var(loginSuccess, savedToken) = await AuthorizeWithUsernameAndPasswordAsync(acc.Email, acc.Password);
if (!loginSuccess)
{
ModelState.AddModelError("InvalidLogin", "Username or password is invalid. Please check again.");
return(View(acc));
}
if (acc.RememberLogin)
{
var savingTime = GetCookieOptions(DateTime.Now);
ResponseCookies.Append(Consts.LoginToken, savedToken, savingTime);
ResponseCookies.Append(Consts.Username, acc.Email, savingTime);
}
Session.SetObject(Consts.LoginSession, new LoginedUser(acc.Email));
return(RedirectToAction(nameof(HomeController.Index), ControllerName.Of <HomeController>()));
}
public void POST_Login_AuthenticationServerError()
{
//Arrange
var viewModel = new UserAccountViewModel
{
UserName = "******",
Password = "******"
};
var account = new UserAccount
{
Id = 123,
UserName = "******",
IsLocked = false,
UnlockDate = null
};
_userAccountService.Setup(x => x.IsRegistered(It.IsAny <string>())).Returns(true);
_userAccountService.Setup(x => x.FindByUserName(It.IsAny <string>())).Returns(account);
_userAccountService.Setup(x => x.CheckLock(It.IsAny <UserAccount>())).Returns(false);
_userAccountService.Setup(x => x.ValidateCredentials(It.IsAny <string>(), It.IsAny <string>())).Returns((bool?)null);
//Act
var result = (HttpStatusCodeResult)_controller.Login(viewModel, "");
//Assert
Assert.That(result.StatusCode, Is.EqualTo((int)HttpStatusCode.InternalServerError));
}
public void POST_Login_AccountLockedIndefinitely()
{
//Arrange
var viewModel = new UserAccountViewModel
{
UserName = "******",
Password = "******"
};
var account = new UserAccount
{
Id = 123,
UserName = "******",
IsLocked = true,
UnlockDate = null
};
_userAccountService.Setup(x => x.IsRegistered(It.IsAny <string>())).Returns(true);
_userAccountService.Setup(x => x.FindByUserName(It.IsAny <string>())).Returns(account);
_userAccountService.Setup(x => x.CheckLock(It.IsAny <UserAccount>())).Returns(true);
_userAccountService.Setup(x => x.LoginFailed(It.IsAny <UserAccount>())).Returns(account);
//Act
var result = (ViewResult)_controller.Login(viewModel, "");
//Assert
Assert.That(result.ViewName, Is.Empty);
Assert.That(_controller.ModelState[string.Empty].Errors[0].ErrorMessage, Is.EqualTo(Strings.LoginLockedPerm));
}
public async Task <UserAccountViewModel> GetUserWithRole(int userId)
{
var param = new DynamicParameters();
param.Add("@Id", userId, System.Data.DbType.Int32, System.Data.ParameterDirection.Input);
UserAccountViewModel user = null;
try
{
var reader = await DbConnection.QueryMultipleAsync(SP_GET_WITHROLE, param, commandType : System.Data.CommandType.StoredProcedure, transaction : DbTransaction);
reader.Read <UserAccount, Role, UserAccountViewModel>(
(userRs, roleRs) =>
{
if (user == null)
{
return(null);
}
if (roleRs != null)
{
user.Roles.Add(roleRs);
}
return(user);
}
);
return(user);
}
finally
{
if (!IsJoinTransaction)
{
DbConnection.Dispose();
}
}
}
public UserAccountViewModel GetUserAccount(int userID)
{
UserAccountViewModel userViewModel = new UserAccountViewModel();
try
{
pidhubEntities entity = new pidhubEntities();
var user = (from ua in entity.UserAccounts
where ua.User_ID == userID
select ua).FirstOrDefault();
if (user != null)
{
userViewModel.UserID = user.User_ID;
userViewModel.PilotName = user.PilotName;
userViewModel.Email = user.Email;
userViewModel.Password = user.Password;
}
}
catch (Exception ex)
{
}
return(userViewModel);
}
public UserAccountViewModel CreateUserAccount(UserAccountViewModel userViewModel)
{
try
{
pidhubEntities entity = new pidhubEntities();
UserAccount userAccount = new UserAccount()
{
PilotName = userViewModel.PilotName,
Email = userViewModel.Email,
Password = userViewModel.Password
};
entity.UserAccounts.Add(userAccount);
entity.SaveChanges();
userViewModel.UserID = userAccount.User_ID;
}
catch (Exception ex)
{
//TODO Change method to return SaveResult
//saveResult.ErrorMessage = String.Format("There was an error creating your account {0}.", ex.Message);
}
return(userViewModel);
}
public ActionResult Create()
{
UserAccountViewModel user = new UserAccountViewModel();
user.vm_Roles = db.Roles.ToArray();
return(View(user));
}
public void POST_Login_InvalidPassword()
{
//Arrange
var viewModel = new UserAccountViewModel
{
UserName = "******",
Password = "******"
};
var account = new UserAccount
{
Id = 123,
UserName = "******",
IsLocked = false,
UnlockDate = null,
FailedLoginAttempts = 0
};
_userAccountService.Setup(x => x.IsRegistered(It.IsAny <string>())).Returns(true);
_userAccountService.Setup(x => x.FindByUserName(It.IsAny <string>())).Returns(account);
_userAccountService.Setup(x => x.CheckLock(It.IsAny <UserAccount>())).Returns(false);
_userAccountService.Setup(x => x.ValidateCredentials(It.IsAny <string>(), It.IsAny <string>())).Returns(false);
_userAccountService.Setup(x => x.LoginFailed(It.IsAny <UserAccount>())).Returns(account);
//Act
var result = (ViewResult)_controller.Login(viewModel, "");
//Assert
Assert.That(result.ViewName, Is.Empty);
Assert.That(_controller.ModelState[string.Empty].Errors[0].ErrorMessage, Is.EqualTo(Strings.LoginError));
}
public ActionResult Edit(UserAccountViewModel viewModel)
{
if (ModelState.IsValid)
{
try
{
_userManagementService.Edit(viewModel.Id, viewModel.Name, viewModel.EmailAddress, viewModel.JobTitle);
return RedirectToAction("Index");
}
catch (DomainValidationException dex)
{
ModelState.UpdateFromDomain(dex.Result);
}
}
return View(viewModel);
}
public ActionResult Create(UserAccountViewModel viewModel)
{
if (ModelState.IsValid)
{
try
{
var id = Guid.NewGuid();
_userManagementService.Create(id, viewModel.Name, viewModel.EmailAddress, viewModel.Password, viewModel.JobTitle);
return RedirectToAction("Index");
}
catch (DomainValidationException dex)
{
ModelState.UpdateFromDomain(dex.Result);
}
}
return View(viewModel);
}
