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