//lsakdjf ls public async Task<bool> Register(string email, int? schoolid, int instructorid, string password) { if (ModelState.IsValid) { var user = new ApplicationUser { UserName = email, Email = email }; user.SchoolIdentity = schoolid; user.InstructorIdentity = instructorid; // user.SchoolID = model.SchoolID; var result = await UserManager.CreateAsync(user, password); var role = new IdentityRole("Instructor"); var result2 = UserManager.AddToRole(user.Id, role.Name); if (result.Succeeded && result2.Succeeded) { var 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", " UserName / Email = " + email + "\n Password : "******"Please confirm your account by clicking this link: <a href=\"" + callbackUrl + "\">link</a>"); return true; } else return false; } else return false; }
public async Task<ActionResult> Create(RegisterDoctorViewModel userViewModel) { if (ModelState.IsValid) { var user = new ApplicationUser { FirstName = userViewModel.FirstName, LastName = userViewModel.LastName, PWZ = userViewModel.PWZ, UserName = userViewModel.Email, Email = userViewModel.Email, IsConfirmed = true }; var adminresult = await UserManager.CreateAsync(user, userViewModel.Password); if (adminresult.Succeeded) { var result = await UserManager.AddToRoleAsync(user.Id, "Doctor"); if (!result.Succeeded) { ModelState.AddModelError("", result.Errors.First()); return View(); } } else { ModelState.AddModelError("", adminresult.Errors.First()); return View(); } return RedirectToAction("Index"); } return View(); }
// GET: api/Claims //public IEnumerable<string> Get() public ApplicationUser Get() { //return new string[] { "value1", "value2" }; var u = new ApplicationUser(); u.UserName = "******"; return u; }
private static Task<bool> VerifyClientIdAsync(ApplicationUserManager manager, ApplicationUser user, CookieValidateIdentityContext context) { string clientId = context.Identity.FindFirstValue("AspNet.Identity.ClientId"); if (!string.IsNullOrEmpty(clientId) && user.Clients.Any(c => c.Id.ToString() == clientId)) { user.CurrentClientId = clientId; return Task.FromResult(true); } return Task.FromResult(false); }
/// <summary> /// This method registers a Beagle Tag User. /// </summary> /// <param name="email"></param> /// <param name="password"></param> /// <returns></returns> public async Task<JsonResult> RegisterUser(string email, string password) { if (email == null || password == null) { return Json(new { success = false, message = "missing one or more parameters", UID = "", }, JsonRequestBehavior.AllowGet); } bool success = false; string message = ""; var roles = new List<string> { "Admin" }; //create a new user for this person var user = new ApplicationUser { UserName = email, Email = email, Tags = new List<IdentitySample.Models.Tag>(), Roles = roles }; var UserManager = HttpContext.GetOwinContext().GetUserManager<ApplicationUserManager>(); var result = await UserManager.CreateAsync(user, password); if (result.Succeeded) { success = true; } else { message = "failed due to these errors: " + result.Errors.ToList().ToString(); } //await ZDB.Users.UpdateOneAsync(x => x.Email == email, Builders<ApplicationUser>.Update.Push(x => x.Roles, "Admin")); var idString = ""; if(user!= null) { idString = user.Id.ToString(); } return Json(new { success = success, message = message, UID = idString }, JsonRequestBehavior.AllowGet); }
public async Task<ActionResult> Register(RegisterViewModel model) { if (ModelState.IsValid) { var user = new ApplicationUser() { UserName = model.UserName }; var result = await UserManager.CreateAsync(user, model.Password); if (result.Succeeded) { await SignInAsync(user, isPersistent: false); return RedirectToAction("Index", "Home"); } else { AddErrors(result); } } // If we got this far, something failed, redisplay form return View(model); }
/// <summary> /// Creates a store manager user who can manage the inventory. /// </summary> /// <param name="serviceProvider"></param> /// <returns></returns> private static async Task CreateAdminUser(IServiceProvider serviceProvider) { var options = serviceProvider.GetRequiredService<IOptions<IdentityDbContextOptions>>().Value; const string adminRole = "Administrator"; var userManager = serviceProvider.GetRequiredService<UserManager<ApplicationUser>>(); var roleManager = serviceProvider.GetRequiredService<RoleManager<IdentityRole>>(); if (!await roleManager.RoleExistsAsync(adminRole)) { await roleManager.CreateAsync(new IdentityRole(adminRole)); } var user = await userManager.FindByNameAsync(options.DefaultAdminUserName); if (user == null) { user = new ApplicationUser { UserName = options.DefaultAdminUserName }; await userManager.CreateAsync(user, options.DefaultAdminPassword); await userManager.AddToRoleAsync(user, adminRole); await userManager.AddClaimAsync(user, new Claim("ManageStore", "Allowed")); } }
public async Task<ActionResult> Register(RegisterPatientViewModel model) { if (ModelState.IsValid) { var user = new ApplicationUser { FirstName = model.FirstName, LastName = model.LastName, Pesel = model.Pesel, Address = model.Address, UserName = model.Email, Email = model.Email }; var result = await UserManager.CreateAsync(user, model.Password); if (result.Succeeded) { var roleResult = await UserManager.AddToRoleAsync(user.Id, "Patient"); if (roleResult.Succeeded) { return View("RegistrationMessage"); } else { ModelState.AddModelError("", roleResult.Errors.First()); } } ModelState.AddModelError("", result.Errors.First()); } // If we got this far, something failed, redisplay form return View(model); }
public async Task<HttpResponseMessage> Register([FromBody]dynamic model) { var user = new ApplicationUser { UserName = (string)model.username, Email = (string)model.email }; var result = await Manager().CreateAsync(user, (string)model.password); if (!result.Succeeded) { return Request.CreateErrorResponse(HttpStatusCode.MethodNotAllowed, JsonConvert.SerializeObject(result.Errors)); } if (model.claims != null) { var claims = JsonConvert.DeserializeObject<Dictionary<string, string>>(model.claims.ToString()); if (claims.Count > 0) { AddClaims(user.Id, claims); } } return new HttpResponseMessage { Content = new StringContent(JsonConvert.SerializeObject(await Manager().FindByIdAsync(user.Id))), StatusCode = HttpStatusCode.Created }; }
public async Task<ActionResult> Register(RegisterViewModel model) { if (ModelState.IsValid) { var user = new ApplicationUser { UserName = model.Email, Email = model.Email, Company = model.Company }; var result = await UserManager.CreateAsync(user, model.Password); if (result.Succeeded) { var code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id); var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme); String body = IdentitySample.Common.Helper.Build_UserRegistration(user.UserName, callbackUrl); await UserManager.SendEmailAsync(user.Id, "Confirmación de cuenta", body); return View("DisplayEmail"); } AddErrors(result); } // If we got this far, something failed, redisplay form return View(model); }
public async Task<ActionResult> Register(RegisterViewModel model) { if (ModelState.IsValid) { var user = new ApplicationUser { UserName = model.Email, Email = model.Email }; var result = await UserManager.CreateAsync(user, model.Password); if (result.Succeeded) { // await SignInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false); //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>"); string callbackUrl = await SendEmailConfirmationTokenAsync(user.Id, "Confirm your account"); ViewBag.Message = "Check your email and confirm your account, you must be confirmed " + "before you can log in."; return View("DisplayEmail"); //return RedirectToAction("Index", "Home"); } AddErrors(result); } // If we got this far, something failed, redisplay form return View(model); }
public async Task<ActionResult> RegisterStudentForSection(RegisterViewModelOfStudentToSection model) { if (ModelState.IsValid) { var user = new ApplicationUser { UserName = model.Email, Email = model.Email }; var result = await UserManager.CreateAsync(user, model.Password); if (result.Succeeded) { Student stud = new Student(); stud.Age = model.age; stud.Gender = model.Gender; stud.schoolName = model.schoolName; stud.Id = user.Id; stud.SectionId = model.SectionId; db.Students.Add(stud); db.SaveChanges(); result = await UserManager.AddToRolesAsync(user.Id, "Student"); if (!result.Succeeded) { } else { var 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 this link: <a href=\"" + callbackUrl + "\">link</a>"); ViewBag.Link = callbackUrl; return RedirectToAction("StudentManagement", "Teachers",new { id=model.SectionId}); } } AddErrors(result); } // If we got this far, something failed, redisplay form return View(model); }
public async Task<ActionResult> RegisterTeacher(RegisterViewModelOfTeacher model) { if (ModelState.IsValid) { var user = new ApplicationUser { UserName = model.Email, Email = model.Email }; var result = await UserManager.CreateAsync(user, model.Password); if (result.Succeeded) { Teacher teac = new Teacher(); teac.Address = model.Address; teac.School = model.School; teac.UserId = user.Id; db.Teachers.Add(teac); db.SaveChanges(); result = await UserManager.AddToRolesAsync(user.Id, "Teacher"); if (!result.Succeeded) { } else { var 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 this link: <a href=\"" + callbackUrl + "\">link</a>"); ViewBag.Link = callbackUrl; return View("DisplayEmail"); } } AddErrors(result); } // If we got this far, something failed, redisplay form return View(model); }
private async Task SignInAsync(ApplicationUser user, bool isPersistent, bool rememberBrowser) { // Clear any partial cookies from external or two factor partial sign ins AuthenticationManager.SignOut(DefaultAuthenticationTypes.ExternalCookie, DefaultAuthenticationTypes.TwoFactorCookie); var userIdentity = await user.GenerateUserIdentityAsync(UserManager); if (rememberBrowser) { var rememberBrowserIdentity = AuthenticationManager.CreateTwoFactorRememberBrowserIdentity(user.Id); AuthenticationManager.SignIn(new AuthenticationProperties { IsPersistent = isPersistent }, userIdentity, rememberBrowserIdentity); } else { AuthenticationManager.SignIn(new AuthenticationProperties { IsPersistent = isPersistent }, userIdentity); } }
private async Task SignInAsync(ApplicationUser user, bool isPersistent) { AuthenticationManager.SignOut(DefaultAuthenticationTypes.ExternalCookie); var identity = await UserManager.CreateIdentityAsync(user, DefaultAuthenticationTypes.ApplicationCookie); AuthenticationManager.SignIn(new AuthenticationProperties() { IsPersistent = isPersistent }, identity); }
public async Task<IActionResult> ExternalLoginConfirmation(ExternalLoginConfirmationViewModel model, string returnUrl = null) { if (User.IsSignedIn()) { return RedirectToAction("Index", "Manage"); } if (ModelState.IsValid) { // Get the information about the user from the external login provider var info = await SignInManager.GetExternalLoginInfoAsync(); if (info == null) { return View("ExternalLoginFailure"); } var user = new ApplicationUser { UserName = model.Email, Email = model.Email }; var result = await UserManager.CreateAsync(user); if (result.Succeeded) { result = await UserManager.AddLoginAsync(user, info); if (result.Succeeded) { await SignInManager.SignInAsync(user, isPersistent: false); return RedirectToLocal(returnUrl); } } AddErrors(result); ViewBag.LoginProvider = info.LoginProvider; } ViewBag.ReturnUrl = returnUrl; return View(model); }
public async Task<ActionResult> Register(RegisterViewModel model) { if (ModelState.IsValid) { var user = new ApplicationUser { UserName = model.UserName, FirstName = model.FirstName, LastName = model.LastName/*, Email = model.Email */}; var result = await UserManager.CreateAsync(user, model.Password); if (result.Succeeded) { var 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 this link: <a href=\"" + callbackUrl + "\">link</a>"); ViewBag.Link = callbackUrl; return View("DisplayEmail"); } AddErrors(result); } // If we got this far, something failed, redisplay form return View(model); }
private async Task SignInAsync(ApplicationUser user, bool isPersistent) { var clientKey = Request.Browser.Type; await UserManager.SignInClientAsync(user, clientKey); // Zerando contador de logins errados. await UserManager.ResetAccessFailedCountAsync(user.Id); // Coletando Claims externos (se houver) ClaimsIdentity ext = await AuthenticationManager.GetExternalIdentityAsync(DefaultAuthenticationTypes.ExternalCookie); AuthenticationManager.SignOut(DefaultAuthenticationTypes.ExternalCookie, DefaultAuthenticationTypes.TwoFactorCookie, DefaultAuthenticationTypes.ApplicationCookie); AuthenticationManager.SignIn ( new AuthenticationProperties { IsPersistent = isPersistent }, // Criação da instancia do Identity e atribuição dos Claims await user.GenerateUserIdentityAsync(UserManager, ext) ); }
public async Task<ActionResult> ExternalLoginConfirmation(ExternalLoginConfirmationViewModel model, string returnUrl) { if (User.Identity.IsAuthenticated) { return RedirectToAction("Index", "Manage"); } if (ModelState.IsValid) { // Pegar a informação do login externo. var info = await AuthenticationManager.GetExternalLoginInfoAsync(); if (info == null) { return View("ExternalLoginFailure"); } var user = new ApplicationUser { UserName = model.Email, Email = model.Email }; var result = await UserManager.CreateAsync(user); if (result.Succeeded) { result = await UserManager.AddLoginAsync(user.Id, info.Login); if (result.Succeeded) { await SignInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false); var userext = UserManager.FindByEmailAsync(model.Email); await SignInAsync(userext.Result, false); return RedirectToLocal(returnUrl); } } AddErrors(result); } ViewBag.ReturnUrl = returnUrl; return View(model); }
public async Task<ActionResult> Register(RegisterViewModel model) { if (ModelState.IsValid) { var user = new ApplicationUser { UserName = model.Email, Email = model.Email }; var result = await UserManager.CreateAsync(user, model.Password); if (result.Succeeded) { var 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, "Confirme sua Conta", "Por favor confirme sua conta clicando neste link: <a href='" + callbackUrl + "'></a>"); ViewBag.Link = callbackUrl; return View("DisplayEmail"); } AddErrors(result); } // No caso de falha, reexibir a view. return View(model); }
public async Task<ActionResult> Register(RegisterViewModel model) { if (ModelState.IsValid) { string profilePictureUrl = ""; if(model.ProfilePicture != null && model.ProfilePicture.ContentLength > 0) { string uploadDir = AppDomain.CurrentDomain.BaseDirectory + "UserProfilePictures\\"; //var imagePath = Path.Combine(Server.MapPath(uploadDir), imageToUpload.FileName); //var imageUrl = Path.Combine(uploadDir, imageToUpload.FileName); string filename = Path.GetFileName(model.ProfilePicture.FileName); model.ProfilePicture.SaveAs(Path.Combine(uploadDir, filename)); profilePictureUrl = Path.Combine(uploadDir, filename); } var user = new ApplicationUser { UserName = model.Email, Email = model.Email}; user.Nickname = model.Nickname; user.ProfilePictureUrl = profilePictureUrl; var result = await UserManager.CreateAsync(user, model.Password); if (result.Succeeded) { var 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 this link: <a href=\"" + callbackUrl + "\">link</a>"); ViewBag.Link = callbackUrl; return View("DisplayEmail"); } AddErrors(result); } // If we got this far, something failed, redisplay form return View(model); }
public async Task<ActionResult> Register(RegisterViewModel model) { if (ModelState.IsValid) { var user = new ApplicationUser { UserName = model.Email, Email = model.Email }; // Add the Address properties: user.Address = model.Address; user.City = model.City; user.State = model.State; user.PostalCode = model.PostalCode; var result = await UserManager.CreateAsync(user, model.Password); if (result.Succeeded) { // var 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 this link: <a href=\"" + callbackUrl + "\">link</a>"); //ViewBag.Link = callbackUrl; return View("RegistrationSuccess"); } AddErrors(result); } // If we got this far, something failed, redisplay form return View(model); }
public async Task<ActionResult> Create(RegisterViewModel userViewModel, params string[] selectedRoles) { if (ModelState.IsValid) { var user = new ApplicationUser { UserName = userViewModel.Email, Email = userViewModel.Email, // Add the Address Info: Address = userViewModel.Address, City = userViewModel.City, State = userViewModel.State, PostalCode = userViewModel.PostalCode }; // Add the Address Info: user.Address = userViewModel.Address; user.City = userViewModel.City; user.State = userViewModel.State; user.PostalCode = userViewModel.PostalCode; var adminresult = await UserManager.CreateAsync(user, userViewModel.Password); //Add User to the selected Roles if (adminresult.Succeeded) { if (selectedRoles != null) { var result = await UserManager.AddToRolesAsync(user.Id, selectedRoles); if (!result.Succeeded) { ModelState.AddModelError("", result.Errors.First()); ViewBag.RoleId = new SelectList(await RoleManager.Roles.ToListAsync(), "Name", "Name"); return View(); } } } else { ModelState.AddModelError("", adminresult.Errors.First()); ViewBag.RoleId = new SelectList(RoleManager.Roles, "Name", "Name"); return View(); } return RedirectToAction("Index"); } ViewBag.RoleId = new SelectList(RoleManager.Roles, "Name", "Name"); return View(); }
public async Task<ActionResult> Register(RegisterViewModel model) { if (ModelState.IsValid) { var user = new ApplicationUser { UserName = model.Email, Email = model.Email }; var result = await UserManager.CreateAsync(user, model.Password); if (result.Succeeded) { //var 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 this link: <a href=\"" + callbackUrl + "\">link</a>"); //ViewBag.Link = callbackUrl; //return View("DisplayEmail"); await SignInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false); // once he presses registraion button control will come here //and only after success ful registraion here that token will be either emptied in database so that next time no one can use that token return RedirectToAction("Create", "ProductOwners"); } AddErrors(result); } // If we got this far, something failed, redisplay form return View(model); }
public async Task<ActionResult> Register(RegisterViewModel model) { if (ModelState.IsValid) { var user = new ApplicationUser { UserName = model.Email, Email = model.Email }; var result = await UserManager.CreateAsync(user, model.Password); if (result.Succeeded) { var 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, "確認帳號", "感謝您註冊成為WecareStore會員,點擊後回到WecareStore完成帳號認證 <a href=\"" + callbackUrl + "\">link</a>"); ViewBag.Link = callbackUrl; //////註冊後將user寫入shoppingcart MigrateShoppingCart(model.Email); /////// return View("DisplayEmail"); } AddErrors(result); } // If we got this far, something failed, redisplay form return View(model); }
public async Task<ActionResult> Create(RegisterViewModel userViewModel, params string[] selectedRoles) { var roles = await IdentityContext.AllRolesAsync(); if (ModelState.IsValid) { var user = new ApplicationUser { UserName = userViewModel.Email, Email = userViewModel.Email }; var adminresult = await UserManager.CreateAsync(user, userViewModel.Password); //Add User to the selected Roles if (adminresult.Succeeded) { if (selectedRoles != null) { var result = await UserManager.AddUserToRolesAsync(user.Id, selectedRoles); if (!result.Succeeded) { ModelState.AddModelError("", result.Errors.First()); ViewBag.RoleId = new SelectList(roles, "Name", "Name"); return View(); } } } else { ModelState.AddModelError("", adminresult.Errors.First()); ViewBag.RoleId = new SelectList(roles, "Name", "Name"); return View(); } return RedirectToAction("Index"); } ViewBag.RoleId = new SelectList(roles, "Name", "Name"); return View(); }
private async Task SignInAsync(ApplicationUser user, bool isPersistent) { AuthenticationManager.SignOut(DefaultAuthenticationTypes.ExternalCookie, DefaultAuthenticationTypes.TwoFactorCookie); AuthenticationManager.SignIn(new AuthenticationProperties { IsPersistent = isPersistent }, await user.GenerateUserIdentityAsync(UserManager)); }
private void TwoFactorPartialSignIn(ApplicationUser user) { ClaimsIdentity identity = new ClaimsIdentity(DefaultAuthenticationTypes.TwoFactorCookie); identity.AddClaim(new Claim(ClaimTypes.NameIdentifier, user.Id)); AuthenticationManager.SignIn(identity); }
public async Task<ActionResult> ExternalLoginConfirmation(ExternalLoginConfirmationViewModel model, string returnUrl) { if (User.Identity.IsAuthenticated) { return RedirectToAction("Index", "Manage"); } if (ModelState.IsValid) { // Get the information about the user from the external login provider var info = await AuthenticationManager.GetExternalLoginInfoAsync(); if (info == null) { return View("ExternalLoginFailure"); } var user = new ApplicationUser { UserName = model.UserName, FirstName = model.FirstName, LastName = model.LastName/*Email = model.Email*/ }; var result = await UserManager.CreateAsync(user); if (result.Succeeded) { result = await UserManager.AddLoginAsync(user.Id, info.Login); if (result.Succeeded) { await SignInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false); return RedirectToLocal(returnUrl); } } AddErrors(result); } ViewBag.ReturnUrl = returnUrl; return View(model); }
public async Task<ActionResult> Create(RegisterViewModel userViewModel, params string[] selectedGroups) { if (ModelState.IsValid) { var user = new ApplicationUser { UserName = userViewModel.Email, Email = userViewModel.Email }; var adminresult = await UserManager.CreateAsync(user, userViewModel.Password); //Add User to the selected Groups if (adminresult.Succeeded) { if (selectedGroups != null) { selectedGroups = selectedGroups ?? new string[] { }; await this.GroupManager .SetUserGroupsAsync(user.Id, selectedGroups); } return RedirectToAction("Index"); } } ViewBag.Groups = new SelectList(await RoleManager.Roles.ToListAsync(), "Id", "Name"); return View(); }