public ActionResult Save(User user, HttpPostedFileBase ImageFile) { if (!ModelState.IsValid) { var viewModel = new NewUserViewModel { User = user }; return(View("Index", viewModel)); } if (user.Id == 0) { if (ImageFile != null) { string filename = Path.GetFileName(ImageFile.FileName); user.ImagePath = "/Images/" + filename; filename = Path.Combine(Server.MapPath("~/Images/"), filename); ImageFile.SaveAs(filename); } else { user.ImagePath = "/Images/LOG-IN.png"; } user.UserRank = "Customer"; user.Password = EncDecPassword.EncryptPassword(user.Password); _context.Users.Add(user); } _context.SaveChanges(); return(RedirectToAction("Index", "Login")); }
public ActionResult NewCoordinator() { var model = new NewUserViewModel(); model.Birthday = DateTime.Today; return(View(model)); }
public ActionResult Register(NewUserViewModel viewModel) { // Log any logged-in user out this.ClearSession(); if (!ModelState.IsValid) { return(View(viewModel)); } // Create the new user profile UserProfile profile = new UserProfile(); profile.Username = viewModel.Username; profile.Salt = CryptHelper.CreateSalt(256); profile.Password = CryptHelper.CreatePasswordHash(viewModel.Password, profile.Salt); profile.RoleId = DomainHelper.GetIdByKeyValue(ref this._db, "PersonType", "Mentor"); profile.CanBeDeleted = true; // Add the profile to the dataset this._db.UserProfiles.Add(profile); // Save the changes this._db.SaveChanges(); // Let the user in FormsAuthentication.SetAuthCookie(profile.Username, true); // Send the user on to the registration page return(RedirectToAction("Index", "Registration")); }
public async Task <IActionResult> Register(NewUserViewModel model) { if (ModelState.IsValid) { var user = new AppUser { UserName = model.Email, Email = model.Email, City = model.City, Country = model.Country }; var result = await userManager.CreateAsync(user, model.Password); if (result.Succeeded) { var token = await userManager.GenerateEmailConfirmationTokenAsync(user); var confirmationLink = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, token }, Request.Scheme); mailService.SendEmailCustom(confirmationLink, model.Email, "Email confirmation link"); return(View("RegistrationConfirmation")); } foreach (var error in result.Errors) { ModelState.AddModelError("", error.Description); } } return(View(model)); }
public ActionResult NewUser(NewUserViewModel model) { if (IsAuthenticated) { return(RedirectToAction("Index", "Home")); } if (ModelState.IsValid) { var currentUser = usersDAL.GetUser(model.Username); if (currentUser != null) { ModelState.AddModelError("Username", "This username is unavailable."); return(View("newUser", model)); } var hashProvider = new HashProvider(); var hashedPassword = hashProvider.HashPassword(model.Password); var salt = hashProvider.SaltValue; var newUser = new UserModel { Username = model.Username, Password = hashedPassword, Salt = salt }; usersDAL.RegisterNewUser(newUser); LogUserIn(model.Username); return(RedirectToAction("Index", "Home")); } return(View("NewUser", model)); }
public virtual async Task <ActionResult> NewUser( Guid?siteId) { var selectedSite = await SiteManager.GetSiteForDataOperations(siteId); // only server admin site can edit other sites settings if (selectedSite.Id != SiteManager.CurrentSite.Id) { ViewData["Title"] = string.Format(CultureInfo.CurrentUICulture, StringLocalizer["{0} - New User"], selectedSite.SiteName); } else { ViewData["Title"] = StringLocalizer["New User"]; } var model = new NewUserViewModel { SiteId = selectedSite.Id }; var viewName = await CustomUserInfo.GetNewUserViewName(UserManager.Site, HttpContext); await CustomUserInfo.HandleNewUserGet( UserManager.Site, model, HttpContext, ViewData); return(View(viewName, model)); }
public IActionResult AddUserForm(NewUserViewModel model) { if (ModelState.IsValid) { if (_context.users.SingleOrDefault(u => u.email == model.email) != null) { TempData["Error"] = "☝🏻 Email is already in use, please try another email address"; return(RedirectToAction("Register")); } PasswordHasher <NewUserViewModel> Hasher = new PasswordHasher <NewUserViewModel>(); model.password = Hasher.HashPassword(model, model.password); user AddUser = new user { firstName = model.firstName, lastName = model.lastName, stAddress = model.stAddress, city = model.city, state = model.state, zip = model.zip, email = model.email, userType = model.userType, password = model.password }; _context.users.Add(AddUser); _context.SaveChanges(); AddUser = _context.users.SingleOrDefault(u => u.email == AddUser.email); HttpContext.Session.SetInt32("userid", AddUser.userid); return(RedirectToAction("Dashboard", "Home")); } return(View("Register")); }
public ActionResult UpdateUserDetails(User user) { var userInDb = _context.Get(user.Id); var emailIsUnique = _context.EmailIsUnique(user.Email); if (user.Email == userInDb.Email) { emailIsUnique = true; } if (emailIsUnique) { userInDb.FullName = user.FullName; userInDb.Email = user.Email; userInDb.BranchId = user.BranchId; userInDb.PhoneNumber = user.PhoneNumber; _context.Update(user); TempData["Success"] = "Update Successful"; return(RedirectToAction("Index")); } if (!emailIsUnique) { ModelState.AddModelError("EmailExist", "Email Already Exist"); } var viewModel = new NewUserViewModel { User = user, Branches = _context.GetBranches().ToList() }; return(View("EditUserForm", viewModel)); }
public async Task <ActionResult> New([Bind("Name", "Password", "ConfirmPassword", "Role")] NewUserViewModel model) { if (ModelState.IsValid) { var newUser = new IdentityUser { UserName = model.Name, }; var result = await _users.CreateAsync(newUser, model.Password); if (!result.Succeeded) { throw new Exception(string.Join(", ", result.Errors.Select(x => x.Description))); } result = await _users.AddToRoleAsync(newUser, model.Role); if (!result.Succeeded) { throw new Exception(string.Join(", ", result.Errors.Select(x => x.Description))); } return(RedirectToAction("Index")); } return(View(model)); }
public async Task <ActionResult> Create(NewUserViewModel user) { if (ModelState.IsValid) { ApplicationUser admin = new ApplicationUser() { Email = user.Email, UserName = user.Email, FirstName = user.FirstName, LastName = user.LastName, CreateDate = DateTime.Now, LastUpdate = DateTime.Now }; var userManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(db)); var result = await userManager.CreateAsync(admin, user.Password); if (result.Succeeded) { userManager.AddToRole(admin.Id, Roles.Admin); } return(RedirectToAction("Index")); } return(View(user)); }
public async Task <ActionResult> Create(NewUserViewModel model) { if (ModelState.IsValid) { string currentUserId = User.Identity.GetUserId(); int companyId = db.Users.Single(a => a.Id == currentUserId).CompanyId; //TODO Save Campny id in session when during t he login var user = new ApplicationUser { UserName = model.Email, Email = model.Email, CompanyId = companyId, Profile = new Profile() { DateOfCreate = DateTime.Now, DateOfUpdate = DateTime.Now, Job = model.Job, Address = "Not Set", FirstName = model.FirstName, LastName = model.LastName, Gender = model.Gender, PhoneNumber = "Not Set" } }; var userManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(db)); var result = await userManager.CreateAsync(user, model.Password); if (result.Succeeded) { userManager.AddToRole(user.Id, Roles.Staff); return(RedirectToAction("Index")); } } return(View(model)); }
public async Task <IActionResult> EditAsync(string id) { // TODO: CLEAN UP ApplicationUser userToEdit = await _userManager.FindByIdAsync(id); IList <string> userToEditRoles = await _userManager.GetRolesAsync(userToEdit); IdentityRole userToEditRole; bool noRole = userToEditRoles.Count == 0; if (noRole) { userToEditRole = await _roleManager.FindByNameAsync("Employee"); } else { userToEditRole = await _roleManager.FindByNameAsync(userToEditRoles[0]); } NewUserViewModel editUserViewModel = new NewUserViewModel(_context.PaymentProfiles.ToList(), _context.Roles.ToList(), userToEdit, userToEditRole); if (noRole) { editUserViewModel.OldRoleName = "N/A"; } return(View(editUserViewModel)); }
public async Task <IActionResult> New(NewUserViewModel model) { if (!ModelState.IsValid) { return(View(model)); } var newUser = new UserModel() { FullName = model.FullName, UserName = model.Email, Email = model.Email, EmailConfirmed = true, PhoneNumberConfirmed = true }; var addUser = await _userService.RegisterUser(newUser, model.Password, model.Role); if (addUser == RegisterStatus.Succeeded) { return(RedirectToAction(nameof(UserController.List), "User")); } else if (addUser == RegisterStatus.ExistUser) { ViewData["Message"] = Model.Resources.ValidationMessages.ExistEmail; return(View(model)); } ViewData["Message"] = Model.Resources.ValidationMessages.CreateError; return(View(model)); }
public async Task <IActionResult> EditAsync(NewUserViewModel editUserViewModel) { if (ModelState.IsValid) { ApplicationUser userToEdit = await _userManager.FindByIdAsync(editUserViewModel.UserId); IdentityRole newRole = await _roleManager.FindByIdAsync(editUserViewModel.IdentityRoleId); if (newRole.Name != editUserViewModel.OldRoleName) { await _userManager.AddToRoleAsync(userToEdit, newRole.Name); } if (editUserViewModel.OldRoleName != "N/A" && editUserViewModel.OldRoleName != newRole.Name) { await _userManager.RemoveFromRoleAsync(userToEdit, editUserViewModel.OldRoleName); } ApplicationUser.EditUser(userToEdit, editUserViewModel); await _userManager.UpdateAsync(userToEdit); return(Redirect("/User/Index")); } return(View(editUserViewModel)); }
public IActionResult New() { NewUserViewModel newUserViewModel = new NewUserViewModel(_context.PaymentProfiles.ToList(), _context.Roles.ToList()); return(View(newUserViewModel)); }
public ActionResult Save(RegisteredUsers registeredUser) { if (!ModelState.IsValid) { var viewModel = new NewUserViewModel { RegisteredUser = registeredUser, Biographies = _context.Biographies.ToList() }; return(View("UserForm", viewModel)); } if (registeredUser.Id == 0) { _context.RegisteredUsers.Add(registeredUser); } else { var registeredUserInDb = _context.RegisteredUsers.Single(c => c.Id == registeredUser.Id); registeredUserInDb.Name = registeredUser.Name; registeredUserInDb.Birthdate = registeredUser.Birthdate; registeredUserInDb.Gender = registeredUser.Gender; registeredUserInDb.Email = registeredUser.Email; registeredUserInDb.Address = registeredUser.Address; registeredUserInDb.Postcode = registeredUser.Postcode; registeredUserInDb.Phonenumber = registeredUser.Phonenumber; registeredUserInDb.BiographyId = registeredUser.BiographyId; } _context.SaveChanges(); return(RedirectToAction("Index", "User")); }
public void TestNewUserPostReturnsRedirectToRouteResultType() { var model = new NewUserViewModel(); var result = _controller.NewUser(model) as RedirectToRouteResult; Assert.AreEqual(typeof(RedirectToRouteResult), result.GetType()); }
public void TestNewUserPostReturnsCorrectRedirectToRouteResult() { var model = new NewUserViewModel(); var result = _controller.NewUser(model) as RedirectToRouteResult; Assert.AreEqual("NewUser", result.RouteValues["action"]); }
public int Save(NewUserViewModel data) { var role = UnitOfWork.Role .Where(p => p.Name == "AppUser") .Select(p => new { Id = p.IdRole }) .FirstOrDefault(); if (role != null) { var model = new User { Name = data.Name, Email = data.Email, Password = data.Password, Birthday = data.Birthday, LastName = data.LastName, FkRole = role.Id, Active = true }; UnitOfWork.Set <User>().Add(model); UnitOfWork.SaveChanges(); return(model.IdUser); } return(-1); }
public async Task <IActionResult> Register([FromBody] NewUserViewModel registration) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } IdentityUser newUser = new IdentityUser { UserName = registration.User, Email = registration.Email }; IdentityResult result = await _userManager.CreateAsync(newUser, registration.Password); if (!result.Succeeded) { foreach (var error in result.Errors) { ModelState.AddModelError(error.Code, error.Description); } return(BadRequest(ModelState)); } return(Ok()); }
public ActionResult NewUser(NewUserViewModel model) { if (base.IsAuthenticated) { return(RedirectToAction("Dashboard", "Messages", new { username = base.CurrentUser })); } if (ModelState.IsValid) { var currentUser = userDal.GetUser(model.Username); if (currentUser != null) { ViewBag.ErrorMessage = "This username is unavailable"; return(View("NewUser", model)); } var newUser = new User { Username = model.Username, Password = model.Password, }; // Add the user to the database userDal.CreateUser(newUser); // Log the user in and redirect to the dashboard base.LogUserIn(model.Username); return(RedirectToAction("Dashboard", "Messages", new { username = model.Username })); } else { return(View("NewUser", model)); } }
private void CreateUser(UserManager <ErasmusUser> manager, NewUserViewModel user, string role) { //Check for existing user var dbUser = manager.Users.SingleOrDefault(x => x.Email == user.Email); if (dbUser == null) { //Doesn't exist - create dbUser = new ErasmusUser { Email = user.Email, UserName = user.Email, EmailConfirmed = true, FirstName = user.FirstName, LastName = user.LastName, Birthday = user.Birthday, PhoneNumber = user.Telephone, UniversityId = user.UniversityId == 0 ? null : user.UniversityId, PersonalIdCode = user.PersonalCode, StudentId = user.StudentId }; manager.Create(dbUser, user.Password); manager.AddToRole(dbUser.Id, role); } else { throw new FormValidationException( new Dictionary <string, string>() { { "Email", "User with the same email already exists." } } ); } }
public void RegisterNewUser() { //Arrange var newUser = new NewUserViewModel { FullName = "Narendiran Dorairaj", Email = "*****@*****.**", CompanyName = "The Little Kingdom", PhoneNumber = "1234567890", Title = "Senior HR Specialist", NumberOfEmployees = NumberOfEmployees.Xs }; var mockCompanyServices = new Mock <ICompanyService>(); var mockUserServices = new Mock <IUserService>(); mockCompanyServices.Setup(c => c.Add(It.IsAny <Company>())); mockUserServices.Setup(u => u.Add(It.IsAny <User>())); var registerController = new RegisterController(mockCompanyServices.Object, mockUserServices.Object); //Act var result = (HttpStatusCodeResult)registerController.AddUser(newUser); //Assert Assert.AreEqual(HttpStatusCode.Created, (HttpStatusCode)result.StatusCode); mockCompanyServices.Verify(cs => cs.Add(It.IsAny <Company>()), Times.Once); mockUserServices.Verify(us => us.Add(It.IsAny <User>()), Times.Once); }
public async Task <IActionResult> Register(NewUserViewModel model) { if (ModelState.IsValid) { // Copy data from RegisterViewModel to IdentityUser var user = new IdentityUser { UserName = model.Email, Email = model.Email }; // Store user data in AspNetUsers database table var result = await userManager.CreateAsync(user, model.Password); // If user is successfully created, sign-in the user using // SignInManager and redirect to index action of HomeController if (result.Succeeded) { await signInManager.SignInAsync(user, isPersistent : false); return(RedirectToAction("Index", "Home")); } // If there are any errors, add them to the ModelState object // which will be displayed by the validation summary tag helper foreach (var error in result.Errors) { ModelState.AddModelError(string.Empty, error.Description); } } return(View(model)); }
public async Task <IActionResult> Register( NewUserViewModel newUserViewModel, CancellationToken cancellationToken) { if (ModelState.IsValid) { try { await this.registrationService.RegisterUser(newUserViewModel, cancellationToken); return(View("SuccessfullyRegistered")); } catch (ValidationException ex) { ModelState.AddModelError(nameof(newUserViewModel.Username), ex.Message); SetSkippedIfValid(nameof(newUserViewModel.Password)); SetSkippedIfValid(nameof(newUserViewModel.ConfirmPassword)); void SetSkippedIfValid(string key) { if (ModelState.GetFieldValidationState(key) == ModelValidationState.Valid) { ModelState.MarkFieldSkipped(key); } } } } return(View(nameof(RegistrationForm))); }
public async Task <IActionResult> CreateUser(NewUserViewModel model) { ViewBag.AllCompanies = new SelectList(_companyService.GetCompaniesList(), "CompanyId", "CompanyName"); ViewBag.allRoles = new SelectList(_roleManager.Roles.ToList(), "Name", "Name"); if (ModelState.IsValid) { AppUser newUser = new AppUser() { Email = model.Email, UserName = model.Email, MemberName = model.MemberName, JoinDateTime = DateTime.Now, CompanyId = model.CompanyID }; var result = await _userManager.CreateAsync(newUser, model.ConfirmPassword); if (result.Succeeded) { await _userManager.AddToRoleAsync(newUser, model.UserRole); Company company = await _companyService.GetCompanyById(model.CompanyID); if (company.AppUsers.Count >= (int)company.CompanyMemberSize) { ViewBag.SizeExceeded = "Company Membership Size Exceeded"; return(View(model)); } company.AppUsers.Add(newUser); return(RedirectToAction("GetUserList")); } } return(View("~/Views/Admin/CreateUser.cshtml", model)); }
public async Task AddNewUser(NewUserViewModel model) { var info = new ContactInfo { PhoneNumber = model.Phone, Email = model.Email, }; _dataContext.ContactInfos.Add(info); await _dataContext.SaveChangesAsync(); var contactInfoId = info.Id; var user = new User { Name = model.Name, ContactInfo = info, }; _dataContext.Users.Add(user); await _dataContext.SaveChangesAsync(); ContactGroup group = _dataContext.ContactGroups.FirstOrDefault(e => e.Id == model.ContactGroupId); _dataContext.Contacts.Add(new Contact { User = user, ContactGroup = group, ContactMethod = model.ContactMethod, }); await _dataContext.SaveChangesAsync(); }
public async Task <bool> HandleNewUserValidation( ISiteContext site, NewUserViewModel viewModel, HttpContext httpContext, ViewDataDictionary viewData, ModelStateDictionary modelState, CancellationToken cancellationToken = default(CancellationToken) ) { await EnsureProps(); var result = true; foreach (var p in _props.Properties) { if (p.VisibleOnRegistration) { var postedValue = httpContext.Request.Form[p.Key]; if (_userPropertyValidator.IsValid(p, postedValue, modelState)) { // if valid keep the field populated in case some other model validation failed and the form is re-displayed viewData[p.Key] = postedValue; } else { result = false; } } } return(result); }
public async Task <IHttpActionResult> NewUser([FromBody] NewUserViewModel data) { data.Id = Guid.NewGuid().ToString(); if (data.Username.IsNullOrWhiteSpace() || data.Password.IsNullOrWhiteSpace()) { return(Content(HttpStatusCode.BadRequest, "Invalid Data")); } var user = new ApplicationUser { Id = data.Id, UserName = data.Username }; var result = await _userManager.CreateAsync(user, data.Password); if (result.Succeeded) { return(Ok("User added")); } return(BadRequest()); }
public async Task <ActionResult> QQLogin(NewUserViewModel viewModel) { var owinContext = Request.GetOwinContext(); var identity = await owinContext.Environment.GetIdentityServerPartialLoginAsync(); if (identity == null || identity.IsAuthenticated == false) { return(new HttpUnauthorizedResult()); } var qqConnectProfile = new QQConnectProfile(identity.Claims); var newUser = new InMemoryUser { Username = viewModel.UserName ?? "Default Name", Subject = Guid.NewGuid().ToString(), Enabled = true, Provider = qqConnectProfile.Issuer, ProviderId = qqConnectProfile.OpenId, Claims = new[] { new Claim(Constants.ClaimTypes.NickName, qqConnectProfile.NickName), new Claim(Constants.ClaimTypes.Picture, qqConnectProfile.Avatar), } }; Users.All.Add(newUser); var resumeUrl = await owinContext.Environment.GetPartialLoginResumeUrlAsync(); return(Redirect(resumeUrl)); }
public ViewModelLocator() { // The hell with IoC. Let's just create all out VM's when application loads. MainView = new MainViewModel(); LoginView = new LoginViewModel(); NewUserView = new NewUserViewModel(); HomeView = new HomeViewModel(); AccountsView = new AccountsViewModel(); AccountViewer = new AccountDetailsViewModel(); StatementsView = new StatementsViewModel(); StatementViewer = new StatementViewerViewModel(); RecentActivityView = new RecentActivityViewModel(); FeedbackView = new FeedbackViewModel(); AboutView = new AboutViewModel(); AccountNew = new AccountNewViewModel(); }
public async Task<ActionResult> CreateUser(NewUserViewModel model) { try { //model.Email = model.UserName; if (!ModelState.IsValid) { AddRedirectMessage(ModelState); return View("Users", model); } model.Roles = model.AvailableRoles.Where(x => x.IsSelected).ToArray(); await ViewModelsService.Execute(model); AddRedirectMessage(ServerResponseStatus.SUCCESS, string.Format("User '{0}' created!", model.UserName)); return RedirectToAction("Users", "UserAdministration", new { id = model.UserId }); } catch (Exception ex) { AddRedirectMessage(ex); return RedirectToAction("Users", "UserAdministration"); } }