public async Task<ActionResult> Register(RegisterViewModel model) { if (ModelState.IsValid) { var user = new ApplicationUser() { UserName = model.UserName }; user.HomeTown = model.HomeTown; user.MyUserInfo = new MyUserInfo() { FirstName = model.UserName }; // Store Gender as Claim user.Claims.Add(new IdentityUserClaim() { ClaimType = ClaimTypes.Gender, ClaimValue = "Male" }); 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); }
public async Task<ActionResult> Register(RegisterViewModel model) { if (ModelState.IsValid) { using(var db= new ELearningContext()) { User userr= new User(){UserName=model.UserName, Password= model.Password}; db.Users.Add(userr); db.SaveChanges(); } 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); }
public async Task<ActionResult> Register(RegisterViewModel model) { if (ModelState.IsValid) { var user = new ApplicationUser { UserName = model.UserName, FirstName = model.FirstName, LastName = model.LastName}; try { var result = await UserManager.CreateAsync(user, model.Password); if (result.Succeeded) { await SignInAsync(user, false); return RedirectToAction("Index", "Home"); } AddErrors(result); } catch (Exception) { //When no database, sometimes database creation fails. AddErrors(new IdentityResult("Database creation failed, please restart the application!")); return View(model); } } // 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, NickName = userViewModel.NickName }; var adminresult = await UserManager.CreateAsync(user, userViewModel.Password); 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) { try { // Create a profile, password, and link the local login before signing in the user User user = new User(model.UserName); if (await IdentityStore.CreateLocalUser(user, model.Password)) { await AuthenticationManager.SignIn(HttpContext, user.Id, isPersistent: false); return RedirectToAction("Index", "Home"); } else { ModelState.AddModelError("", "Failed to register user name: " + model.UserName); } } catch (IdentityException e) { ModelState.AddModelError("", e.Message); } } // 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.UserName }; var result = await UserManager.CreateAsync(user, model.Password); if (result.Succeeded) { await SignInAsync(user, isPersistent: false); var service = new Service(); User register = new User(); register.Active = true; register.BirthYear = model.BirthYear; register.DisplayName = model.DisplayName; register.Email = model.Email; register.Gender = model.Gender; register.UserName = model.UserName; service.CreateUser(ref register); DisplayWelcomeMessage(register); return RedirectToAction("Index", "User"); } else { ModelState.AddModelError("UserName", "That username is already taken"); AddErrors(result); } } // If we got this far, something failed, redisplay form. return View(model); }
public async Task<ActionResult> Register(RegisterViewModel model) { var userValidator = UserManager.UserValidator as UserValidator<ApplicationUser>; userValidator.AllowOnlyAlphanumericUserNames = false; //not sure why these two lines work, but I can now use @symbol in username allowing for emails as userName. if (ModelState.IsValid) { var user = new ApplicationUser() { UserName = model.UserName, FirstName = model.FirstName, LastName = model.LastName, SuggestedAccount = model.SuggestedAccount, GradeLevel = model.GradeLevel}; var result = await UserManager.CreateAsync(user, model.Password); if (result.Succeeded) { UserManager.AddToRole(user.Id, model.SuggestedAccount); await SignInAsync(user, isPersistent: false); return RedirectToAction("Index", "Home"); } else { 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 confirmationToken = CreateConfirmationToken(); var user = new ApplicationUser { UserName = model.UserName, EmailAddress = model.EmailAddress, ConfirmationToken = confirmationToken, IsConfirmed = false }; var result = await UserManager.CreateAsync(user, model.Password); if (result.Succeeded) { //await SignInAsync(user, isPersistent: false); SendEmailConfirmation(model.EmailAddress, model.UserName, confirmationToken); return RedirectToAction("Index", "Home"); } AddErrors(result); } // If we got this far, something failed, redisplay form return View(model); }
public async Task<ActionResult> Register(RegisterViewModel model) { OglasController aleksaoglas = new OglasController(); 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); var korisnik = new Korisnik() { IDKorisnik = user.Id, eMail = user.UserName, MailStize = 0 }; aleksaoglas.baza.Korisnik.Add(korisnik); aleksaoglas.baza.SaveChanges(); return RedirectToAction("Login", "Account"); } else { AddErrors(result); } } // If we got this far, something failed, redisplay form return View(model); }
public ActionResult Register(RegisterViewModel viewModel) { var anyUser = userService.GetAllUserEntities().Any(u => u.Login==viewModel.Login); if (anyUser) { ModelState.AddModelError("", "User with this address already registered."); return View(viewModel); } if (ModelState.IsValid) { var membershipUser = ((CustomMembershipProvider)Membership.Provider) .CreateUser(viewModel.Login, viewModel.Password,viewModel.Name); if (membershipUser != null) { FormsAuthentication.SetAuthCookie(viewModel.Login, false); TempData["user"] = userService.GetByLogin(viewModel.Login).ToPlUser(); return RedirectToAction("Index", "Home"); } else { ModelState.AddModelError("", "Error registration."); } } return View(viewModel); }
public async Task<User> RegisterAsync (RegisterViewModel registerViewModel) { // client = clientFactory.CreateHttpClient (); HttpClient client = new HttpClient (); client.BaseAddress = new Uri("http://spotvox.azurewebsites.net/"); client.DefaultRequestHeaders.Clear (); client.DefaultRequestHeaders.Accept.Clear (); client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); using (client) { string userJson = JsonConvert.SerializeObject (registerViewModel); HttpContent content = new StringContent (userJson, Encoding.UTF8, "application/json"); HttpResponseMessage response = await client.PostAsync ("api/account/register", content); if (response.IsSuccessStatusCode) { string jsonMessage; using (Stream responseStream = await response.Content.ReadAsStreamAsync ()) { jsonMessage = new StreamReader (responseStream).ReadToEnd (); } User user = (User)JsonConvert.DeserializeObject (jsonMessage, typeof(User)); LoginViewModel loginModel = new LoginViewModel (); loginModel.Email = user.Email; loginModel.Password = registerViewModel.Password; user = await LoginAsync(loginModel); return user; } else { return null; } } }
public async Task<ActionResult> Register(RegisterViewModel model) { if (ModelState.IsValid) { var user = new ApplicationUser { UserName = model.UserName, MoneyBirdAccountName = model.MoneyBirdAccountName, MoneyBirdUserName = model.MoneyBirdUserName, MoneyBirdPassword = model.MoneyBirdPassword }; var result = await UserManager.CreateAsync(user, model.Password); if (result.Succeeded) { await SignInAsync(user, isPersistent: false); return RedirectToAction("Index", "Home"); } AddErrors(result); } // If we got this far, something failed, redisplay form return View(model); }
public async Task<ActionResult> Create() { //Get the list of Roles var model = new RegisterViewModel(); model.CategoriesList = new SelectList(await CategoryManager.Categories.ToListAsync(), "Name", "Name"); return View(model); }
public async Task<ActionResult> Register(RegisterViewModel model) { using (var context = new ApplicationDbContext()) { if (ModelState.IsValid) { var user = new ApplicationUser() { UserName = model.UserName, Name = model.Name, LastName = model.LastName, Status = "Active" }; var result = await UserManager.CreateAsync(user, model.Password); if (result.Succeeded) { var roleStore = new RoleStore<IdentityRole>(context); var roleManager = new RoleManager<IdentityRole>(roleStore); var userStore = new UserStore<ApplicationUser>(context); var userManager = new UserManager<ApplicationUser>(userStore); userManager.AddToRole(user.Id, "SimpleUser"); await SignInAsync(user, isPersistent: false); return RedirectToAction("Index", "Home"); } else { AddErrors(result); } } } // If we got this far, something failed, redisplay form return View(model); }
public async Task<ActionResult> Register(RegisterViewModel model) { if (ModelState.IsValid) { // Create a local login before signing in the user var user = new ApplicationUser() { UserName = model.UserName, DisplayName = model.DisplayName, FacebookProfile = model.FacebookProfile, }; var result = await IdentityManager.Users.CreateLocalUserAsync(user, model.Password); if (result.Success) { await IdentityManager.Authentication.SignInAsync(AuthenticationManager, user.Id, isPersistent: false); return RedirectToAction("Index", "Home"); } else { 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 MailPigUser { UserName = model.Email, Email = model.Email, Oib = model.Oib, UsedForCommercialPurposes = model.UsedForCommercialPurposes, OrganisationName = model.OrganisationName }; IdentityResult result = await UserManager.CreateAsync(user, model.Password); if (result.Succeeded) { await SignInAsync(user, isPersistent: 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", "Dashboard"); } else { 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.UserName }; user.Email = model.Email; user.ConfirmedEmail = false; var result = await UserManager.CreateAsync(user, model.Password); if (result.Succeeded) { System.Net.Mail.MailMessage m = new System.Net.Mail.MailMessage( new System.Net.Mail.MailAddress("*****@*****.**", "Web Registration"), new System.Net.Mail.MailAddress(user.Email)); m.Subject = "Email confirmation"; m.Body = string.Format("Dear {0}<BR/>Thank you for your registration, please click on the below link to complete your registration: <a href=\"{1}\" title=\"User Email Confirm\">{1}</a>", user.UserName, Url.Action("ConfirmEmail", "Account", new { Token = user.Id, Email = user.Email }, Request.Url.Scheme)); m.IsBodyHtml = true; System.Net.Mail.SmtpClient smtp = new System.Net.Mail.SmtpClient("smtp.mydomain.com"); smtp.Credentials = new System.Net.NetworkCredential("*****@*****.**", "password"); smtp.EnableSsl = true; smtp.Send(m); return RedirectToAction("Confirm", "Account", new { Email = user.Email }); } else { AddErrors(result); } } // If we got this far, something failed, redisplay form return View(model); }
public async Task<ActionResult> Register(RegisterViewModel model) { if (model.UserName.Length > 16 || model.UserName.Length < 6) { ModelState.AddModelError("UserName", "The username should be between 6 and 16 characters long."); } if (ModelState.IsValid) { // Create a local login before signing in the user var user = new ApplicationUser { UserName = model.UserName, Points = 10}; var result = await IdentityManager.Users.CreateLocalUserAsync(user, model.Password); if (result.Success) { await IdentityManager.Authentication.SignInAsync(AuthenticationManager, user.Id, isPersistent: false); return RedirectToAction("Index", "Home"); } else { AddErrors(result); } } // If we got this far, something failed, redisplay form return View(model); }
public async Task<ActionResult> Register(RegisterViewModel model) { if (ModelState.IsValid) { // Create a local login before signing in the user var user = new ApplicationUser { UserName = model.UserName, FirstName = model.FirstName, LastName = model.LastName, Email = model.Email, PhotoUrl = (model.Photo ?? @"../../img/Avatars/default-avatar.jpg") }; var result = await IdentityManager.Users.CreateLocalUserAsync(user, model.Password); if (result.Success) { await IdentityManager.Authentication.SignInAsync(AuthenticationManager, user.Id, isPersistent: false); return RedirectToAction("Index", "Home"); } else { AddErrors(result); } } // If we got this far, something failed, redisplay form return View(model); }
public ActionResult Register(RegisterViewModel model) { if (!ModelState.IsValid) return Json(new ServiceOperationResult(false, Main.InvalidForm), JsonRequestBehavior.AllowGet); return Json(PiServices.UserService.AddUser(model), JsonRequestBehavior.AllowGet); }
public async Task<ActionResult> Register(RegisterViewModel model) { if (ModelState.IsValid) { var user = new User() { UserName = model.UserName, FirstName = model.FirstName, LastName = model.LastName, Email = model.Email, Phone = model.Phone, CellPhone = model.CellPhone, Gender = model.Gender, Birthday = model.Birthday, Address = model.Address, CreationDate = DateTime.UtcNow.AddHours(-5) }; var result = await UserManager.CreateAsync(user, model.Password); if (result.Succeeded) { await SignInAsync(user, isPersistent: false); return RedirectToAction("Index", "Home"); } else { AddErrors(result); } } // Si llegamos a este punto, es que se ha producido un error y volvemos a mostrar el formulario return View(model); }
public async Task<ActionResult> Register(RegisterViewModel model) { if (ModelState.IsValid) { CreateResponse response = await this.Membership.CreateAsync(new CreateRequest() { UserName = model.UserName, Password = model.Password, AuthenticationType = DataContract.AuthenticationTypeEnum.ApplicationCookie }); if (response.Success) { ClaimsIdentity identity = response.ClaimIdentity.ConvertToClaimsIdentity(); SignInAsync(identity, IsPersistent: false); return RedirectToAction("Index", "Home"); } else { AddErrors(response.Errors); } } // If we got this far, something failed, redisplay form return View(model); }
public async Task<ActionResult> Create(RegisterViewModel model) { if (ModelState.IsValid) { var succeded = true; var user = new CustomUser { UserName = model.Email, Email = model.Email }; var adminresult = await UserManager.CreateAsync(user, model.Password); if (!adminresult.Succeeded) { ModelState.AddModelError("", adminresult.Errors.First()); } else { user = await UserManager.FindByEmailAsync(model.Email); var result = await UserManager.AddToCategoryAsync(user.Id, model.Category); if (!result.Succeeded) { ModelState.AddModelError("", result.Errors.First()); } else { return RedirectToAction("Index"); } } } model.CategoriesList = new SelectList(await CategoryManager.Categories.ToListAsync(), "Name", "Name"); return View(model); }
public async Task<ActionResult> Register(RegisterViewModel model) { if (ModelState.IsValid) { ServiceUser serviceUser = new ServiceUser { Name = model.UserName, RoleId = 2 }; ServiceUserRepository.Instance.AddUser(serviceUser); 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); }
public async Task<ActionResult> Register(RegisterViewModel model) { if (ModelState.IsValid) { if (await RecaptchaIsValid(Request.Form["g-recaptcha-response"])) //if(true) { var user = new ApplicationUser() { UserName = model.UserName }; var result = UserManager.Create(user, model.Password); if (result.Succeeded) { await SignInAsync(user, isPersistent: false); return RedirectToAction("Index", "Home"); } else { AddErrors(result); } } ModelState.AddModelError( "invalid-recaptcha-response", "Please answer the recaptcha challenge."); } return View(); }
public async Task<ActionResult> Join(string JoinCode) { //set up the confirmation page so the user can confim he wants to change households //might also need a view model for this page var invitation = await db.Invitations.FirstOrDefaultAsync(i => i.JoinCode.ToString() == JoinCode); if (invitation != null) { var model = new RegisterViewModel { HouseholdId = invitation.Household.Id, HouseholdName = invitation.Household.Name, Email = invitation.ToEmail }; var user = db.Users.FirstOrDefault(u => u.Email == invitation.ToEmail); if (user != null) { //then user exists / populate user info model.FirstName = user.FirstName; model.LastName = user.LastName; } return View(model); } else { return RedirectToAction("Login", "Account", new {message = "Unauthorized"}); } }
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) { UserService.AddUser(new User { FirstName = model.FirstName, LastName = model.LastName, Username = model.UserName, Password = UserManager.PasswordHasher.HashPassword(model.Password), Email = model.EmailAddress, IsAdmin = false }); await SignInAsync(user, isPersistent: false); return RedirectToAction("Home", "User"); } else { 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.UserName }; var result = await UserManager.CreateAsync(user, model.Password); if (result.Succeeded) { if (user.Roles.Count == 0) { UserManager.AddToRole(user.Id, "User"); } await SignInAsync(user, isPersistent: false); return RedirectToAction("Index", "Home"); } else { AddErrors(result); } } // If we got this far, something failed, redisplay form return View(model); }
public async Task<IActionResult> Register(RegisterViewModel model) { if (ModelState.IsValid) { var user = new ApplicationUser { UserName = model.Email, Email = model.Email, TimeZoneId = _generalSettings.Value.DefaultTimeZone }; var result = await _userManager.CreateAsync(user, model.Password); if (result.Succeeded) { var token = await _userManager.GenerateEmailConfirmationTokenAsync(user); var callbackUrl = Url.Action(new UrlActionContext { Action = nameof(ConfirmEmail), Controller = "Admin", Values = new { userId = user.Id, token = token }, Protocol = Request.Scheme }); await _mediator.SendAsync(new SendConfirmAccountEmail { Email = model.Email, CallbackUrl = callbackUrl }); return RedirectToAction(nameof(DisplayEmail), "Admin"); } 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.UserName }; user.UserInfo = new ApplicationUserInfo { ApplicationUser = user }; Image defaultAvatar = new Image { Name = "defaultAvatar" }; user.UserInfo.Avatar = defaultAvatar; db.SaveChanges(); var result = await UserManager.CreateAsync(user, model.Password); if (result.Succeeded) { db.SaveChanges(); await SignInAsync(user, isPersistent: false); return RedirectToAction("Index", "Home"); } else { 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) { // ############################################################ // Claims-aware "Register" method to handle user-submitted data // GivenName and Surname are claims - we gather them on the HTML Form // The RegisterViewModel class was modified, to add these properties // We also configure some "role" claims // Add claims await UserManager.AddClaimAsync(user.Id, new Claim(ClaimTypes.Email, model.Email)); await UserManager.AddClaimAsync(user.Id, new Claim(ClaimTypes.GivenName, model.GivenName)); await UserManager.AddClaimAsync(user.Id, new Claim(ClaimTypes.Surname, model.Surname)); await UserManager.AddClaimAsync(user.Id, new Claim(ClaimTypes.Role, "User")); // Role claims processing // In this web app template, the user submits zero or more claims, as strings // We will go through the collection, and add each one foreach (var role in model.Roles) { await UserManager.AddClaimAsync(user.Id, new Claim(ClaimTypes.Role, role.Trim())); } 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("Details", "Account")); // ############################################################ } AddErrors(result); } // If we got this far, something failed, redisplay form var form = AutoMapper.Mapper.Map <RegisterViewModelForm>(model); Manager m = new Manager(); var roles = m.RoleClaimGetAllStrings(); form.RoleList = new MultiSelectList( items: roles, selectedValues: model.Roles); return(View(form)); }
private ActionResult RegisterView(RegisterViewModel model) { ViewBag.IsMultiTenancyEnabled = _multiTenancyConfig.IsEnabled; return(View("Register", model)); }
/// <summary> /// Create instagram user. /// </summary> /// <param name="connection"></param> /// <param name="userId"></param> /// <param name="userInfo"></param> public static void CreateInstagramUser(IDbConnection connection, string userId, RegisterViewModel userInfo) { var p = new DynamicParameters(); p.Add("A_Id", userId); p.Add("A_UserName", userInfo.User_Name); p.Add("A_Email", userInfo.Email); p.Add("A_FullName", userInfo.Full_Name); connection.Execute("CreateInstagramUser", p, commandType: CommandType.StoredProcedure); }
public async Task <IdentityResult> RegisterAccount(RegisterViewModel model) { var user = new ApplicationUser { UserName = model.Email, Email = model.Email, FirstName = model.FirstName, LastName = model.LastName, RegisterDate = DateTime.Now, RegisterIP = System.Web.HttpContext.Current.Request.GetVisitorIP(), LastAccessDate = DateTime.Now, LastAccessIP = System.Web.HttpContext.Current.Request.GetVisitorIP() }; 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>"); // Send Message var roleAdministrator = await RoleManager.FindByNameAsync(BeYourMarket.Model.Enum.Enum_UserRole.Administrator.ToString()); var administrator = roleAdministrator.Users.FirstOrDefault(); var message = new MessageSendModel() { UserFrom = administrator.UserId, UserTo = user.Id, Subject = HttpContext.ParseAndTranslate(string.Format("[[[Welcome to {0}!]]]", CacheHelper.Settings.Name)), Body = HttpContext.ParseAndTranslate(string.Format("[[[Hi, Welcome to {0}! I am happy to assist you if you has any questions.]]]", CacheHelper.Settings.Name)) }; await MessageHelper.SendMessage(message); // Send an email with this link string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id); var urlHelper = new UrlHelper(System.Web.HttpContext.Current.Request.RequestContext); var callbackUrl = urlHelper.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: System.Web.HttpContext.Current.Request.Url.Scheme); var emailTemplateQuery = await _emailTemplateService.Query(x => x.Slug.ToLower() == "signup").SelectAsync(); var emailTemplate = emailTemplateQuery.FirstOrDefault(); if (emailTemplate != null) { dynamic email = new Postal.Email("Email"); email.To = user.Email; email.From = CacheHelper.Settings.EmailAddress; email.Subject = emailTemplate.Subject; email.Body = emailTemplate.Body; email.CallbackUrl = callbackUrl; EmailHelper.SendEmail(email); } } return(result); }
public async Task <ActionResult> Register(RegisterViewModel model) { try { ExternalLoginInfo externalLoginInfo = null; if (model.IsExternalLogin) { externalLoginInfo = await _signInManager.GetExternalLoginInfoAsync(); if (externalLoginInfo == null) { throw new Exception("Can not external login!"); } model.UserName = model.EmailAddress; model.Password = Authorization.Users.User.CreateRandomPassword(); } else { if (model.UserName.IsNullOrEmpty() || model.Password.IsNullOrEmpty()) { throw new UserFriendlyException(L("FormIsNotValidMessage")); } } var user = await _userRegistrationManager.RegisterAsync( model.Name, model.Surname, model.EmailAddress, model.UserName, model.Password, true // Assumed email address is always confirmed. Change this if you want to implement email confirmation. ); // Getting tenant-specific settings var isEmailConfirmationRequiredForLogin = await SettingManager.GetSettingValueAsync <bool>(AbpZeroSettingNames.UserManagement.IsEmailConfirmationRequiredForLogin); if (model.IsExternalLogin) { Debug.Assert(externalLoginInfo != null); if (string.Equals(externalLoginInfo.Principal.FindFirstValue(ClaimTypes.Email), model.EmailAddress, StringComparison.OrdinalIgnoreCase)) { user.IsEmailConfirmed = true; } user.Logins = new List <UserLogin> { new UserLogin { LoginProvider = externalLoginInfo.LoginProvider, ProviderKey = externalLoginInfo.ProviderKey, TenantId = user.TenantId } }; } await _unitOfWorkManager.Current.SaveChangesAsync(); Debug.Assert(user.TenantId != null); var tenant = await _tenantManager.GetByIdAsync(user.TenantId.Value); // Directly login if possible if (user.IsActive && (user.IsEmailConfirmed || !isEmailConfirmationRequiredForLogin)) { AbpLoginResult <Tenant, User> loginResult; if (externalLoginInfo != null) { loginResult = await _logInManager.LoginAsync(externalLoginInfo, tenant.TenancyName); } else { loginResult = await GetLoginResultAsync(user.UserName, model.Password, tenant.TenancyName); } if (loginResult.Result == AbpLoginResultType.Success) { await _signInManager.SignInAsync(loginResult.Identity, false); return(Redirect(GetAppHomeUrl())); } Logger.Warn("New registered user could not be login. This should not be normally. login result: " + loginResult.Result); } return(View("RegisterResult", new RegisterResultViewModel { TenancyName = tenant.TenancyName, NameAndSurname = user.Name + " " + user.Surname, UserName = user.UserName, EmailAddress = user.EmailAddress, IsEmailConfirmed = user.IsEmailConfirmed, IsActive = user.IsActive, IsEmailConfirmationRequiredForLogin = isEmailConfirmationRequiredForLogin })); } catch (UserFriendlyException ex) { ViewBag.ErrorMessage = ex.Message; return(View("Register", model)); } }
public virtual async Task <ActionResult> Register(RegisterViewModel model) { try { //Get tenancy name and tenant if (!_multiTenancyConfig.IsEnabled) { model.TenancyName = Tenant.DefaultTenantName; } else if (model.TenancyName.IsNullOrEmpty()) { throw new UserFriendlyException(L("TenantNameCanNotBeEmpty")); } CurrentUnitOfWork.SetTenantId(null); var tenant = await GetActiveTenantAsync(model.TenancyName); CurrentUnitOfWork.SetTenantId(tenant.Id); //Create user var user = new User { TenantId = tenant.Id, Name = model.Name, Surname = model.Surname, EmailAddress = model.EmailAddress, IsActive = true }; //Get external login info if possible ExternalLoginUserInfo externalLoginInfo = null; if (model.IsExternalLogin) { externalLoginInfo = await HttpContext.Authentication.GetExternalLoginUserInfo(model.ExternalLoginAuthSchema); if (externalLoginInfo == null) { throw new ApplicationException("Can not external login!"); } user.Logins = new List <UserLogin> { new UserLogin { LoginProvider = externalLoginInfo.LoginInfo.LoginProvider, ProviderKey = externalLoginInfo.LoginInfo.ProviderKey, TenantId = tenant.Id } }; model.UserName = model.UserName; model.Password = Users.User.CreateRandomPassword(); if (string.Equals(externalLoginInfo.EmailAddress, model.EmailAddress, StringComparison.InvariantCultureIgnoreCase)) { user.IsEmailConfirmed = true; } } else { if (model.UserName.IsNullOrEmpty() || model.Password.IsNullOrEmpty()) { throw new UserFriendlyException(L("FormIsNotValidMessage")); } } user.UserName = model.UserName; user.Password = new PasswordHasher().HashPassword(model.Password); //Add default roles user.Roles = new List <UserRole>(); foreach (var defaultRole in await _roleManager.Roles.Where(r => r.IsDefault).ToListAsync()) { user.Roles.Add(new UserRole { RoleId = defaultRole.Id }); } //Save user CheckErrors(await _userManager.CreateAsync(user)); await _unitOfWorkManager.Current.SaveChangesAsync(); //Directly login if possible if (user.IsActive) { AbpLoginResult <Tenant, User> loginResult; if (externalLoginInfo != null) { loginResult = await _logInManager.LoginAsync(externalLoginInfo.LoginInfo, tenant.TenancyName); } else { loginResult = await GetLoginResultAsync(user.UserName, model.Password, tenant.TenancyName); } if (loginResult.Result == AbpLoginResultType.Success) { await SignInAsync(loginResult.User, loginResult.Identity); return(Redirect(Url.Action("Index", "Home"))); } Logger.Warn("New registered user could not be login. This should not be normally. login result: " + loginResult.Result); } //If can not login, show a register result page return(View("RegisterResult", new RegisterResultViewModel { TenancyName = tenant.TenancyName, NameAndSurname = user.Name + " " + user.Surname, UserName = user.UserName, EmailAddress = user.EmailAddress, IsActive = user.IsActive })); } catch (UserFriendlyException ex) { ViewBag.IsMultiTenancyEnabled = _multiTenancyConfig.IsEnabled; ViewBag.ErrorMessage = ex.Message; return(View("Register", model)); } }
public void SetUp() { assembler = Substitute.For <IUserAssembler>(); dataAccess = Substitute.For <IUserDataAccess>(); errorHelper = Substitute.For <IErrorHelper>(); errorHelper.Create(Arg.Any <Exception>(), Arg.Any <string>(), Arg.Any <Type>(), Arg.Any <string>()) .Returns(new ResponseErrorWrapper()); errorHelper.Create(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <Type>(), Arg.Any <string>()) .Returns(new ResponseErrorWrapper()); validRegisterUserRequest = new RegisterUserRequest { DateOfBirth = DateTime.Now, EmailAddress = "TEST", FirstName = "TEST", LastName = "TEST", Password = "******", Username = "******" }; validValidateUserResponse = new ValidateUserResponse { LoginSuccess = true, RequestReference = Guid.NewGuid(), User = new UserProxy { EmailAddress = "TEST", DateOfBirth = DateTime.Now, FirstName = "TEST", Id = Guid.NewGuid(), LastName = "TEST" } }; invalidValidateUserResponse = new ValidateUserResponse { Errors = { new ResponseErrorWrapper() } }; validValidateUserRequest = new ValidateUserRequest { EmailAddress = "TEST", Password = "******", Username = "******" }; invalidValidateUserRequest = new ValidateUserRequest { EmailAddress = string.Empty, Password = string.Empty, Username = string.Empty }; validLoginViewModel = new LoginViewModel { EmailAddress = "TEST", Password = "******", ReturnUrl = "TEST" }; invalidLoginViewModel = new LoginViewModel { EmailAddress = string.Empty, Password = string.Empty, ReturnUrl = string.Empty }; invalidRegisterViewModel = new RegisterViewModel { AcceptTermsAndConditions = false, ConfirmPassword = string.Empty, DateOfBirth = DateTime.MinValue, EmailAddress = string.Empty, FirstName = string.Empty, LastName = string.Empty, Password = string.Empty }; validRegisterUserResponse = new RegisterUserResponse { RequestReference = Guid.NewGuid(), RegisterSuccess = true }; invalidRegisterUserResponse = new RegisterUserResponse { RequestReference = Guid.NewGuid(), Errors = { new ResponseErrorWrapper() }, RegisterSuccess = false }; validRegisterViewModel = new RegisterViewModel { AcceptTermsAndConditions = true, ConfirmPassword = "******", DateOfBirth = DateTime.Now, EmailAddress = "TEST", FirstName = "TEST", LastName = "TEST", Password = "******" }; invalidRegisterUserRequest = new RegisterUserRequest { DateOfBirth = DateTime.MinValue, EmailAddress = string.Empty, FirstName = string.Empty, LastName = string.Empty, Password = string.Empty, Username = string.Empty }; assembler.NewRegisterUserRequest(invalidRegisterViewModel).Returns(invalidRegisterUserRequest); assembler.NewRegisterUserRequest(validRegisterViewModel).Returns(validRegisterUserRequest); assembler.NewRegisterUserRequest(null).Throws(new Exception("TEST EXCEPTION")); assembler.NewValidateUserRequest(invalidLoginViewModel).Returns(invalidValidateUserRequest); assembler.NewValidateUserRequest(validLoginViewModel).Returns(validValidateUserRequest); assembler.NewValidateUserRequest(null).Throws(new Exception("TEST EXCEPTION")); assembler.NewClaimsIdentity(validValidateUserResponse).Returns(new ClaimsIdentity()); dataAccess.RegisterUser(invalidRegisterUserRequest).Returns(invalidRegisterUserResponse); dataAccess.RegisterUser(validRegisterUserRequest).Returns(validRegisterUserResponse); dataAccess.ValidateUser(invalidValidateUserRequest).Returns(invalidValidateUserResponse); dataAccess.ValidateUser(validValidateUserRequest).Returns(validValidateUserResponse); orchestrator = new UserOrchestrator(assembler, dataAccess, errorHelper); }
public async Task <ActionResult> Register(RegisterViewModel model) { if (model.Role == "Patient") { if (ModelState.IsValid) { var user = new Patient { UserName = model.Email, Email = model.Email, FirstName = model.FirstName, LastName = model.LastName, Password = model.Password, PhoneNumber = model.PhoneNumber, PhoneNumberConfirmed = true, Gender = model.Gender, BirthDate = model.BirthDate, City = model.City, HomeAddress = model.HomeAddress, CivilStatus = model.CivilStatus, Enabled = true, RegistrationDate = DateTime.UtcNow.Date, Profession = model.Profession, Allergies = model.Allergies, SpecialReq = model.SpecialReq }; var result = await UserManager.CreateAsync(user, model.Password); if (result.Succeeded) { // await SignInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false); // Pour plus d'informations sur l'activation de la confirmation du compte et la réinitialisation du mot de passe, consultez http://go.microsoft.com/fwlink/?LinkID=320771 // Envoyer un message électronique avec ce lien // 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, "Confirmez votre compte", "Confirmez votre compte en cliquant <a href=\"" + callbackUrl + "\">ici</a>"); return(RedirectToAction("Login", "Account")); } AddErrors(result); } // Si nous sommes arrivés là, un échec s’est produit. Réafficher le formulaire return(View(model)); } else if (model.Role == "Doctor") { if (ModelState.IsValid) { var user = new Doctor { UserName = model.Email, Email = model.Email, FirstName = model.FirstName, LastName = model.LastName, Password = model.Password, PhoneNumber = model.PhoneNumber, PhoneNumberConfirmed = true, Gender = model.Gender, BirthDate = model.BirthDate, City = model.City, HomeAddress = model.HomeAddress, CivilStatus = model.CivilStatus, Enabled = true, RegistrationDate = DateTime.UtcNow.Date, Speciality = model.Speciality, Location = model.Location }; if (model.Surgeon == "Yes") { user.Surgeon = true; } else if (model.Surgeon == "No") { user.Surgeon = false; } var result = await UserManager.CreateAsync(user, model.Password); if (result.Succeeded) { // await SignInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false); // Pour plus d'informations sur l'activation de la confirmation du compte et la réinitialisation du mot de passe, consultez http://go.microsoft.com/fwlink/?LinkID=320771 // Envoyer un message électronique avec ce lien // 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, "Confirmez votre compte", "Confirmez votre compte en cliquant <a href=\"" + callbackUrl + "\">ici</a>"); return(RedirectToAction("Login", "Account")); } AddErrors(result); } // Si nous sommes arrivés là, un échec s’est produit. Réafficher le formulaire return(View(model)); } else { if (ModelState.IsValid) { var user = new User { UserName = model.Email, Email = model.Email, FirstName = model.FirstName, LastName = model.LastName, Password = model.Password, PhoneNumber = model.PhoneNumber, PhoneNumberConfirmed = true, Gender = model.Gender, BirthDate = model.BirthDate, City = model.City, HomeAddress = model.HomeAddress, CivilStatus = model.CivilStatus, Enabled = true, RegistrationDate = DateTime.UtcNow.Date }; var result = await UserManager.CreateAsync(user, model.Password); if (result.Succeeded) { // await SignInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false); // Pour plus d'informations sur l'activation de la confirmation du compte et la réinitialisation du mot de passe, consultez http://go.microsoft.com/fwlink/?LinkID=320771 // Envoyer un message électronique avec ce lien // 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, "Confirmez votre compte", "Confirmez votre compte en cliquant <a href=\"" + callbackUrl + "\">ici</a>"); return(RedirectToAction("Login", "Account")); } AddErrors(result); } // Si nous sommes arrivés là, un échec s’est produit. Réafficher le formulaire return(View(model)); } }
public virtual async Task <UserLoginResult> TryRegister( RegisterViewModel model, ModelStateDictionary modelState, HttpContext httpContext, IHandleCustomRegistration customRegistration ) { var template = new LoginResultTemplate(); IUserContext userContext = null; var userName = !string.IsNullOrWhiteSpace(model.Username) ? model.Username : await _userManager.SuggestLoginNameFromEmail(_userManager.Site.Id, model.Email); var userNameAvailable = await _userManager.LoginIsAvailable(Guid.Empty, userName); if (!userNameAvailable) { userName = await _userManager.SuggestLoginNameFromEmail(_userManager.Site.Id, model.Email); } var user = new SiteUser { SiteId = _userManager.Site.Id, UserName = userName, Email = model.Email, FirstName = model.FirstName, LastName = model.LastName, DisplayName = model.DisplayName, LastLoginUtc = DateTime.UtcNow, AccountApproved = _userManager.Site.RequireApprovalBeforeLogin ? false : true }; await customRegistration.ProcessUserBeforeCreate(user, httpContext); if (model.DateOfBirth.HasValue) { user.DateOfBirth = model.DateOfBirth.Value; } if (!string.IsNullOrWhiteSpace(_userManager.Site.RegistrationAgreement)) { if (model.AgreeToTerms) { user.AgreementAcceptedUtc = DateTime.UtcNow; } } var result = await _userManager.CreateAsync(user, model.Password); if (result.Succeeded) { template.User = user; template.IsNewUserRegistration = true; await _loginRulesProcessor.ProcessAccountLoginRules(template); } else { foreach (var error in result.Errors) { modelState.AddModelError(string.Empty, error.Description); } } if (template.RejectReasons.Count == 0 && user != null && template.SignInResult == SignInResult.Failed && // failed is initial state, could have been changed to lockedout result.Errors.Count <IdentityError>() == 0 ) { await _signInManager.SignInAsync(user, isPersistent : false); template.SignInResult = SignInResult.Success; } if (template.User != null) { userContext = new UserContext(template.User); } return(new UserLoginResult( template.SignInResult, template.RejectReasons, userContext, template.IsNewUserRegistration, template.MustAcceptTerms, template.NeedsAccountApproval, template.NeedsEmailConfirmation, template.EmailConfirmationToken, template.NeedsPhoneConfirmation )); }
public async Task <IActionResult> Create(RegisterViewModel registerViewModel) { if (!User.Identity.IsAuthenticated) { return(RedirectToAction("Login", "Account")); } if (!User.IsInRole("Admin")) { return(RedirectToAction("Login", "Account")); } if (!ModelState.IsValid) { ViewBag.Active = "Home"; return(View(registerViewModel)); } AppUser newUser; if (registerViewModel.Photo != null) { if (!registerViewModel.Photo.IsImage()) { ViewBag.Active = "Home"; ModelState.AddModelError("Photo", "File type should be image"); return(View(registerViewModel)); } string filename = await registerViewModel.Photo.SaveAsync(_env.WebRootPath); registerViewModel.PhotoURL = filename; newUser = new AppUser { Firstname = registerViewModel.Firstname.Trim(), Lastname = registerViewModel.Lastname.Trim(), Email = registerViewModel.Email.Trim(), UserName = registerViewModel.Username.Trim(), PhoneNumber = registerViewModel.Phone.Trim(), PhotoURL = registerViewModel.PhotoURL }; } else { newUser = new AppUser { Firstname = registerViewModel.Firstname.Trim(), Lastname = registerViewModel.Lastname.Trim(), Email = registerViewModel.Email.Trim(), UserName = registerViewModel.Username.Trim(), PhoneNumber = registerViewModel.Phone.Trim(), PhotoURL = "Person-icon.png" }; } IdentityResult identityResult = await _usermanager.CreateAsync(newUser, registerViewModel.Password); if (!identityResult.Succeeded) { foreach (var error in identityResult.Errors) { ModelState.AddModelError("", error.Description); } ViewBag.Active = "Home"; return(View(registerViewModel)); } //add default member role to user await _usermanager.AddToRoleAsync(newUser, StaticUsers.Member); ViewBag.Active = "Home"; return(RedirectToAction("Index")); }
public async Task <ActionResult> Register(RegisterViewModel model) { try { if (model == null) { return(new HttpStatusCodeResult(HttpStatusCode.BadRequest)); } if (ModelState.IsValid) { var user = new ApplicationUser { UserName = model.Fullname, Email = model.Email }; var result = await UserManager.CreateAsync(user, model.Password); if (result.Succeeded) { await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false); //Assign Role to user Here await this.UserManager.AddToRoleAsync(user.Id, model.RoleName); //Ends Here return(RedirectToAction("Index", "Users")); } AddErrors(result); } else { ModelState.AddModelError(string.Empty, "Error: Failed to create the user. Check password requirements."); switch (model.RoleName) { case "Super Admin": return(RedirectToAction("Login", "Account")); case "Sales Admin": return(RedirectToAction("RegisterSalesAdmin", "Account")); default: break; } //return View(model); } } catch (Exception ex) { Console.WriteLine("Error Message:" + ex.Message); } // If we got this far, something failed, redisplay form return(View(model)); }