public ActionResult Register(RegisterVM user) { if (ModelState.IsValid) { var pwd = new PasswordManager(); //var password = Membership.GeneratePassword(10, 0); var password = "******"; string salt = null; var passwordHash = pwd.GeneratePasswordHash(password, out salt); var newUser = new User { FirstName = user.FirstName, LastName = user.LastName, LoginEmail = user.LoginEmail, PasswordHash = passwordHash, PasswordSalt = salt, CreationDate = DateTime.Now, Gender = user.Gender, IsDeleted = false }; var link = "?password="******"<p>Email From: {0} ({1})</p><p>Message:</p><p>{2}</p>"; var message = new MailMessage(); message.To.Add(new MailAddress(user.LoginEmail)); // replace with valid value message.From = new MailAddress("*****@*****.**"); // replace with valid value message.Subject = "Account confirmation"; message.Body = string.Format(body, message.From, "AI Research", "Please confirm by clicking this link "); message.IsBodyHtml = true; using (var smtp = new SmtpClient()) { var credential = new NetworkCredential { UserName = "******", // replace with valid value Password = "******" // replace with valid value }; smtp.Credentials = credential; smtp.Host = "smtp-mail.outlook.com"; smtp.Port = 587; smtp.EnableSsl = true; // await smtp.SendMailAsync(message); //return RedirectToAction("Sent"); } Services.UserService.AddUser(newUser, user.RoleID); user.Roles = GetRoles(); return(RedirectToAction("Login", "Account")); } return(View(user)); }
public IActionResult Register(RegisterVM model) { if (ModelState.IsValid) { var isRegistered = this.accountService.Register(signIn, model); if (isRegistered) { return(this.Redirect("/home/index")); } } return(this.View(model)); }
public void CreateUser(RegisterVM registerVM) { User user = new User { Name = registerVM.UserName, Email = registerVM.Email, Password = registerVM.Password }; _repository.Create <User>(user); _repository.Save(); return; }
//Este proceso sera boolean --- si funciona enviar true // sino false public ActionResult Register(RegisterVM model) { if (!ModelState.IsValid) { return(View(model)); } else { _manejoUserServices.CrearUsuario(model); } return(RedirectToAction("Login", "Account")); }
public bool CrearUsuario(RegisterVM model) { Usuario user = new Usuario(); user.Nombre_Usuario = model.Nombre_Usuario; user.Password = model.Password; //user.Posicion = model.Posicion; //user.premio = model.premio; _manejoUsuarioRepo.ReistrarUsuarios(user); return(true); }
public JsonResult Insert(RegisterVM model) { client.DefaultRequestHeaders.Add("Authorization", HttpContext.Session.GetString("JWTToken")); var myContent = JsonConvert.SerializeObject(model); var buffer = System.Text.Encoding.UTF8.GetBytes(myContent); var byteContent = new ByteArrayContent(buffer); byteContent.Headers.ContentType = new MediaTypeHeaderValue("application/json"); var result = client.PostAsync("auth/register", byteContent).Result; return(Json(result)); }
public async Task <string> RegisterUserAsync(RegisterVM model, string url) { var user = new IdentityUser() { Email = model.Email, PasswordHash = model.Password, UserName = model.Email, PhoneNumber = model.Phone, EmailConfirmed = /*false*/ true }; var result = await _userManager.CreateAsync(user, model.Password); if (!result.Succeeded) { throw new Exception($"Register error ({result.Errors.FirstOrDefault()?.Description})"); } _userManager.AddToRoleAsync(user, model.Role).Wait(); var fileId = (await _fileService.CreateFileDbAsync(model.Photo, userId: user.Id)).Id; var userProfile = new UserProfile() { FirstName = model.FirstName, LastName = model.LastName, DateBirth = model.DateBirth, //DateLastOnline = DateTime.Now, SexId = model.SexId, FileId = fileId, UserId = user.Id }; await _db.UserProfiles.CreateAsync(userProfile); if (model.Role == "manager") { var manager = new Manager { UserProfileId = userProfile.Id, LocationId = model.LocationId }; await _db.Managers.CreateAsync(manager); } //await _chatService.SetLastOnlineAsync(user.Id); //var code = await _userManager.GenerateEmailConfirmationTokenAsync(user); //var encode = HttpUtility.UrlEncode(code); //var callbackUrl = new StringBuilder("https://") // .AppendFormat(url) // .AppendFormat("/api/account/email") // .AppendFormat($"?user_id={user.Id}&code={encode}"); //await _emailService.SendEmailAsync(user.Email, "Confirm your account", //$"Confirm the registration by clicking on the link: <a href='{callbackUrl}'>link</a>"); return(user.Id); }
public ActionResult Register([Bind(Include = "Id,Username,Password,ConfirmPassword,Title,Forename,Surname,Dob,AddressStreet," + "AddressTown,AddressCounty,AddressPostalCode,HomePhoneNo,WorkPhoneNo,MobilePhoneNo,Email")] RegisterVM registration) { if (ModelState.IsValid) { if (_authFacade.Register(registration.Username, registration.Password, registration.ConfirmPassword)) { _authFacade.GetToken(registration.Username, registration.Password); GenericFacade.UserName = registration.Username; string owinId = _authFacade.GetUserId(); GenericFacade.OwinId = owinId; _authFacade.AddCustomerRole(); Session[Global.RolesSessionVar] = GenericFacade.IsAdmin; _customerFacade.Create(new Customer { OwinUserId = owinId, UserName = registration.Username, Title = registration.Title, Forename = registration.Forename, Surname = registration.Surname, DoB = registration.Dob, AddressStreet = registration.AddressStreet, AddressTown = registration.AddressTown, AddressCounty = registration.AddressCounty, AddressPostalCode = registration.AddressPostalCode, HomePhoneNo = registration.HomePhoneNo, WorkPhoneNo = registration.WorkPhoneNo, MobilePhoneNo = registration.MobilePhoneNo, Email = registration.Email }); Customer c = _customerFacade.Get(); Session[Global.UserIdSessionVar] = c.Id; Session[Global.UsernameSessionVar] = registration.Username; return(RedirectToAction("index", "home")); } else { return(View(registration)); } } return(View(registration)); }
public async Task <IActionResult> Register(RegisterVM registerVM) { if (!ModelState.IsValid) { return(View(registerVM)); } CustomUser customUser = new CustomUser { FirstName = registerVM.FirstName, LastName = registerVM.LastName, Email = registerVM.Email, PhoneNumber = registerVM.PhoneNumber, UserName = registerVM.UserName }; IdentityResult result = await _userManager.CreateAsync(customUser, registerVM.Password); if (!result.Succeeded) { foreach (var error in result.Errors) { error.Description = "Qeydiyyat zamanı xəta baş verdi"; ModelState.AddModelError("", error.Description); } return(View(registerVM)); } await _userManager.AddToRoleAsync(customUser, "İstifadəçi"); #region Sending Email Confirmation Message SmtpClient client = new SmtpClient("smtp.gmail.com", 587); client.UseDefaultCredentials = false; client.EnableSsl = true; client.Credentials = new NetworkCredential(_configuration["ConnectionStrings:SmtpClientCredentialEmail"], _configuration["ConnectionStrings:SmtpClientCredentialPassword"]); MailMessage message = new MailMessage("*****@*****.**", registerVM.Email); message.IsBodyHtml = true; message.Subject = "Hesabın təsdiqlənməsi"; message.Body = $"<a href='https://localhost:44365/Account/Confirmation/?userId={customUser.Id}'>Hesabını təsdiqlə</a>"; client.Send(message); #endregion TempData["Confirm"] = true; return(View()); }
//public AccountService(IHttpContextAccessor accessor) //{ // userId = userManager.GetUserId(accessor.HttpContext.User); //} public async Task <SignInResult> TrySignInUser(RegisterVM vM) { var user = await userManager.FindByIdAsync(userId); var result = await signInManager.PasswordSignInAsync( user.UserName, user.PasswordHash, isPersistent : false, lockoutOnFailure : false ); return(result); }
public int UserRegistration(RegisterVM registerVM) { try { _mapper = profile.Map().CreateMapper(); UserMaster userMaster = _mapper.Map <RegisterVM, UserMaster>(registerVM); _uow.UserMasters.Add(userMaster); return(_uow.CommitChanges()); } catch (Exception ex) { return(0); } }
public void RejectRevertAudit(RegisterVM vm, EventHandler <RestClientEventArgs <RMARegisterInfo> > callback) { string relativeUrl = "/RMAService/Register/RejectRevertAudit"; RMARegisterInfo msg = vm.ConvertVM <RegisterVM, RMARegisterInfo>(); restClient.Update <RMARegisterInfo>(relativeUrl, msg, (obj, args) => { if (args.FaultsHandle()) { return; } callback(obj, args); }); }
public async Task <IActionResult> Register(RegisterVM register) { var res = await _roleManager.RoleExistsAsync("NormalUser"); if (!res == true) { IdentityRole identityRole = new IdentityRole { Name = "NormalUser" }; await _roleManager.CreateAsync(identityRole); } if (ModelState.IsValid) { var user = new User() { FirstName = register.FirstName, LastName = register.LastName, Email = register.Email, PhoneNumber = register.Phone, UserName = register.Email, }; var result = await _userManager.CreateAsync(user, register.Password); if (result.Succeeded) { await _userManager.AddToRoleAsync(user, "NormalUser"); await _signInManager.SignInAsync(user, false); return(RedirectToAction("Index", "Home")); } else { foreach (var error in result.Errors) { ModelState.AddModelError("", error.Description); } } } return(View(register)); }
public static void CreateInstructor(RegisterVM vm) { Instructor p = new Instructor(); //HireDate is particular to Instructor p.HireDate = vm.HireDate; p.Email = vm.Email; p.FirstMidName = vm.FirstMidName; p.LastName = vm.LastName; p.Password = SaltAndHash(vm.Password); p.UserName = vm.UserName; db.Instructors.Add(p); db.SaveChanges(); }
public static void CreateStudent(RegisterVM vm) { Student p = new Student(); //EnrollmentDate is particular to Student p.EnrollmentDate = vm.HireDate; p.Email = vm.Email; p.FirstMidName = vm.FirstMidName; p.LastName = vm.LastName; p.Password = SaltAndHash(vm.Password); p.UserName = vm.UserName; db.Students.Add(p); db.SaveChanges(); }
public async Task <IActionResult> OnPostAsync([FromBody] RegisterVM registerVM) { MemberRepo cRP = new MemberRepo(_context); ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList(); if (ModelState.IsValid) { if (cRP.checkExist(registerVM.Email)) { var Obj = new { errorMessage = "User Already Exist", StatusCode = "Invalid Register." }; return(new ObjectResult(Obj)); } var user = new IdentityUser { UserName = registerVM.Email, Email = registerVM.Email, }; var result = await _userManager.CreateAsync(user, registerVM.Password); if (result.Succeeded) { var code = await _userManager.GenerateEmailConfirmationTokenAsync(user); code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code)); var enCode = Encoding.UTF8.GetString(WebEncoders.Base64UrlDecode(code)); await _userManager.ConfirmEmailAsync(user, enCode); bool isNewClient = cRP.Create(registerVM.Username, registerVM.LastName, registerVM.FirstName, registerVM.Email); if (isNewClient) { var tokenString = GenerateJSONWebToken(user); var jsonOK = new { tokenString = tokenString, StatusCode = "OK", currentUser = registerVM.Email }; return(new ObjectResult(jsonOK)); } } } var jsonInvalid = new { tokenString = "", StatusCode = "Invalid register." }; return(new ObjectResult(jsonInvalid)); }
public ActionResult Register(RegisterVM model) { var userManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(db)); ApplicationUser user = new ApplicationUser { UserName = model.Username }; var r = userManager.CreateAsync(user, model.Password); if (r.Result.Succeeded) { return(RedirectToAction("Login")); } return(View(model)); }
// GET: Users/Create public ActionResult Register() { var model = new RegisterVM(); //Create a temporary user than can be passed to the UI and //used to store the data that needs to be posted to the database model.tempUser = new User { Role = 1, ShowCV = true }; ViewBag.UserTypeId = new SelectList(db.UserTypes, "UserTypeId", "UserTypeText"); return(View(model)); }
public async Task <IActionResult> CreateUserAsync([FromBody] RegisterVM model) { if (model == null) { throw new NullReferenceException("Register Model Is Null"); } var result = await _identityService.CreateUserAsync(model); if (result.Succeeded) { return(Ok(result)); } return(BadRequest(result)); }
public ActionResult Register(RegisterVM registerVM) { var user = new User { Email = registerVM.Email, FirstName = registerVM.FirstName, LastName = registerVM.LastName, Password = registerVM.Password }; unitOfWork.Users.Insert(user); SetAuthCookie(unitOfWork.Users.GetUserByCredentials(user.Email, registerVM.Password)); return(Redirect("Index")); }
public async Task <IdentityResult> RegisterAsync(RegisterVM model) { var user = new User() { UserName = model.Email, Email = model.Email }; var result = await _userManager.CreateAsync(user, model.Password); if (result.Succeeded) { await _userManager.AddToRoleAsync(user, "Customer"); } return(result); }
public async Task <ActionResult> Register(RegisterVM registerViewModel) { if (!ModelState.IsValid) { ModelState.AddModelError(string.Empty, "Please try again."); return(View(registerViewModel)); } string username = registerViewModel.Username; Users user = await _unitOfWork.usersRolesRepo.GetAsync(username); if (user != null) { ModelState.AddModelError(string.Empty, "User already exists"); return(View(registerViewModel)); } string hashInfo = Hasher.HashGenerator(registerViewModel.HashedPassword); string myHash = hashInfo.Split(':')[0]; // returns the hash user = new Users() { Username = username, HashedPassword = hashInfo }; _unitOfWork.usersRolesRepo.Add(user); UserRolesMapping roleMap = new UserRolesMapping() { UserID = user.ID, RoleID = _roleId }; _unitOfWork.rolesMappingRepo.Add(roleMap); bool registerOk = await _accountRest.RegisterServiceAsync(username, myHash, _userRole); if (registerOk) { int saved = await _unitOfWork.SaveAsync(); if (saved < 0) { ModelState.AddModelError(string.Empty, "Unable to save User to client."); return(View(registerViewModel)); } bool tokenOk = await LoginHelper(username, myHash); if (tokenOk) { return(RedirectToAction("Inbox", "Messages")); } } ModelState.AddModelError(string.Empty, "Unable to register user."); return(View(registerViewModel)); }
public async Task <IActionResult> Register(RegisterVM model, string returnUrl) { if (await _db.UserClients.AnyAsync(a => a.Email == model.User.Email)) { ModelState.AddModelError("User.Email", "This Email was Registered"); model.Breadcrumb = new Breadcrumb { Path = new Dictionary <string, string> { { "Home", Url.Action("Index", "Home") }, { "Register", null } }, Page = Page.Login }; TempData["Error"] = "This user have been Registered"; return(View(model)); } if (ModelState.IsValid) { model.User.CreatedAt = DateTime.Now; PasswordHasher <UserClient> hasher = new PasswordHasher <UserClient>( new OptionsWrapper <PasswordHasherOptions>( new PasswordHasherOptions() { CompatibilityMode = PasswordHasherCompatibilityMode.IdentityV2 }) ); model.User.Password = hasher.HashPassword(model.User, model.User.Password); model.User.Token = Guid.NewGuid().ToString(); await _db.UserClients.AddAsync(model.User); await _db.SaveChangesAsync(); var option = new CookieOptions { Expires = DateTime.Now.AddMinutes(60), IsEssential = true }; Response.Cookies.Append("Token", model.User.Token, option); return(LocalRedirect(returnUrl)); } model.Breadcrumb = new Breadcrumb { Path = new Dictionary <string, string> { { "Home", Url.Action("Index", "Home") }, { "Register", null } }, Page = Page.Login }; return(View(model)); }
public int Create(RegisterVM registerVM) { var spName = "SP_Register"; parameters.Add("@name", registerVM.EmployeeName); parameters.Add("@birthdate", registerVM.BirthDate); parameters.Add("@address", registerVM.Address); parameters.Add("@email", registerVM.Email); parameters.Add("@phone", registerVM.Phone); parameters.Add("@password", registerVM.Password); var result = connection.Execute(spName, parameters, commandType: CommandType.StoredProcedure); return(result); }
public ActionResult Registration(RegisterVM entity) { string HASHValue = string.Empty; byte[] SALT = new byte[saltLengthLimit]; try { using (RepshoDBE db = new RepshoDBE()) { // Ensure we have a valid viewModel to work with if (!ModelState.IsValid) { return(View(entity)); } //Retrive Stored HASH Value From Database According To Username (one unique field) var userInfo = db.UserMasters.Where(s => s.Username == entity.Username.Trim()).FirstOrDefault(); //Assign HASH Value if (userInfo == null) { UserMaster user = new UserMaster(); SALT = Get_SALT(); HASHValue = Get_HASH_SHA512(entity.Password, entity.Username, SALT); user.SALT = SALT; user.HASH = HASHValue; user.Username = entity.Username; user.FirstName = entity.FirstName; user.LastName = entity.LastName; user.UserEmail = entity.UserEmail; db.UserMasters.Add(user); db.SaveChanges(); ModelState.Clear(); return(RedirectToAction("Login", "Login")); } else { //Login Fail TempData["ErrorMSG"] = "User Exists"; return(View(entity)); } } } catch (Exception ex) { throw; } }
public IActionResult Register(RegisterVM input) { if (ModelState.IsValid) { if (CheckEmail(input.Email)) //dodatna back-end provjera za zauzetost maila jer ModelState.IsValid ne provjerava REMOTE { ModelState.AddModelError("Email", $"Email {input.Email} je zauzet!"); //TempData["ErrorMessage"] = "Check the fields"; } if (CheckEmail(input.Username)) //dodatna back-end provjera za zauzetost username jer ModelState.IsValid ne provjerava REMOTE { ModelState.AddModelError("Username", $"Username {input.Username} je zauzet!"); //TempData["ErrorMessage"] = "Check the fields"; } if (CheckEmail(input.Username) || CheckEmail(input.Email)) { return(PartialView("Register", input)); } TempData["ErrorMessage"] = "Uspjesna registracija!"; //obavijesti korisnika o uspjesnoj registraciji //dodaj korisnika u bazu User novi = new User { Username = input.Username, Password = input.Password, Email = input.Email, Role = 0 }; db.Users.Add(novi); db.SaveChanges(); Zaposlenik novi_zaposlenik = new Zaposlenik { User = novi, UserId = novi.UserId }; db.Zaposlenici.Add(novi_zaposlenik); db.SaveChanges(); GetSetUser.SetLoggedUser(HttpContext, novi, false); //automatski logiraj novoregistrovanog korisnika //dodaj zaposlenika u tabelu zaposlenici, default korisnik je zaposlenik return(RedirectToAction("Index", "Index")); } else { //TempData["ErrorMessage"] = "Check the fields"; return(PartialView("Register", input)); } }
public bool AssignToRole(RegisterVM uservm) { try { ApplicationUserIdentity user = TheUnitOfWork.Account.FindByName(uservm.UserName); if (uservm.userType == UserType.Teacher) { TheUnitOfWork.Account.AssignToRole(user.Id, "Teacher"); Teacher teacher = new Teacher() { user = user, ID = user.Id, firstName = uservm.firstName, lastName = uservm.lastName, gender = uservm.gender.ToString(), age = uservm.age, image = "defaultProfile.jpg" }; user.teacher = teacher; TheUnitOfWork.Teacher.InsertTeacher(teacher); TheUnitOfWork.Commit(); } else if (uservm.userType == UserType.Student) { TheUnitOfWork.Account.AssignToRole(user.Id, "Student"); Student student = new Student() { user = user, ID = user.Id, firstName = uservm.firstName, lastName = uservm.lastName, gender = uservm.gender.ToString(), age = uservm.age, image = "defaultProfile.jpg" }; user.student = student; TheUnitOfWork.Student.InsertStudent(student); TheUnitOfWork.Commit(); } return(true); } catch { return(false); } }
public async Task <IActionResult> RegisterAsync([FromBody] RegisterVM model) { if (model == null) { throw new NullReferenceException("Register model is null"); } if (ModelState.IsValid) { var role = _roleManager.FindByIdAsync(model.RoleId).Result; if (role.Name == "Customer" || role.Name == "Admin") { throw new NullReferenceException("Role is not good"); } var user = new Account { UserName = model.Email, FirstName = model.FirstName, LastName = model.LastName, PhoneNumber = model.PhoneNumber, Email = model.Email }; var result = await _userManager.CreateAsync(user, model.Password); if (result.Succeeded) { var roleResult = await _userManager.AddToRoleAsync(user, role.Name); if (!roleResult.Succeeded) { throw new NullReferenceException("Role is not good"); } await SendPasswordAsync(model.Email, model.Password, model.Email); Employee employee = new Employee { Account = user, BranchID = model.BranchId }; _employeeService.AddEmployee(employee); return(Ok(result)); // Status Code: 200 } return(BadRequest(result)); } return(BadRequest("Some properties are not valid")); // Status code: 400 }
public async Task <IActionResult> Register(RegisterVM model) { if (ModelState.IsValid) { ApplicationUserVM newUser = new ApplicationUserVM { UserName = model.Name, Email = model.Email, PhoneNumber = model.PhoneNumber }; MapperConfiguration config = new MapperConfiguration(cfg => { cfg.CreateMap <ApplicationUserVM, ApplicationUser>(); }); IMapper map = config.CreateMapper(); ApplicationUser user = map.Map <ApplicationUserVM, ApplicationUser>(newUser); IdentityResult result = await _userManager.CreateAsync(user, model.Password); string rgx = @"^(?=.+[0-9])(?=.+[!@#$%^&*])(?=.+[a-z])(?=.+[A-Z])[0-9a-zA-Z!@#$%^&*]{6,}$"; //if (Regex.IsMatch(model.Password, rgx)) //{ // IdentityResult result = await _userManager.CreateAsync(user, model.Password); if (result.Succeeded) { bool roleCheck = await _roleManager.RoleExistsAsync("User"); if (!roleCheck) { IdentityResult roleResult = await _roleManager.CreateAsync(new IdentityRole("User")); } await _userManager.AddToRoleAsync(user, "User"); SendMessage(user); return(PartialView("DisplayEmail")); // } } else { ModelState.AddModelError("", " Пароль от 6 символов с использованием цифр, спец. символов, латиницы, наличием строчных и прописных символов."); } ModelState.AddModelError("", "Пользователь с таким Еmail или именем уже существует"); } return(View(model)); }
public async Task <IActionResult> Register(RegisterVM register) { if (!ModelState.IsValid) { ViewBag.RegError = 1; return(View(register)); } User user = new User { Name = register.Name, UserName = register.Username, Email = register.Email, RegDate = DateTime.Now }; IdentityResult identityResult = await _userManager.CreateAsync(user, register.Password); if (!identityResult.Succeeded) { foreach (var error in identityResult.Errors) { ModelState.AddModelError(string.Empty, error.Description); } ViewBag.RegError = 1; return(View(register)); } await _userManager.AddToRoleAsync(user, Helpers.Extensions.Role.User.ToString()); var code = await _userManager.GenerateEmailConfirmationTokenAsync(user); var link = Url.Action(nameof(VerifyEmail), "Account", new { userId = user.Id, code }, Request.Scheme, Request.Host.ToString()); MailMessage mail = new MailMessage(); mail.From = new MailAddress("*****@*****.**", "Perivallo"); mail.To.Add(new MailAddress(user.Email)); mail.Subject = "Verify your email"; mail.Body = $"<a href=\"{link}\">Verify Email</a>"; mail.IsBodyHtml = true; SmtpClient smtp = new SmtpClient(); smtp.Host = "smtp.gmail.com"; smtp.Port = 587; smtp.EnableSsl = true; smtp.Credentials = new NetworkCredential("*****@*****.**", "mybstwrk@prvll"); smtp.Send(mail); //await _signInManager.SignInAsync(user, true); return(RedirectToAction("EmailVerification")); }
public async Task<bool> Create(RegisterVM model) { var newUser = new ApplicationUser { DisplayName = model.DisplayName, Email = model.Email, UserName = model.UserName, RegistrationDate = DateTime.Now }; var result = await _users.CreateAsync(newUser, model.Password); if (result) { _loggingService.Info(string.Format("创建用户:{0}",newUser.UserName)); return true; } _loggingService.Error(string.Format("创建用户 {0} 失败", newUser.UserName)); return false; }
public async Task<JsonResult> Create(RegisterVM model) { if (ModelState.IsValid) { var result = await _userService.Create(model); //return RedirectToAction("index"); return Json(result, JsonRequestBehavior.DenyGet); } return Json(false, JsonRequestBehavior.DenyGet); }
public async Task<ActionResult> Register(RegisterVM model) { if (ModelState.IsValid) { var user = new ApplicationUser { UserName = model.UserName, Email = model.Email }; 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("Index", "Home"); } AddErrors(result); } // If we got this far, something failed, redisplay form return View(model); }