public ActionResult Signup(SignupViewModel signup) { if (!ModelState.IsValid) { return(new ShapeResult(this, _services.New.Checkout_Signup(Signup: signup))); } var customer = _customerService.CreateCustomer(signup.Email, signup.Password); customer.FirstName = signup.FirstName; customer.LastName = signup.LastName; customer.Title = signup.Title; _authenticationService.SignIn(customer.User, true); return(RedirectToAction("SelectAddress")); }
public async Task <IActionResult> Signup(SignupViewModel model) { if (ModelState.IsValid) { if (!(await _roleManager.RoleExistsAsync(model.Role))) { var role = new IdentityRole { Name = model.Role }; var roleResult = await _roleManager.CreateAsync(role); if (!roleResult.Succeeded) { var errors = roleResult.Errors.Select(s => s.Description); ModelState.AddModelError("Role", string.Join(",", errors)); return(View(model)); } } if ((await _userManager.FindByEmailAsync(model.Email)) == null) { var user = new IdentityUser { Email = model.Email, UserName = model.Email }; var result = await _userManager.CreateAsync(user, model.Password); if (result.Succeeded) { var claim = new Claim("Department", model.Department); await _userManager.AddClaimAsync(user, claim); await _userManager.AddToRoleAsync(user, model.Role); return(RedirectToAction("Signin")); } ModelState.AddModelError("Signup", string.Join("", result.Errors.Select(x => x.Description))); return(View(model)); } } return(View(model)); }
public async Task ShouldNotSignupWithEmailAlreadyTaken() { var server = new ServerFake(); var user = server.AppDbContext.CreateUser(); var viewModel = new SignupViewModel { Name = "Another", Email = user.Email, Password = UserFactory.Password }; var response = await server.CreateClient().PostAsJsonAsync("signup", viewModel); var errors = await response.Content.ReadAsJsonAsync <List <string> >(); var expectedErrors = new [] { "E-mail já cadastrado." }; Assert.Equal((HttpStatusCode)422, response.StatusCode); Assert.Equal(errors.OrderBy(e => e), expectedErrors.OrderBy(e => e)); Assert.False(server.Mailer.EmailSent); }
public async Task <IActionResult> Signup([FromBody] SignupViewModel viewModel) { try { await _accountService.Signup(viewModel); return(Ok()); } catch (ArgumentException) { return(BadRequest()); } catch (Exception) { return(StatusCode(StatusCodes.Status500InternalServerError)); } }
public ActionResult FeedbackPost(SignupViewModel input) { if (input == null) { return(Json(CommandResponse.Fail.SetMessage("Invalid input"))); } if (input.Name.IsNullOrWhitespace()) { return(Json(CommandResponse.Fail.SetMessage("Name is missing"))); } var outcome = (DateTime.Now.Second % 2) > 0 ? CommandResponse.Ok.SetMessage("Welcome to the team!") : CommandResponse.Fail.SetMessage("Oops! Something went unexpectedly wrong."); return(Json(outcome)); }
public ActionResult Signup(SignupViewModel model) { if (ModelState.IsValid) { var newUser = Mapper.Map <UserDto> (model); newUser.RoleId = (int)Roles.ApprovedMember; bool result = _userService.CreateUser(newUser); if (result) { return(Redirect(Url.Action("Login", "Account"))); } ModelState.AddModelError("", "Login is already taken"); } return(View()); }
public async Task <Users> CreateUserAsync(SignupViewModel signp) { return(await Task.Run(() => { return new Users() { ActiveCode = Guid.NewGuid().GetHashCode().ToString().Replace("-", "").Substring(4, 4), ActiveDate = DateTime.Now, Email = signp.Email, IsConfirm = false, Password = signp.Password.CreateSHA256(), PhoneNumber = signp.PhoneNumber, UserName = signp.UserName, UserId = Guid.NewGuid() }; })); }
public async Task Signup(SignupViewModel viewModel) { var user = _context.Users.SingleOrDefault(u => u.Email == viewModel.Email); if (user != null) { throw new ArgumentException(); } var salt = AuthHelper.CreateSalt(128); var passwordHash = AuthHelper.CreateHash(viewModel.Password, salt); var newUser = new User(viewModel.Email, passwordHash, salt, viewModel.FirstName, viewModel.LastName, null); _context.Users.Add(newUser); await _context.SaveChangesAsync(); }
public string Signup([FromBody] SignupViewModel signupData) { Boolean success = AccountService.Signup(signupData); if (success) { return(Login(new LoginViewModel() { Email = signupData.Email, Password = signupData.Password })); } else { return new RequestResult() { State = RequestState.Failed } }.Serialize();
public static void SignUp(SignupViewModel svm) { if (AuthController.SignUp(svm)) { LogIn(new LoginViewModel { Email = svm.Email, Password = svm.Password }); SignUpForm.Close(); } else { MessageBox.Show("Could not register you with these credentials.", "Authentication error", MessageBoxButtons.OK, MessageBoxIcon.Error); } }
public IActionResult SignUp() { var authResponse = HttpContext.Session.Get <AuthenticationResponse>("AuthenticationResponse"); if (authResponse == null) { return(RedirectToAction("Authenticate", "Login")); } var viewModel = new SignupViewModel { SystemID = authResponse.systemID, UserName = authResponse.userName, }; return(View(viewModel)); }
public JsonResult PostSignup(SignupViewModel model) { if (model == null) { return(Json(null)); } if (ModelState.IsValid) { model.SaveModel(); var jsonResult = Json(model, JsonRequestBehavior.AllowGet); jsonResult.MaxJsonLength = int.MaxValue; return(jsonResult); } else { return(Json(null)); } }
public async Task <IActionResult> Index(SignupViewModel model) { var user = new ApplicationUser { UserName = model.UserName, Email = model.Email }; IdentityResult result = await _userManager.CreateAsync(user, model.Password); if (result.Succeeded) { user.AddToMailingList(); user.MailingList = true; return(View("Index", "You've been added to the mailing list!")); } else { return(View()); } }
public async Task <IActionResult> Signup([FromBody] SignupViewModel signupVM) { var user = new ApplicationUser() { Name = signupVM.Username, UserName = signupVM.Email, Email = signupVM.Email, BirthDate = signupVM.BirthDate, Gender = signupVM.Gender, UserType = signupVM.UserRole }; var result = await _userManager.CreateAsync(user, signupVM.Password); if (result.Succeeded) { //Email Token For Email Confirmation string confirmationToken = _userManager.GenerateEmailConfirmationTokenAsync(user).Result; string confirmationTokenLink = Url.Action("EmailConfirmed", "Accounts", new { userId = user.Id, token = confirmationToken }, protocol: HttpContext.Request.Scheme); //Adding User Claim await _userManager.AddClaimAsync(user, new Claim(signupVM.UserRole, "True")); //Send Email With Confirmation Token . try { _emailSender.AccountConfirmationEmail(user.Email, confirmationTokenLink); } catch (Exception ex) { string error = ex.Message; } return(Ok(new { Status = "Success" })); } return(Ok(new { Status = "Failed", Errors = result.Errors.Where(e => e.Code != "DuplicateUserName") })); }
public async Task <IActionResult> SignUp(SignupViewModel signUp) { SignUpResponse result = await _account.SignUpAsync(signUp); switch (result) { case SignUpResponse.Success: return(Ok(new { Id = 0, Title = "Success Go To Active Account", Result = new { } })); case SignUpResponse.Exception: return(Ok(new { Id = -2, Title = "Exception", Result = new { } })); case SignUpResponse.UserAlreadyExist: return(Ok(new { Id = -3, Title = "User Already Exist", Result = new { } })); default: goto case SignUpResponse.Exception; } }
public ActionResult Signup(SignupViewModel user) { if (ModelState.IsValid) { using (ISession session = DBConnect.OpenUserSession()) { using (ITransaction tx = session.BeginTransaction()) { User qUserU = new User(); User qUserE = new User(); qUserU = session.Query <User>() .Where(x => x.Username == user.Username) .FirstOrDefault(); qUserE = session.Query <User>() .Where(x => x.Email == user.Email) .FirstOrDefault(); if (qUserU != null || qUserE != null) { if (qUserU != null) { ModelState.AddModelError("Username", "Username has been taken."); } if (qUserE != null) { ModelState.AddModelError("Email", "There exists an account with this email address."); } return(View()); } else { user.RoleId = "user"; user.Id = Guid.NewGuid(); user.Salt = CreateSalt(10); user.HashedPass = GenerateSHA256(user.Password, user.Salt); session.Save(user); tx.Commit(); return(RedirectToAction("Index", "Home")); } } } } return(View()); }
public async Task <IActionResult> Create([Bind("DisplayName,Email,Password")] SignupViewModel args) { args.PasswordHash = BCrypt.Net.BCrypt.HashPassword(args.Password); User user = new User { DisplayName = args.DisplayName, Email = args.Email, Password = args.PasswordHash }; _context.Add(user); await _context.SaveChangesAsync(); user = _context.Users.Single(u => u.Email.Equals(user.Email)); await this.Login(user); return(RedirectToAction("Index", "")); }
public IActionResult Signup(SignupViewModel model) { if (User.Identity.IsAuthenticated) { return(Redirect("/")); } var succeed = _cetUserService .Signup(model.UserName, model.Password, model.Email, model.FirstName, model.LastName); if (succeed) { return(RedirectToAction("Signin")); } else { return(RedirectToAction("Signup", new { error = "signup" })); } }
public ActionResult Signup(SignupViewModel memberData) { try { if (ModelState.IsValid) { bool valid = ValidateSignup(memberData); if (!valid) { return(View()); } Member member = new Member(); member.username = memberData.UserName; member.email = memberData.Email; member.created_at = DateTime.Now; string hashedPass = Security.GenerateMd5(memberData.Password); member.password = hashedPass; member.is_active = false; member.confirm_token = Security.Encrypt("OMAR*" + member.username + "*" + member.created_at + "*" + memberData.Password, true); rpMember.Insert(member); //Send verification link to email string activationUrl = Url.Action("ConfirmSignup", "Member", new { token = member.confirm_token }, "http"); NotifyMember.AccountActivation(member.email, activationUrl); return(View("Success", new MessageView() { Message = "We sent a link to " + member.email + " to activate your account." })); } else { ModelState.AddModelError("", "There is an error in the input data, try again."); } } catch (Exception e) { } return(View()); }
public ActionResult Add(SignupViewModel model) { if (ModelState.IsValid) { var newUser = Mapper.Map <SimpleSocialNetwork.Domain.User>(model); newUser.RoleId = (int)Roles.Moderator; bool result = _userService.CreateUser(newUser); if (result) { return(Redirect(Url.Action("Index", "Admin"))); } else { ModelState.AddModelError("", "Login is already taken"); } } return(View()); }
public async Task <UserViewModel> CreateAsync(SignupViewModel model, CancellationToken ct) { var existingUser = await _userRepository.GetByEmailAsync(model.Email, ct : ct); if (existingUser is not null) { return(null); } var user = model.Adapt <User>(); var secret = PasswordSecret.Create(model.Password); user.Name ??= user.Email; user.PasswordHash = secret.Hash; user.Salt = secret.Salt; var createdUser = await _userRepository.CreateAsync(user, ct); return(createdUser.Adapt <UserViewModel>()); }
public ActionResult Identify(SignupViewModel model) { if (ModelState.IsValid) { if (model.Name == "The Man") { ModelState.AddModelError("Name", "No, there can only be one 'The man', and you are not it."); } } if (ModelState.IsValid) { var cookie = new HttpCookie("name", model.Name); cookie.Expires = DateTime.Now.AddYears(1); Response.Cookies.Add(cookie); return(RedirectToAction("Index")); } return(View(model)); }
public IActionResult Signup(SignupViewModel signupViewModel) { MyIdentityUser user = new MyIdentityUser() { Email = signupViewModel.Email, UserName = signupViewModel.Email }; IdentityResult result = _userManager.CreateAsync(user, signupViewModel.Password).Result; if (result.Succeeded) { _signInManager.SignInAsync(user, true); return(RedirectToAction("Index", "Home")); } else { return(Content("User account creation failed: " + result.Errors.First().Description)); } }
public async Task <IActionResult> Signup(SignupViewModel signupViewModel) { if (ModelState.IsValid) { SignupViewModel vModel = new SignupViewModel(); SignupBO bo = new SignupBO(_pool, _userManager); vModel = await bo.CreateUser(signupViewModel); if (!vModel.IsValid) { ModelState.AddModelError("Signup", vModel.Message); return(View(vModel)); } else { RedirectToAction("Confirm"); } } return(View()); }
public IActionResult Signup(string username, string password, string repeatPassword) { var errors = new List <string>(); if (username == null || username.Length == 0) { errors.Add("Username is required."); } else if (_gymDb.Users.ToList().Find(user => user.Login == username) != null) { return(View(SignupViewModel.newErrorInstance("A user with that name already exists"))); } else if (username.Length < 3) { errors.Add("Username too short."); } if (password == null || password.Length == 0) { errors.Add("Password is required."); } else if (password.Length < 8) { errors.Add("Password too short."); } else if (password != repeatPassword) { errors.Add("Different passwords were provided."); } if (errors.Count > 0) { return(View(SignupViewModel.newErrorInstance(string.Join(' ', errors)))); } else { var user = new User(username, Cypher.sha256Hash(password)); _gymDb.Users.Add(user); _gymDb.SaveChanges(); return(View(SignupViewModel.newSuccessInstance(username))); } }
public async Task <IActionResult> Signup(SignupViewModel signup, string ReturnUrl) { if (ModelState.IsValid) { var user = new ApplicationUser { UserName = signup.CustomerEmail, Email = signup.CustomerEmail, PhoneNumber = signup.CustomerPhone, Address = signup.CustomerAddress, Fullname = signup.CustomerName }; var result = await _userManager.CreateAsync(user, signup.Password); if (result.Succeeded) { var newUser = await _userManager.FindByEmailAsync(user.Email); var addToRole = await _userManager.AddToRoleAsync(newUser, "User"); var token = await _userManager.GenerateEmailConfirmationTokenAsync(newUser); //var confirmationLink = Url.Action("ConfirmEmail", "Identity", // new { userId = user.Id, token = token }, Request.Scheme); return(RedirectToAction("SendEmailConfirm", new { userId = user.Id, token = token })); //await _signInManager.SignInAsync(user, isPersistent: false); //if (!string.IsNullOrEmpty(ReturnUrl)) //{ // return Redirect(ReturnUrl); //} //else //{ // return RedirectToAction("Index", "Home", new { Area = "Client" }); //} } foreach (var error in result.Errors) { ModelState.AddModelError("", error.Description); } } return(RedirectToAction("login", signup)); }
internal static string SaveUserDetails(SignupViewModel model, bool isNewUser) { using (var context = GetMMBContext()) { if (Convert.ToBoolean(model.FirstName.Length) && Convert.ToBoolean(model.Password.Length) && Convert.ToBoolean(model.Email.Length) && Convert.ToBoolean(model.Username.Length)) { if (model.Password == model.ConfirmPassword) { var userDetails = context.User.Where(r => r.Username == model.Username && r.Email == model.Email); if (userDetails.Any()) { return("Duplicate"); //username or email already exists } else { var userEntity = UserEntity(); userEntity.FirstName = model.FirstName; userEntity.LastName = model.LastName; userEntity.UserPassword = model.Password; userEntity.RecordStatus = 0; //currently inactive account userEntity.IsAdmin = 0; userEntity.CreatedOn = DateTime.UtcNow; userEntity.LastUpdatedOn = DateTime.UtcNow; userEntity.ResetPasswordKey = ""; userEntity.Email = model.Email; userEntity.Username = model.Username; context.User.Add(userEntity); context.SaveChanges(); return("Success"); } } } else { //all fields are not filled return("KnownFailure"); } } return("Failed"); }
public async Task IShouldCanCreateAUser() { // Prepare var userViewModel = new SignupViewModel { Email = "*****@*****.**", Password = "******" }; var userResponse = new SignupViewModel { Email = "*****@*****.**", Password = null }; var mockForDomainUserService = new Mock <IUserService>(); mockForDomainUserService.Setup(service => service.GetUserByEmail(It.IsAny <string>())) .ReturnsAsync(null as User) .Verifiable(); var mockForApplicationUserService = new Mock <IUserApplicationService>(); mockForApplicationUserService.Setup(service => service.CreateUser(userViewModel)) .ReturnsAsync(userResponse) .Verifiable(); var controller = new UserController( mockForDomainUserService.Object, mockForApplicationUserService.Object, null, null); // Action var result = await controller.Create(userViewModel); // Assert Assert.IsInstanceOfType(result, typeof(ActionResult <SignupViewModel>)); Assert.AreEqual(userResponse, result.Value); Assert.AreEqual(userResponse.Password, null); mockForDomainUserService.VerifyAll(); mockForApplicationUserService.VerifyAll(); }
public async Task IShouldCanCreateAUser() { var userToCreate = new User { Id = "asdf798asdfas-asjkdhrjkwer8", Email = "*****@*****.**" }; var viewModel = new SignupViewModel { Email = "*****@*****.**" }; var viewModelResult = new SignupViewModel { Email = "*****@*****.**" }; var mockForDomainService = new Mock <IUserService>(); mockForDomainService.Setup(service => service.CreateUser(It.IsAny <User>(), It.IsAny <string>())) .ReturnsAsync(userToCreate) .Verifiable(); var mockForMapper = new Mock <IMapper>(); mockForMapper.Setup(m => m.Map <User>(It.IsAny <SignupViewModel>())) .Returns(userToCreate) .Verifiable(); mockForMapper.Setup(m => m.Map <SignupViewModel>(It.IsAny <User>())) .Returns(viewModelResult) .Verifiable(); var service = new UserApplicationService(mockForMapper.Object, mockForDomainService.Object); var result = await service.CreateUser(viewModel); Assert.AreEqual(viewModelResult, result); mockForDomainService.VerifyAll(); mockForMapper.VerifyAll(); }
public ActionResult Signup(SignupViewModel viewModel) { //Declare redirect path variables: string redirect_action; string redirect_controller; //Verify the user's password and confirmPassword are the same, else GET OUT! if (viewModel.Password == viewModel.ConfirmPassword) { //Create a new user: try { IUserMapper user = users_bll.Insert(new UserMapper { Name = viewModel.Name, RoleName = "user", password_hash = viewModel.Password }); //Set the session to log the user in: setSessionData(user); //redirect path variables: redirect_action = "Index"; redirect_controller = "Dashboard"; } catch (SqlBLLException) { //redirect path variables: redirect_action = "Signup"; redirect_controller = "Authentication"; TempData["ErrorMessage"] = "The username you entered already exists."; } } else { //redirect path variables: redirect_action = "Signup"; redirect_controller = "Authentication"; TempData["ErrorMessage"] = "The password you entered must match in both fields."; } //Redirect to the dashboard (protected page): return(RedirectToAction(redirect_action, redirect_controller)); }
public ActionResult HtmlHelpers(SignupViewModel vm) { return View(vm); }
public ActionResult ChameleonForms(SignupViewModel vm) { return View(vm); }
public ActionResult EditorTemplates(SignupViewModel vm) { return View(vm); }
private string _signupurl = "http://idea-bag.com/authentication/signupstandarduser";//"http://idea-bag.com/authentication/echoposttest";// #endregion #region Constructor public SignupViewController (IntPtr handle) : base (handle) { this._viewmodel = new SignupViewModel (_signupurl); this._viewmodel.OnSignupCompleted += HandleSignupCompleted; }