public async Task <ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new User {
UserName = model.Email, Email = model.Email, FirstName = model.FirstName, LastName = model.LastName, Purchased = 3
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
// For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=320771
// Send an email with this link
// string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
// var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
// await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>");
return(RedirectToAction("GetCurrentUser", "User"));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public OldHouseUser GetTestFackUser(string nickName, string userName, string password)
{
var user = MyUserManager.FindByNameAsync(userName).Result;
if (user != null)
{
return(user);
}
user = new OldHouseUser {
NickName = nickName,
UserName = userName,
PasswordHash = password
};
//todo put all oldhouse user roles in consts
//todo use a fake user iu data base later
user.Roles.Add("User");
//it has no profile yet
//todo may return a fake profile in data base
var profile = CreateAFakeProfile();
user.Profiles.Add(OldHouseUserProfile.PROFILENBAME, profile.Id);
MyUserManager.CreateAsync(user).Wait();
ProfileService.SaveOne(profile);
return(user);
}
/// <summary>
/// just the create user method in the jtext103Identity, but with profile added
//
/// </summary>
/// <param name="user">the oldhouse user</param>
/// <param name="profileNames">you can indecate a list of new profile name</param>
/// <returns></returns>
public async Task <IdentityResult> CreateUserWithProfile(OldHouseUser user, HashSet <string> profileNames)
{
//default user role
user.Roles.Add("User");
var avatarName = "defaultAvatar_boy_";
if (user.sex == "female")
{
avatarName = "defaultAvatar_girl_";
}
var rnd = new Random();
avatarName += rnd.Next(1, 6).ToString() + ".jpg";
user.Avatar = avatarName;
var result = await MyUserManager.CreateAsync(user);
//only when the user is added then can we add profiels
if (result.IsSuccessful)
{
//done add userId in profile
user.Profiles = CreateNewProfile(profileNames, user.Id);
await MyUserManager.UpdateAsync(user);
}
return(result);
}
public async Task <ActionResult> Store(string username, string password)
{
var account = new Account()
{
UserName = username,
Email = username,
FirstName = "Xuan Hung",
LastName = "Dao",
Avatar = "avatar",
Birthday = DateTime.Now,
CreatedAt = DateTime.Now
};
IdentityResult result = await _userManager.CreateAsync(account, password);
if (result.Succeeded)
{
_userManager.AddToRole(account.Id, "User");
// For more information on how to enable account confirmation and password reset please visit https://go.microsoft.com/fwlink/?LinkID=320771
// Send an email with this link
string code = await _userManager.GenerateEmailConfirmationTokenAsync(account.Id);
await _userManager.SendEmailAsync(account.Id, "Hello world! Please confirm your account", "<b>Please confirm your account</b> by clicking <a href=\"http://google.com.vn\">here</a>");
return(RedirectToAction("Index", "Home"));
}
return(View("Register"));
}
public async Task <TokenAuthorizeModel> RegisterExternalAsync(MyUserManager userManager, RegisterExternalViewModel viewModel)
{
var identity = viewModel.ToEntity();
var authenticationType = Enum.Parse <ExternalAuthenticationType>(viewModel.Provider, true);
_externalAuthenticationFactory.Create(authenticationType).GetUserDetails(identity, viewModel.ProviderIdToken);
identity.UserName = identity.Email;
//If user exist in the system
var user = await userManager.FindByNameAsync(identity.UserName);
if (user != null)
{
return(await user.AuthorizeAsync(userManager, _extensionSettings.appSettings));
}
//if user is not exist in the system
IdentityResult result = await userManager.CreateAsync(identity);
if (result.Succeeded)
{
await updateOtherInfoForIdentity(userManager, identity);
return(await identity.AuthorizeAsync(userManager, _extensionSettings.appSettings));
}
throw new FoodCourtException(ErrorMessage.USER_CREATE_FAIL);
}
public async Task <TokenAuthorizeModel> RegisterAsync(MyUserManager userManager, RegisterViewModel viewModel)
{
//save
var identity = viewModel.ToEntity();
identity.PasswordHash = userManager.PasswordHasher.HashPassword(identity, viewModel.Password);
IdentityResult result = await userManager.CreateAsync(identity);
if (result.Succeeded)
{
await updateOtherInfoForIdentity(userManager, identity);
return(await identity.AuthorizeAsync(userManager, _extensionSettings.appSettings));
}
throw new FoodCourtException(ErrorMessage.USER_CREATE_FAIL);
}
public MyUser AddUser(MyUser user, string password, ref IdentityResult result)
{
user.LockoutEnabled = false;
var order = uM.CreateAsync(user, password);
order.Wait();
result = order.Result;
if (result.Succeeded)
{
return(user);
}
else
{
return(null);
}
}
public async Task <ActionResult> Register(RegisterInputModel model, string SelectedRole)
{
if (ModelState.IsValid)
{
#if DEBUG
Debug.WriteLine("Model is valid");
#endif
var user = new t_User();
user.UserName = model.UserName;
user.FIO = model.FIO;
user.Position = model.Position;
user.SetPasswordEnabled = model.SetPasswordEnabled;
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
#if DEBUG
Debug.WriteLine("resulult is secceeded");
#endif
if (SelectedRole != null)
{
var result2 = await _userManager.AddToRoleAsync(user.Id, SelectedRole);
if (result2.Succeeded)
{
#if DEBUG
Debug.WriteLine("Roles is added");
#endif
return(RedirectToAction("List"));
}
}
}/*
* var result = await _userManager.RegisterUserAsync(model, SelectedRole);
* if (result.Succeeded)
* {
#if DEBUG
* Debug.WriteLine("User is added!");
#endif
* return RedirectToAction("List");
* }*/
}
model.userRoles = _userManager.GetListUserRoles();
return(View(model));
}
public async Task <IHttpActionResult> Register([FromBody] RegisterBindingModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = new AppUser
{
UserName = model.UserName,
Email = model.Email
};
//create user
var createUserResult = await _userManager.CreateAsync(user, model.Password);
if (!createUserResult.Succeeded)
{
return(GetErrorResult(createUserResult));
}
return(Content(HttpStatusCode.Created, user));
}
public async Task <IdentityResult> Register(MyUser user, string password)
{
var result = await _userManager.CreateAsync(user, password);
return(result);
}
public async Task <IActionResult> SignInCompleteAsync()
{
string returnUrl = "/";
//returnUrl = returnUrl ?? "/";
var info = await SignInManager.GetExternalLoginInfoAsync();
if (info == null)
{
// El login no es válido o no se ha completado
return(BadRequest());
}
//var userid = info.Principal.Claims.FirstOrDefault(c => c.Type == ClaimTypes.NameIdentifier);
//var name = info.Principal.Claims.FirstOrDefault(c => c.Type == ClaimTypes.Name);
//var identityAtDb = await UserManager.FindByLoginAsync(info.LoginProvider, info.ProviderKey);
//if (identityAtDb == null)
//{
// identityAtDb = await UserManager.FindByEmailAsync(email);
// if(identityAtDb == null)
// {
// identityAtDb = new MyUser();
// identityAtDb.Email = email;
// }
//}
//var userAtIdentity = await UserManager.FindByEmailAsync
var result = await SignInManager.ExternalLoginSignInAsync(info.LoginProvider, info.ProviderKey, isPersistent : false, bypassTwoFactor : true);
if (result.Succeeded)
{
return(Ok());
}
if (result.IsLockedOut)
{
return(Forbid());
}
else
{
// La idea es: si el usuario no tiene una cuenta creada y enlazada con el proveedor (hubiera pasado por result.Succeeded)
// exijimos (si aplica) que se cree una cuenta.
// Podemos coger los Claims que nos provee el servicio externo.
var email = info.Principal.Claims.FirstOrDefault(c => c.Type == ClaimTypes.Email)?.Value;
if (string.IsNullOrWhiteSpace(email))
{
return(SignOut());
}
var identityUser = new MyUser();
await UserStore.SetUserNameAsync(identityUser, email, System.Threading.CancellationToken.None);
await EmailStore.SetEmailAsync(identityUser, email, System.Threading.CancellationToken.None);
var createResult = await UserManager.CreateAsync(identityUser);
if (createResult.Succeeded)
{
await SignInManager.SignInAsync(identityUser, isPersistent : false);
return(Redirect("/"));
}
else
{
foreach (var error in createResult.Errors)
{
ModelState.AddModelError(error.Code, error.Description);
}
return(BadRequest(ModelState));
}
}
}
