public async Task <IActionResult> SignUp(SignupUserModel signupUserModel)
{
try {
AddUsertodatabase(signupUserModel);
if (ModelState.IsValid)
{
Users.Add(signupUserModel);
var result = await account.CreateUserAsync(signupUserModel);
if (!result.Succeeded)
{
foreach (var errormessage in result.Errors)
{
ModelState.AddModelError("", errormessage.Description);
}
}
ModelState.Clear();
return(RedirectToAction("Signup", new { Email = signupUserModel.Email }));
}
ModelState.AddModelError(string.Empty, "Added succ");
}
catch (Exception ex)
{
ModelState.AddModelError(string.Empty, ex.Message);
}
return(View());
}
public ActionResult Signup(SignupUserModel userModel)
{
if (ModelState.IsValid)
{
ModelState.Clear();
}
return(View());
}
private void AddUsertodatabase(SignupUserModel registeruserinfo)
{
client = new FireSharp.FirebaseClient(config);
var data = registeruserinfo;
PushResponse pushResponse = client.Push("User", data);
data.Email = pushResponse.Result.name;
SetResponse setResponse = client.Set("User" + data.Email, data);
}
public async Task <IdentityResult> CreateUserAsync(SignupUserModel signupUserModel)
{
var user = new IdentityUser()
{
Email = signupUserModel.Email
};
var result = await userManager.CreateAsync(user, signupUserModel.Password);
return(result);
}
public async Task <IdentityResult> CreateUserAsync(SignupUserModel model)
{
var user = new IdentityUser()
{
Email = model.Email,
UserName = model.Email
};
var result = await _usermanager.CreateAsync(user, model.Password);
return(result);
}
public async Task <IActionResult> SignUp([FromBody] SignupUserModel model)
{
try
{
await authenticationManager.Signup(model);
return(Ok());
}
catch (Exception ex)
{
return(BadRequest("Something failed"));
}
}
public async Task <IdentityResult> CreateUserAsync(SignupUserModel userModel)
{
var user = new ApplicationUser() //for Default Identity table Use IdentityUser
{
FirstName = userModel.FirstName,
lastName = userModel.lastName,
Email = userModel.Email,
UserName = userModel.Email
};
var result = await _userManager.CreateAsync(user, userModel.Password);
return(result);
}
public async Task <IHttpActionResult> Signup(SignupUserModel userModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
using (AccountRepository accountRepository = new AccountRepository())
{
await accountRepository.RegisterUser(userModel);
}
return(Ok());
}
public async Task Signup(SignupUserModel signupUserModel)
{
var user = new User
{
Email = signupUserModel.Email,
UserName = signupUserModel.Email
};
var result = await userManager.CreateAsync(user, signupUserModel.Password);
if (result.Succeeded)
{
await userManager.AddToRoleAsync(user, signupUserModel.RoleId);
}
}
public async Task <IActionResult> Signup(SignupUserModel userModel)
{
if (ModelState.IsValid)
{
var result = await _accountRepository.CreateUserAsync(userModel);
if (!result.Succeeded)
{
foreach (var errorMessage in result.Errors)
{
ModelState.AddModelError("", errorMessage.Description);
}
return(View());
}
ModelState.Clear();
}
return(View());
}
public async Task <IHttpActionResult> Signup(SignupUserModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = new ApplicationUser {
UserName = model.Username, Email = model.Email
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
var identity = await UserManager.CreateIdentityAsync(user, DefaultAuthenticationTypes.ApplicationCookie);
Authentication.SignIn(new AuthenticationProperties {
IsPersistent = true
}, identity);
}
return(Ok());
}
/// <summary>
/// Registers a new user.
/// </summary>
/// <param name="user">The user information to register.</param>
public async Task RegisterUser(SignupUserModel user)
{
// @TODO: Implement actual user registration.
}
