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); }