public async Task <IActionResult> SignUp(SignupModel model) { if (ModelState.IsValid) { var user = _pool.GetUser(model.EmailAddress); if (user.Status != null) { ModelState.AddModelError("UserExists", "User with this email already exists"); } else { user.Attributes.Add(CognitoAttribute.Name.AttributeName, model.EmailAddress); var createdUser = await _userManager.CreateAsync(user, model.Password); if (createdUser.Succeeded) { //await _signinManager.SignInAsync(user, true); return(RedirectToAction("Confirm")); } else { foreach (var item in createdUser.Errors) { ModelState.AddModelError(item.Code, item.Description); } } } } return(View(model)); }
public async Task <IActionResult> Signup(SignupModel model) { try { if (ModelState.IsValid) { CognitoUser user = _pool.GetUser(model.Email); if (user.Status != null) { ModelState.AddModelError("UserExists", "User with this email already exists"); return(View(model)); } //user.Attributes.Add(CognitoAttributesConstants.Name, model.Email); user.Attributes.Add(CognitoAttribute.Name.AttributeName, model.Email); user.Attributes.Add(CognitoAttribute.Email.AttributeName, model.Email); IdentityResult createdUser = await _userManager.CreateAsync(user, model.Password).ConfigureAwait(false); if (createdUser.Succeeded) { return(RedirectToAction("Confirm")); } else { ModelState.AddModelError("createdUserError", string.Join <string>(" - ", createdUser.Errors.Select(error => error.Description).ToList())); } } } catch (Exception ex) { ModelState.AddModelError("Somne kind of error", ex.Message); } return(View(model)); }
public async Task <IActionResult> Forgot(ForgotModel model) { if (ModelState.IsValid) { var user = _pool.GetUser(model.Email); if (user != null) { await user.ForgotPasswordAsync(); } } return(View(model)); }
public async Task <IActionResult> SignUp(SignUpModel model) { if (!ModelState.IsValid) { return(View()); } var user = _pool.GetUser(model.Email); if (user.Status != null) { ModelState.AddModelError("SignUpError", "User already exists."); return(View(model)); } user.Attributes.Add("name", model.Email); var createdUser = await _userManager.CreateAsync(user, model.Password).ConfigureAwait(false); if (!createdUser.Succeeded) { ModelState.AddModelError("SignUpError", "Unable to create account."); return(View(model)); } return(RedirectToAction("Confirm")); }
public async Task <IActionResult> Create([FromForm] RegisterViewModel model) { IActionResult result = View(); if (ModelState.IsValid) { var user = _userPool.GetUser(model.Email); user.Attributes.Add(CognitoAttribute.Email.AttributeName, model.Email); user.Attributes.Add(CognitoAttribute.GivenName.AttributeName, model.FirstName); user.Attributes.Add(CognitoAttribute.FamilyName.AttributeName, model.LastName); user.Attributes.Add(CognitoAttribute.Name.AttributeName, $"{model.FirstName} {model.LastName}"); user.Attributes.Add(CognitoAttribute.PhoneNumber.AttributeName, $"+1{model.PhoneNumber}"); var createResult = await _userManager.CreateAsync(user, model.Password); if (createResult.Succeeded) { await _signInManager.SignInAsync(user, isPersistent : false); result = RedirectToAction(nameof(Confirm)); } else { foreach (var error in createResult.Errors) { ModelState.AddModelError(string.Empty, error.Description); } } } return(result); }
public async Task <IActionResult> Signup(SignupViewModel model) { if (ModelState.IsValid) { var user = _pool.GetUser(model.Email); if (user.Status != null) { ModelState.AddModelError("UserExists", "User with this email already exists"); return(View(model)); } user.Attributes.Add(nameof(CognitoAttribute.Name).ToLower(), model.Email); var createdUser = await _userManager.CreateAsync(user, model.Passport); if (!createdUser.Succeeded) { foreach (var item in createdUser.Errors) { ModelState.AddModelError(item.Code, item.Description); } } if (createdUser.Succeeded) { return(await Task.Run(() => RedirectToAction("Index", "Home"))); } } return(View()); }
public async Task <IActionResult> Signup(SignupViewModel model) { if (!ModelState.IsValid) { return(View()); } var user = _pool.GetUser(model.Email); if (user.Status != null) { ModelState.AddModelError("UserExists", "User with this email already exists"); return(View(model)); } user.Attributes.Add("name", model.Email); var createdUser = await _userManager.CreateAsync(user, model.Password); if (createdUser.Succeeded) { RedirectToAction("Confirm"); } return(View()); }
public async Task <IActionResult> OnPostAsync(string returnUrl = null) { returnUrl = returnUrl ?? Url.Content("~/"); if (ModelState.IsValid) { var user = _pool.GetUser(Input.UserName); user.Attributes.Add(CognitoAttributesConstants.Email, Input.Email); var result = await _userManager.CreateAsync(user, Input.Password); if (result.Succeeded) { _logger.LogInformation("User created a new account with password."); await _signInManager.SignInAsync(user, isPersistent : false); return(RedirectToPage("./ConfirmAccount")); } foreach (var error in result.Errors) { ModelState.AddModelError(string.Empty, error.Description); } } // If we got this far, something failed, redisplay form return(Page()); }
public async Task <IActionResult> SignUp(SignUpModel model) { if (ModelState.IsValid) { var user = _cognitoUserPool.GetUser(model.Email); if (user.Status != null) { ModelState.AddModelError("UserExist", "User with this email is already exist."); return(View(model)); } ; AttributeType emailAttribute = new AttributeType() { Name = "email", Value = model.Email }; user.Attributes.Add(CognitoAttribute.Name.AttributeName, model.Email); var createdUser = await _userManager.CreateAsync(user, model.Password); if (createdUser.Succeeded) { return(RedirectToAction("Confirm")); } } return(View()); }
public async Task <IActionResult> Signup(SignUpModel model) { if (ModelState.IsValid) { var user = _pool.GetUser(model.Email); if (user.Status != null) { ModelState.AddModelError("UserExists", "User with this email alreadt exists"); } else { user.Attributes.Add("name", model.Email); var createdUser = await _userManager.CreateAsync(user, model.Password); if (createdUser.Succeeded) { return(RedirectToAction("Confirm")); } else { foreach (var error in createdUser.Errors) { ModelState.AddModelError(error.Code, error.Description); } } } } return(View(model)); }
public async Task <IActionResult> Signup(SignupModel model) { if (ModelState.IsValid) { var user = _pool.GetUser(model.Email); if (user.Status != null) { ModelState.AddModelError("UserExists", "User with this email already exists."); return(View(model)); } user.Attributes.Add(CognitoAttribute.Name.ToString(), model.Email); var createdUser = await _userManager.CreateAsync(user, model.Password); if (createdUser.Succeeded) { return(RedirectToAction("Confirm")); //RedirectToPage("./Confirm"); } } return(View()); }
public async Task <IActionResult> SignUp(SignUpViewModel model) { if (User.Identity.IsAuthenticated) { return(RedirectToAction("Index", "Home")); } if (ModelState.IsValid) { var user = _userPool.GetUser(model.Email); if (user.Status != null) { ModelState.AddModelError("UserExists", "User with this email exists"); return(View(model)); } user.Attributes.Add(CognitoAttribute.Name.AttributeName, model.Email); var result = await(_userManager as CognitoUserManager <CognitoUser>) .CreateAsync(user, model.Password); if (result.Succeeded) { return(RedirectToAction("Confirm")); } foreach (var item in result.Errors) { ModelState.AddModelError(item.Code, item.Description); } } return(View(model)); }
public async Task <IActionResult> SignUp(SignUpViewModel model) { try { if (ModelState.IsValid) { var user = _pool.GetUser(model.Email); if (user.Status != null) { ModelState.AddModelError("UserExists", "User with this email already exists"); return(View(model)); } var cognitoAttributeName = CognitoAttribute.Name.AttributeName; user.Attributes.Add(cognitoAttributeName, model.Email); var createdUser = await _userManager.CreateAsync(user, model.Password).ConfigureAwait(false); if (createdUser.Succeeded) { return(RedirectToAction("Confirm")); } } return(View(model)); } catch (Exception ex) { throw ex; } }
public async Task <IActionResult> SignupPost(SignupModel model) { if (ModelState.IsValid) { var user = _pool.GetUser(model.Email); if (user.Status != null) { ModelState.AddModelError("UserExists", "User with this email already exists"); return(View(model)); } user.Attributes.Add(CognitoAttribute.Email.AttributeName, model.Email); user.Attributes.Add(CognitoAttribute.Name.AttributeName, model.Email); Dictionary <string, string> validationData = new Dictionary <string, string>(StringComparer.Ordinal) { { CognitoAttribute.Email.AttributeName, model.Email }, { CognitoAttribute.Name.AttributeName, model.Email }, }; var createdUser = await((CognitoUserManager <CognitoUser>)_userManager).CreateAsync(user, model.Password, validationData); if (createdUser.Succeeded) { return(RedirectToAction("Confirm")); } } return(View(model)); }
public async Task <IActionResult> Signup(SignUpModel model) { if (ModelState.IsValid) { var user = _cognitoUserPool.GetUser(model.Email); if (user.Status != null) { ModelState.AddModelError(nameof(SignUpModel.Email), "User already exists"); return(View(model)); } //Name is required field user.Attributes.Add("name", model.Email);//CognitoAttributesConstants.Name //var result1 = await _cognitoUserManager.CreateAsync(user, model.Password); var result = await _userManager.CreateAsync(user, model.Password); if (result.Succeeded) { return(RedirectToAction("Confirm", new ConfirmModel { Email = model.Email })); } } return(View(model)); }
public async Task <IActionResult> SignUp(Signup model) { if (ModelState.IsValid) { var user = pool.GetUser(model.Email); if (user.Status != null) // user exists { ModelState.AddModelError("UserExists", "User with this email already exists"); return(View(model)); } try { user.Attributes.Add("name", model.Email); var createdUser = await userManager.CreateAsync(user, model.Password).ConfigureAwait(false); if (createdUser.Succeeded) { return(RedirectToAction("Confirm")); } } catch (Exception ex) { ModelState.AddModelError("Signup", "Unable to create new user"); ModelState.AddModelError("SignupUnhandleError", ex.Message); } } return(View("Signup", model)); }
public async Task <IActionResult> Signup(SignupModel model) { if (!ModelState.IsValid) { return(View(model)); } var user = _userPool.GetUser(model.Email); if (user.Status != null) { ModelState.AddModelError("User Exists", "User with this email already exists"); return(View(model)); } user.Attributes.Add(CognitoAttribute.Name.AttributeName, model.Email); var result = await _userManager.CreateAsync(user, model.Password); if (!result.Succeeded) { foreach (var error in result.Errors) { ModelState.AddModelError(error.Code, error.Description); } return(View(model)); } return(RedirectToAction("Confirm")); }
public async Task <IActionResult> Signup(SignupModel model) { if (ModelState.IsValid) { var user = _cognitoUserPool.GetUser(model.Email); if (user.Status != null) { ModelState.AddModelError("UserExists", "User with this email already exists"); return(View(model)); } user.Attributes.Add(CognitoAttribute.Name.AttributeName, model.Email); var createdUser = await _userManager.CreateAsync(user, model.Password); if (createdUser.Succeeded) { return(RedirectToAction(nameof(Confirm), new { model.Email })); } else { createdUser.Errors.ToList().ForEach(e => ModelState.AddModelError(e.Code, e.Description)); } } return(View(model)); }
public async Task <IActionResult> Signup(SignupModel model) { try { if (ModelState.IsValid) { var user = _pool.GetUser(model.Email); if (user.Status != null) { ModelState.AddModelError("UserExists", "User with email mentioned already exists"); return(View(model)); } //user.Attributes.Add(CognitoAttribute.UserName.AttributeName, model.Email); var createdUser = await _userManager.CreateAsync(user, model.Password); if (createdUser.Succeeded) { return(RedirectToAction("Confirm")); } } } catch (Exception ex) { } return(View(model)); }
public async Task <IActionResult> Signup(SignupModel model) { if (ModelState.IsValid) { var user = _pool.GetUser(model.Email); if (user.Status != null) { ModelState.AddModelError("UserExists", "User with this email already exists"); return(View(model)); } user.Attributes.Add(CognitoAttribute.Name.AttributeName, model.Email); var createdUser = await _userManager.CreateAsync(user, model.Password).ConfigureAwait(false); if (createdUser.Succeeded) { await _signInManager.SignInAsync(user, isPersistent : false); return(RedirectToAction("Confirm")); } } return(View()); }
public async Task <IActionResult> SignUp(SignupModel model) { if (!ModelState.IsValid) { return(View()); } CognitoUser user = _pool.GetUser(model.Email); if (user.Status != null) { ModelState.AddModelError("UserExist", "User already exist!"); return(View(model)); } user.Attributes.Add(CognitoAttribute.Name.AttributeName, model.Email); IdentityResult createdUser = await _userManager.CreateAsync(user, model.Password); if (createdUser.Succeeded) { return(RedirectToAction("Confirm")); } return(View()); }
public async Task <IActionResult> Signup(SignupModel model) { if (ModelState.IsValid) { var user = _pool.GetUser(model.Email); if (user != null) { ModelState.AddModelError("UserExist", $"User with {model.Email} as already have account"); return(View(model)); } var result = await _userManager.CreateAsync(user, model.Email); if (result.Succeeded) { RedirectToAction("Confirm"); } else { foreach (var error in result.Errors) { ModelState.AddModelError(error.Code, error.Description); return(View(model)); } } } return(View(model)); }
public async Task <IActionResult> Signup(SignupModel model) { if (ModelState.IsValid) { CognitoUser user = _pool.GetUser(model.Email); if (user.Status != null) { ModelState.AddModelError("UserExists", "User with this email already exist"); return(View(model)); } user.Attributes.Add(CognitoAttributesConstants.Name, model.Email); user.Attributes.Add(CognitoAttributesConstants.BirthDate, model.Birthdate); var createdUser = await _userManager.CreateAsync(user, model.Password).ConfigureAwait(false); if (createdUser.Succeeded) { RedirectToAction("Confirm", "Accounts"); } else { foreach (var error in createdUser.Errors) { ModelState.AddModelError(string.Empty, error.Description); } } } return(View()); }
public async Task <IActionResult> Signup(SignUpModel model) { if (ModelState.IsValid) { var user = pool.GetUser(model.Email); if (user.Status != null) { ModelState.AddModelError("UserExists", "User with this email already exists"); return(View(model)); } user.Attributes.Add(CognitoAttribute.Name.AttributeName, model.Email); userManager.PasswordValidators.Clear(); var result = await userManager.CreateAsync(user, model.Password); if (result.Succeeded) { return(RedirectToAction("Confirm")); } else { foreach (var identityError in result.Errors) { ModelState.AddModelError(identityError.Code, identityError.Description); } } } return(View()); }
public async Task <SignupViewModel> CreateUser(SignupViewModel model) { try { var user = _pool.GetUser(model.Email); //We are using Email as userid. if (user.Status != null) { model.IsValid = false; model.Message = USER_EXISTS; return(model); } user.Attributes.Add(CognitoAttribute.Name.ToString(), model.Email); //We are using Email as name just to get started. var createdUser = await _userManager.CreateAsync(user, model.Password).ConfigureAwait(false); if (createdUser.Succeeded) { model.IsValid = true; model.Message = string.Format("{0} is created successfully.", model.Email); } return(model); } catch (Exception ex) { return(model); } }
public async Task <IActionResult> Signup(SignupModel model) { if (ModelState.IsValid) { var user = _pool.GetUser(model.Email); //try to get user from the user pool if (user.Status != null) // if user exists { ModelState.AddModelError("User Exists", "User with this email already exists."); return(View(model)); } /*user attributes should be set before trying to create but depends pool restrictions. * if the attributes are required and hasn't set, then you will get error. * * * dotnet core 3.0 preview * user.Attributes.Add(CognitoAttributesConstants.Name, model.Email); */ //Set user attirbutes user.Attributes.Add(CognitoAttribute.Email.AttributeName, model.Email); user.Attributes.Add(CognitoAttribute.Name.AttributeName, model.Name); user.Attributes.Add(CognitoAttribute.FamilyName.AttributeName, model.Surname); //try to create new user var createdUser = await _userManager.CreateAsync(user, model.Password).ConfigureAwait(false); if (createdUser.Succeeded) //if user successfuly created { return(RedirectToAction("Confirm", "Account")); //then redirect to Confirm action } } return(View()); }
public async Task <IActionResult> Signup(SignUpModel model) { if (ModelState.IsValid) { var user = _pool.GetUser(model.Email); // we have name attribute required. At the moment, we dont have a name passed in, so we can use the email temporarily. // user will not be null even if it does not exist. user.Attributes.Add("name", model.Email); // without second parameter, a new user is created with password autogenerated. // if is user exists, it will fail here. var createResult = await _userManager.CreateAsync(user, model.Password); if (createResult.Succeeded) { var confirmModel = new ConfirmModel { Email = model.Email, Code = string.Empty }; return(RedirectToAction("Confirm", confirmModel)); } foreach (var item in createResult.Errors) { ModelState.AddModelError(item.Code, item.Description); } } return(View(model)); }
public async Task <IActionResult> Signup(SignupModel signupModel) { if (ModelState.IsValid) { var user = _pool.GetUser(signupModel.Email); if (user.Status != null) { ModelState.AddModelError("UserExists", "User in this email already exists"); return(View(signupModel)); } user.Attributes.Add(CognitoAttribute.Name.ToString(), signupModel.Email); var CreatedUser = await _UserManager.CreateAsync(user, signupModel.Password).ConfigureAwait(false); if (CreatedUser.Succeeded) { return(RedirectToAction("Confirm", "Accounts")); } } return(View(signupModel)); }
public async Task <IActionResult> Signup(SignupModel model) { if (ModelState.IsValid) { var user = _pool.GetUser(model.Email); if (user.Status != null) { ModelState.AddModelError("UserExists", "User with this email already exist"); return(View(model)); } user.Attributes.Add(CognitoAttributesConstants.Name, model.Email); var createdUser = await _userManager.CreateAsync(user, model.Password).ConfigureAwait(false); if (createdUser.Succeeded) { return(RedirectToAction("Confirm")); } foreach (var item in createdUser.Errors) { ModelState.AddModelError(item.Code, item.Description); } } return(View(model)); }
public async Task <IActionResult> Signup(SignupModel model) { if (ModelState.IsValid) { var user = _pool.GetUser(model.Email); if (user.Status != null) { ModelState.AddModelError("UserExist", "User with this email already exist"); return(View(model)); } user.Attributes.Add("name", model.Email); var createdUser = await _userManager.CreateAsync(user, model.Password); //await _userManager.CreateAsync(user)//option to set temporary passwod if (createdUser.Succeeded) { //RedirectToPage("./ConfirmPassword"); return(RedirectToAction("Confirm")); } if (createdUser.Errors != null) { foreach (var item in createdUser.Errors) { ModelState.AddModelError(item.Code, item.Description); } } } return(View()); }