public JsonResult ValidateMemberId([Bind(Prefix = "registerModel")] RegisterFormViewModel model) { var errorMsg = ValidateMemberIdCore(model.MemberId, model.DateOfBirth); return(errorMsg == null ? Json(true, JsonRequestBehavior.AllowGet) : Json(errorMsg, JsonRequestBehavior.AllowGet)); }
public ActionResult Register(RegisterFormViewModel registerViewModel, string returnUrl) { if (!ModelState.IsValid) { registerViewModel.RoleTypes = _context.RoleTypes.ToList(); return(View("RegistrationForm", registerViewModel)); } else { var register = new Registration { Username = registerViewModel.Registration.Username, Password = registerViewModel.Registration.Password, PasswordConfirmation = registerViewModel.Registration.PasswordConfirmation, RoleId = registerViewModel.Registration.RoleId }; FormsAuthentication.SetAuthCookie(register.Username, true); _context.Registrations.Add(register); _context.SaveChanges(); if (Url.IsLocalUrl(returnUrl) && returnUrl.Length > 1 && returnUrl.StartsWith("/") && !returnUrl.StartsWith("//") && !returnUrl.StartsWith("/\\")) { return(Redirect(returnUrl)); } else { return(RedirectToAction("Index", "Account")); } } }
public ActionResult Register(RegisterFormViewModel model) { //View model validation for register form if (ModelState.IsValid) { var respondent = new Respondent { Date = DateTime.Now, DoB = model.DoB, FirstName = model.FirstName, LastName = model.LastName, Phone = model.Phone, IP_Address = GetIpAddress() }; //Store respondent in Session AppSession.SetRespondent(respondent); //Send respondent to Survey return(RedirectToAction("Survey", "Survey")); } //If form invalid return respondent to register form return(View()); }
public async Task <ActionResult> ChangeInfoUser(RegisterFormViewModel model) { if (!ModelState.IsValid) { string msg = string.Join(Environment.NewLine , ModelState.Values.SelectMany(v => v.Errors).Select(v => v.ErrorMessage + " " + v.Exception)); ModelState.AddModelError("", msg); return(View(model)); } var identityUser = UserManager.FindById(model.Id); identityUser = Mapper.Map(model, identityUser); identityUser.Created = DateTime.UtcNow; var result = await UserManager.UpdateAsync(identityUser); if (result.Succeeded) { return(RedirectToAction("ChangeInfoUser", "User")); } return(View()); }
public List <string> Register(RegisterFormViewModel model) { ICollection <string> modelErrors = Validator.ValidateModel(model); if (this.Data.Users.Any(u => u.Username == model.Username)) { modelErrors.Add($"User with '{model.Username}' username already exists."); } if (this.Data.Users.Any(u => u.Email == model.Email)) { modelErrors.Add($"User with '{model.Email}' e-mail already exists."); } if (modelErrors.Count != 0) { return(modelErrors.ToList()); } var user = new User { Username = model.Username, Password = this.PasswordHasher.GeneratePassword(model.Password), Email = model.Email, IsMechanic = model.UserType == "Client" ? false : true, }; Data.Users.Add(user); Data.SaveChanges(); return(modelErrors.ToList()); }
public List <string> CreateUser(RegisterFormViewModel model) { ICollection <string> modelErrors = Validator.ValidateModel(model); if (!IsEmailAvailable(model.Email)) { modelErrors.Add($"User with '{model.Email}' e-mail already exists."); } if (!IsUsernameAvailable(model.Username)) { modelErrors.Add($"User with '{model.Username}' username already exists."); } if (modelErrors.Count != 0) { return(modelErrors.ToList()); } var user = new User { Username = model.Username, Password = this.passwordHasher.GeneratePassword(model.Password), Email = model.Email, }; Data.Users.Add(user); Data.SaveChanges(); return(modelErrors.ToList()); }
public async Task <IActionResult> Register(RegisterFormViewModel register, string returnUrl = null) { returnUrl = returnUrl ?? Url.Content("~/"); if (ModelState.IsValid) { var user = new User { UserName = register.UserName, Email = register.Email, Cpf = register.Cpf, PhoneNumber = register.PhoneNumber, Name = register.Name }; var result = await _userManager.CreateAsync(user, register.Password); if (result.Succeeded) { var role = "Cliente"; await _userManager.AddToRoleAsync(user, role); await _loginManager.SignInAsync(user, false); return(RedirectToAction(nameof(Index))); } else { foreach (var error in result.Errors) { ModelState.AddModelError("", error.Description.ToString()); } } } return(View(register)); }
public async Task <ActionResult> Create(RegisterFormViewModel model, string ReturnUrl) { ActionResult action; if (!this.ModelState.IsValid) { action = this.View(); } else { IdentityUser identityUser = new IdentityUser() { UserName = model.UserName, Address = model.Address, FirstName = model.FirstName, LastName = model.LastName, MiddleName = model.MiddleName, Phone = model.Phone, Email = model.Email, City = model.City, State = model.State, IsLockedOut = false, IsSuperAdmin = false, Created = DateTime.UtcNow }; IdentityUser identityUser1 = identityUser; IdentityResult identityResult = await this._userManager.CreateAsync(identityUser1, model.Password); IdentityResult identityResult1 = identityResult; if (identityResult1.Succeeded) { if (!model.IsSuperAdmin) { string item = this.Request["roles"]; if (!string.IsNullOrEmpty(item)) { string[] strArrays = item.Split(new char[] { ',' }); await this._userManager.AddToRolesAsync(identityUser1.Id, strArrays); } } this.Response.Cookies.Add(new HttpCookie("system_message", string.Format(MessageUI.CreateSuccess, FormUI.Account))); if (!this.Url.IsLocalUrl(ReturnUrl) || ReturnUrl.Length <= 1 || !ReturnUrl.StartsWith("/") || ReturnUrl.StartsWith("//") || ReturnUrl.StartsWith("/\\")) { action = this.RedirectToAction("Index"); } else { action = this.Redirect(ReturnUrl); } } else { this.AddErrors(identityResult1); action = this.View(model); } } return(action); }
public ActionResult Register() { m.LoadData(); var Roles = m.RoleClaimGetAllStrings(); var form = new RegisterFormViewModel(); form.RoleList = new MultiSelectList(Roles); return(View(form)); }
public static AccountModel ToAccountModel(this RegisterFormViewModel ViewModel) { AccountModel Model = new AccountModel(); Model = Mapper.Map <RegisterFormViewModel, AccountModel>(ViewModel); Model.Salt = PasswordHasher.GenerateSalt(); Model.Password = PasswordHasher.ComputeHash(ViewModel.Password, Model.Salt); return(Model); }
public async Task <ActionResult> Edit(RegisterFormViewModel model, string ReturnUrl) { ActionResult action; try { model.Created = null; IdentityUser identityUser = _userManager.FindById(model.Id); identityUser = Mapper.Map(model, identityUser); IdentityResult identityResult = await this._userManager.UpdateAsync(identityUser); if (identityResult.Succeeded) { if (model.IsSuperAdmin) { IList <string> roles = this._userManager.GetRoles(model.Id); this._userManager.RemoveFromRoles <IdentityUser, Guid>(model.Id, roles.ToArray <string>()); } else { string item = this.Request["roles"]; if (!string.IsNullOrEmpty(item)) { IList <string> lstUserRole = this._userManager.GetRoles(model.Id); _userManager.RemoveFromRoles(model.Id, lstUserRole.ToArray()); string[] strArrays = item.Split(new char[] { ',' }); this._userManager.AddToRoles(model.Id, strArrays); } } Response.Cookies.Add(new HttpCookie("system_message", string.Format(MessageUI.UpdateSuccess, FormUI.Account))); if (!this.Url.IsLocalUrl(ReturnUrl) || ReturnUrl.Length <= 1 || !ReturnUrl.StartsWith("/") || ReturnUrl.StartsWith("//") || ReturnUrl.StartsWith("/\\")) { action = this.RedirectToAction("Index"); return(action); } else { action = this.Redirect(ReturnUrl); return(action); } } else { this.AddErrors(identityResult); action = this.View(model); return(action); } } catch (Exception exception1) { Exception exception = exception1; ExtentionUtils.Log(string.Concat("Account.Update: ", exception.Message)); } action = this.View(); return(action); }
public ActionResult ForgotPassword(RegisterFormViewModel form) { var player = m.PlayerGetByEmail(form.Email); if (player != null) { var user = new PassResetAddViewModel(); user.EMAIL = form.Email; user.TOKENEXPIRY = DateTime.Now.AddHours(24); user.VERIFIED = false; var passReset = m.PassResetAdd(user); if (passReset == 'A') { try { SendEmailToUser(user.EMAIL, null, 'P', user.TOKEN); ViewBag.Message = "An email has been sent to the user. Please check your email to change your password."; return(View(form)); } catch (Exception) { ViewBag.Message = "There was a problem sending the email. Please try again later."; return(View(form)); } } else if (passReset == 'U') { try { var newUser = m.PassResetGetByEmail(user.EMAIL); SendEmailToUser(newUser.EMAIL, null, 'P', newUser.TOKEN); ViewBag.Message = "An email has been sent to the user. Please check your email to change your password."; return(View(form)); } catch (Exception) { ViewBag.Message = "There was a problem sending the email. Please try again later."; return(View(form)); } } else { ViewBag.Message = "There was a problem sending the email. Please try again later."; return(View(form)); } } else { ViewBag.Message = "No account found using the providing email used. Please use another email."; return(View(form)); } }
public HttpResponse Register(RegisterFormViewModel model) { var result = UserService.CreateUser(model); if (result.Count != 0) { return(Error(result)); } return(Redirect("/Users/Login")); }
public ActionResult Register() { var role = _context.RoleTypes.ToList(); var viewModel = new RegisterFormViewModel { Registration = new Registration(), RoleTypes = role }; return(View("RegistrationForm", viewModel)); }
public async Task <ActionResult> Edit(RegisterFormViewModel model, string returnUrl) { ActionResult action; try { model.Created = null; var identityUser = UserManager.FindById(model.Id); identityUser = Mapper.Map(model, identityUser); var identityResult = await UserManager.UpdateAsync(identityUser); if (identityResult.Succeeded) { if (model.IsSuperAdmin) { var roles = UserManager.GetRoles(model.Id); UserManager.RemoveFromRoles(model.Id, roles.ToArray()); } else { var item = Request["roles"]; if (!string.IsNullOrEmpty(item)) { var lstUserRole = UserManager.GetRoles(model.Id); UserManager.RemoveFromRoles(model.Id, lstUserRole.ToArray()); var strArrays = item.Split(','); UserManager.AddToRoles(model.Id, strArrays); } } Response.Cookies.Add(new HttpCookie("system_message", string.Format(MessageUI.UpdateSuccess, FormUI.Account))); if (!Url.IsLocalUrl(returnUrl) || returnUrl.Length <= 1 || !returnUrl.StartsWith("/") || returnUrl.StartsWith("//") || returnUrl.StartsWith("/\\")) { action = RedirectToAction("Index"); return(action); } action = Redirect(returnUrl); return(action); } AddErrors(identityResult); action = View(model); return(action); } catch (Exception exception1) { var exception = exception1; LogText.Log(string.Concat("Account.Update: ", exception.Message)); } action = View(); return(action); }
public ActionResult Confirm(RegisterFormViewModel dto) { if (!ModelState.IsValid) { var @evt = db.Events.Include(x => x.Template).SingleOrDefault(e => e.Id == dto.EventId); if (@evt != null) { dto.Template = @evt.Template; } return(View("Register", dto)); } var @event = db.Events.Include(x => x.Template).SingleOrDefault(e => e.Id == dto.EventId); if (@event == null) { return(View("EventNotFound")); } var guest = db.Guests.Include(e => e.Event).Include(t => t.Event.Template).SingleOrDefault(g => g.Id == dto.GuestId); var compareGuest = Mapper.Map <Guest>(dto); if (!guest.Equals(compareGuest)) { var demoChange = Mapper.Map <DemographicChange>(compareGuest); demoChange.Source = Source.RSVP; demoChange.UpdatedBy = "Donor"; db.DemographicChanges.Add(demoChange); } Mapper.Map(dto, guest); @event.RegisterGuest(guest); @event.SendEmail(guest); //Need copy of template before discarding changes. var template = @event.Template.Copy(); //Do not modify template of event. db.Entry(@event.Template).State = EntityState.Unchanged; db.Events.AddOrUpdate(@event); db.Guests.AddOrUpdate(guest); db.SaveChanges(); var finishFormViewModel = Mapper.Map <FinishFormViewModel>(guest); finishFormViewModel.Template = template; return(View("Finish", finishFormViewModel)); }
public async Task <ActionResult> Confirm(RegisterFormViewModel dto) { var @event = _eventService.GetEvent(dto.EventId); if (!ModelState.IsValid) { dto.Template = @event.Template; return(View("Register", dto)); } var guest = await _context.Guests.FirstOrDefaultAsync( e => e.FinderNumber == dto.PromoCode && e.EventId == dto.EventId); var d = Mapper.Map <Guest>(dto); if (guest != d) { var demo = new DemographicChange() { LookupId = dto.LookupId, FinderNumber = dto.PromoCode, Name = dto.Name, Email = dto.Email, Phone = dto.Phone, Street = dto.Address, Street2 = dto.Address2, City = dto.City, State = dto.State, Zipcode = dto.Zipcode, Source = Source.RSVP }; _context.DemographicChanges.AddOrUpdate(demo); _context.SaveChanges(); } Mapper.Map(dto, guest); @event.RegisterGuest(guest); await @event.SendEmail(guest); _context.Events.AddOrUpdate(@event); _context.Guests.AddOrUpdate(guest); _context.SaveChanges(); var model = Mapper.Map <FinishFormViewModel>(guest); var template = @event.Template; model.Template = TemplateHelper.ParseGuestTemplate(guest, template); return(View("Finish", model)); }
public IActionResult Register(RegisterFormViewModel user) { User newUser = new User { Username = user.Username, Password = user.Password }; _context.Users.Add(newUser); _context.SaveChanges(); return(RedirectToAction("Login", "Account")); }
public RegisterFormViewModel GetRegisterFormView( int currentPageId, RegisterFormViewModel model) { var regions = _userRepository.GetAllRegions(); model.RegionSelectList = new MultiSelectList(regions, "Key", "Value", regions.Take(1)); model.Agreements = _userRepository.GetAllActiveAgreements(); model.CurrentUmbracoPageId = currentPageId; model.CurrentPageCulture = Thread.CurrentThread.CurrentCulture; return(model); }
public async Task RegisterAsync() { var form = _form; var result = await _apiClient.PostJsonAsync <RegisterFormViewModel>(ApiUrls.RegisterAction, form); if (!result) { MessageBox.Show("Cannot register an user."); return; } MessageBox.Show("Registration succeeded. Please sign in."); _form = new RegisterFormViewModel(); ChangePageCommand.Execute(this); }
public RegisterResponse Register(RegisterFormViewModel model) { try { var errors = ValidateUser(model.UserEmail, model.SelectedRegions, model.Agreements, isNew: true); if (errors.Any()) { return new RegisterResponse { IsError = true, ShouldDisplayMessage = true, Message = _umbracoHelper.GetDictionaryValue("Register.SendEmail.Failure"), ValidationErrors = errors } } ; var user = _mappingService.Map <RegisterFormViewModel, UserDB>(model); user.UserPassword = _hashingService.Hash(model.UserPassword); user.ActivationToken = GenerateActivationToken(); user.Locale = model.CurrentPageCulture.Name; if (!errors.Any()) { _userRepository.Insert(user, model.SelectedRegions, model.Agreements); _emailService.SendRegisterEmail(user); } return(new RegisterResponse { IsError = false, Message = _umbracoHelper.GetDictionaryValue("Register.SendEmail.Success"), ShouldDisplayMessage = true, ValidationErrors = errors }); } catch (Exception exception) { Log.Error("Error during registering new account", exception); return(new RegisterResponse { IsError = true, Message = exception.Message, ShouldDisplayMessage = true, ValidationErrors = new List <KeyValuePair <string, string> >() }); } }
public ActionResult SubmitRegisterForm(RegisterFormViewModel model) { SetCulture(model.CurrentPageCulture); if (ModelState.IsValid) { model.Response = _accountService.Register(model); if (model.Response.IsError && model.Response.ValidationErrors.Any()) { MapErrorsToModelState(model.Response.ValidationErrors); } } model = _accountService.GetRegisterFormView(model.CurrentUmbracoPageId, model); return(PartialView("RegisterFormPartial", model)); }
public HttpResponse Register(RegisterFormViewModel input) { if (this.IsUserLoggedIn()) { return(this.Redirect("/")); } if (input.Username.Length < 4 || input.Username.Length > 10) { // return this.Error("Username should be between 4 and 20 characters!"); return(this.Redirect("Register")); } if (input.Password.Length < 6 || input.Password.Length > 20) { //return this.Error("Password should be between 6 and 20 characters!"); return(this.Redirect("Register")); } if (input.Password != input.ConfirmPassword) { //return this.Error("Password should match."); return(this.Redirect("Register")); } if (string.IsNullOrWhiteSpace(input.Email)) { //return this.Error("Email cannot be empty!"); return(this.Redirect("Register")); } if (this.usersService.EmailExists(input.Email)) { //return this.Error("Email already in use."); return(this.Redirect("Register")); } if (this.usersService.UsernameExists(input.Username)) { //return this.Error("Username already in use."); return(this.Redirect("Register")); } this.usersService.CreateUser(input.Username, input.Email, input.Password); return(this.Redirect("Login")); }
public async Task <ActionResult> Registration(RegisterFormViewModel model) { try { if (ModelState.IsValid) { var identityUser = new IdentityUser { UserName = model.UserName, Address = model.Address, FirstName = model.FirstName, LastName = model.LastName, MiddleName = model.MiddleName, Phone = model.Phone, Email = model.Email, City = model.City, State = model.State, IsLockedOut = false, IsSuperAdmin = false, Created = DateTime.UtcNow }; var identityResult = await UserManager.CreateAsync(identityUser, model.Password); if (identityResult.Succeeded) { ModelState.AddModelError("", "Đăng ký tài khoản thành công."); } else { var sb = new StringBuilder(); foreach (var item in identityResult.Errors) { sb.Append(item); } ModelState.AddModelError("", sb.ToString()); //ModelState.AddModelError("", "Đăng ký tài khoản không thành công, Vui lòng thử lại."); } } } catch (Exception ex) { ModelState.AddModelError("Error", ex.Message); } return(View(model)); }
public async Task <IActionResult> Register([FromBody] RegisterFormViewModel model) { if (ModelState.IsValid) { var user = new User { UserName = model.Username, Name = model.Name, Surname = model.Surname }; var result = await _userManager.CreateAsync(user, model.Password); if (result.Succeeded) { return(Ok()); } } return(BadRequest()); }
public ActionResult Index(int?eventId) { if (eventId.HasValue) { using (var db = new DataLayer.RegistrationDbContext()) { var evenx = db.Events.Find(eventId.Value); if (evenx == null) { return(View("Error")); } var m = new RegisterFormViewModel(); m.EventId = eventId.Value; ViewBag.EventTitle = evenx.EName; return(View(m)); } } return(View("Error")); }
public async Task <IActionResult> Edit(string Id) { if (Id == null) { return(RedirectToAction(nameof(Error), new { message = "Id nulo" })); } var obj = await _userManager.FindByIdAsync(Id); if (obj == null) { return(RedirectToAction(nameof(Error), new { message = "Id não encontrado" })); } var viewModel = new RegisterFormViewModel { Id = obj.Id, Cpf = obj.Cpf, Email = obj.Email, EmailConf = obj.Email, Name = obj.Name, PhoneNumber = obj.PhoneNumber, UserName = obj.UserName }; return(View(viewModel)); }
public async Task <IActionResult> Edit(RegisterFormViewModel viewModel) { var user = await _userManager.FindByIdAsync(viewModel.Id); user.UserName = viewModel.UserName; user.Email = viewModel.Email; user.Cpf = viewModel.Cpf; user.PhoneNumber = viewModel.PhoneNumber; user.Name = viewModel.Name; var result = await _userManager.UpdateAsync(user); if (result.Succeeded) { TempData["confirm"] = user.UserName + " atualizado com sucesso."; return(RedirectToAction(nameof(Index))); } TempData["erro"] = "Não foi possível atualizar"; return(RedirectToAction(nameof(Index))); }
public HttpResponse Register(RegisterFormViewModel input) { if (this.IsUserLoggedIn()) { return(this.Redirect("/")); } if (input.Username.Length < 5 || input.Username.Length > 20) { return(this.Redirect("Register")); } if (input.Password.Length < 6 || input.Password.Length > 20) { return(this.Redirect("Register")); } if (input.Email != input.Email) { return(this.Redirect("Register")); } if (string.IsNullOrWhiteSpace(input.Password)) { return(this.Redirect("Register")); } if (this.usersService.EmailExists(input.Email)) { return(this.Redirect("Register")); } if (this.usersService.UsernameExists(input.Username)) { return(this.Redirect("Register")); } this.usersService.CreateUser(input.Username, input.Email, input.Password); return(this.Redirect("Login")); }
public async Task <IActionResult> Register([FromBody] RegisterFormViewModel model) { if (model == null || !this.ModelState.IsValid) { return(this.BadRequest(this.ModelState.GetFirstError())); } var user = new User { Email = model.Email, UserName = model.Username }; var result = await this.userManager.CreateAsync(user, model.Password); if (!result.Succeeded) { return(this.BadRequest(result.Errors.FirstOrDefault())); } this.logger.LogInformation("User registered."); return(this.Ok()); }