public JsonResult Register(RegisterUserInputModel inputModel) { try { Assert.ArgumentNotNull(inputModel, "RegisterInputModel"); RegisterBaseJsonResult result = new RegisterBaseJsonResult(); this.ValidateModel(result); if (result.HasErrors) { return(Json(result, JsonRequestBehavior.AllowGet)); } var anonymousVisitorId = this.CurrentVisitorContext.UserId; var response = this.AccountManager.RegisterUser(this.CurrentStorefront, inputModel); if (response.ServiceProviderResult.Success && response.Result != null) { result.Initialize(response.Result); this.AccountManager.Login(CurrentStorefront, CurrentVisitorContext, anonymousVisitorId, response.Result.UserName, inputModel.Password, false); } else { result.SetErrors(response.ServiceProviderResult); } return(Json(result)); } catch (Exception e) { CommerceLog.Current.Error("Register", this, e); return(Json(new BaseJsonResult("Register", e), JsonRequestBehavior.AllowGet)); } }
public async Task <IActionResult> Register([FromBody] RegisterUserInputModel registerModel) { if (!this.ModelState.IsValid) { var errors = this.ExtractModelErrors(this.ModelState); return(this.BadRequest(errors)); } try { var response = await this.accountService.RegisterUser(registerModel); if (!response.Succeeded) { this.AddErrors(response); return(this.BadRequest(this.ModelState)); } return(this.Ok(new List <int>() { 1, 2, 3, 4, 5 })); } catch (Exception ex) { return(this.BadRequest(ex.Message)); } }
public async Task RegisterAsync(RegisterUserInputModel model) { var userExists = await this.userManager.FindByEmailAsync(model.Email) != null; if (userExists) { throw new EntityExistsException("User"); } var newUser = new User { Id = Guid.NewGuid().ToString(), Email = model.Email, UserName = model.Username, NormalizedEmail = model.Email.ToUpper(), NormalizedUserName = model.Username.ToUpper(), UserRoles = new List <UserRole> { new() { RoleId = RoleIds.Client } } }; newUser.PasswordHash = new PasswordHasher <User>().HashPassword(newUser, model.Password); this.repo.Add(newUser); this.repo.Save(); }
public async Task <IdentityResult> RegisterUser(RegisterUserInputModel model) { //TODO: Profile picture, response if registration exists this.CheckModelForNull(model); if (this.ValidateEmail(model.Email) && this.ValidateUsername(model.Username)) { var user = new ApplicationUser() { UserName = model.Username, Email = model.Email }; var result = await this.UserManager.CreateAsync(user, model.Password); if (result.Succeeded) { var vacationUser = new User() { Username = model.Username, ProfilePicture = null, Email = model.Email, ApplicationUser = user }; this.Data.User.Add(vacationUser); this.Data.SaveChanges(); return(result); } throw new Exception(string.Join("; ", result.Errors)); } throw new Exception("Invalid data."); }
public HttpResponse Register(RegisterUserInputModel input) { if (String.IsNullOrEmpty(input.Username) || input.Username.Length < 5 || input.Username.Length > 20) { return(this.Error("Invalid Username")); } if (!userService.IsUsernameAvailable(input.Username)) { return(this.Error("This username is already taken")); } if (string.IsNullOrEmpty(input.Email) || !new EmailAddressAttribute().IsValid(input.Email)) { return(this.Error("Invalid email")); } if (!userService.IsEmailAvailable(input.Email)) { return(this.Error("This email is already taken.")); } if (string.IsNullOrEmpty(input.Password) || input.Password.Length < 6 || input.Password.Length > 20) { return(this.Error("Password is incorrect")); } if (input.Password != input.ConfirmPassword) { return(this.Error("Passowrds dont match")); } this.userService.CreateUser(input.Username, input.Email, input.Password); return(this.Redirect("/Users/Login")); }
public JsonResult Register(RegisterUserInputModel inputModel) { try { Assert.ArgumentNotNull(inputModel, nameof(inputModel)); var result = this.CreateJsonResult <RegisterApiModel>(); if (result.HasErrors) { return(Json(result, JsonRequestBehavior.AllowGet)); } var response = AccountManager.RegisterUser(inputModel); if (response.ServiceProviderResult.Success && response.Result != null) { result.Initialize(response.Result); AccountManager.Login(response.Result.UserName, inputModel.Password, false); } else { result.SetErrors(response.ServiceProviderResult); } return(Json(result)); } catch (Exception e) { return(Json(new ErrorApiModel("Register", e), JsonRequestBehavior.AllowGet)); } }
public ManagerResponse <CreateUserResult, CommerceUser> RegisterUser(RegisterUserInputModel inputModel) { Assert.ArgumentNotNull(inputModel, "inputModel"); Assert.ArgumentNotNullOrEmpty(inputModel.FirstName, "inputModel.FirstName"); Assert.ArgumentNotNullOrEmpty(inputModel.LastName, "inputModel.LastName"); CreateUserResult result; // Attempt to register the user try { var request = new CreateUserRequest(inputModel.UserName, inputModel.Password, inputModel.UserName, StorefrontContext.Current.ShopName); request.Properties.Add("FirstName", inputModel.FirstName); request.Properties.Add("LastName", inputModel.LastName); result = this.CustomerServiceProvider.CreateUser(request); } catch (MembershipCreateUserException e) { result = new CreateUserResult { Success = false }; result.SystemMessages.Add(new SystemMessage { Message = ErrorCodeToString(e.StatusCode) }); } result.WriteToSitecoreLog(); return(new ManagerResponse <CreateUserResult, CommerceUser>(result, result.CommerceUser)); }
public HttpResponse Register(RegisterUserInputModel input) { if (this.IsUserSignedIn()) { return(this.Redirect("/")); } if (string.IsNullOrWhiteSpace(input.Username) || input.Username.Length < 5 || input.Username.Length > 20) { return(this.Error("Invalid username.")); } if (string.IsNullOrWhiteSpace(input.Email)) { return(this.Error("Email is required.")); } if (string.IsNullOrWhiteSpace(input.Password) || input.Password.Length < 6 || input.Password.Length > 20) { return(this.Error("Invalid password.")); } if (input.Password != input.ConfirmPassword) { return(this.Error("Passwords not same.")); } this.usersService.CreateUser(input.Username, input.Email, input.Password); return(this.Redirect("/Users/Login")); }
private async Task SeedUser() { if (!this.data.ApplicationUser.Query().Any(u => u.UserName == "admin")) { var adminModel = new RegisterUserInputModel() { Username = "******", Email = "*****@*****.**", Password = "******" }; await this.accountService.RegisterUser(adminModel); var createAdminRole = await this.roleManager.CreateAsync(new IdentityRole("Administrator")); if (!createAdminRole.Succeeded) { throw new Exception(string.Join("; ", createAdminRole.Errors)); } var adminUser = this.data.ApplicationUser.Query().FirstOrDefault(); var addAdminRole = await this.userManager.AddToRoleAsync(adminUser, "Administrator"); if (!addAdminRole.Succeeded) { throw new Exception(string.Join("; ", addAdminRole.Errors)); } this.data.SaveChanges(); } }
public async Task <IActionResult> Register([FromBody] RegisterUserInputModel model) { var result = await this.identity.Register(model); if (!result.Succeeded) { return(this.BadRequest(result.Errors)); } return(await this.Login(new LoginUserInputModel(model.UserName, model.Password))); }
public async Task <IActionResult> RegisterManager(RegisterUserInputModel inputModel) { if (!this.ModelState.IsValid) { return(this.View(inputModel)); } await this.userService.RegisterUserForCompanyAsync(inputModel, GlobalConstants.ManagerRoleName); return(this.Redirect("/")); }
public async Task <ActionResult <UserOutputModel> > Register(RegisterUserInputModel input) { var result = await this.identity.Register(input); if (!result) { return(this.BadRequest(result.Errors)); } return(await this.Login(new UserInputModel { Email = input.Email, Password = input.Password })); }
public async Task <IdentityResult> Register(RegisterUserInputModel userInput) { var user = new ApplicationUser { Email = userInput.Email, UserName = userInput.UserName, }; var result = await this.userManager.CreateAsync(user, userInput.Password); return(result); }
public void CreateUser(RegisterUserInputModel model) { var user = new User { Username = model.Username, Email = model.Email, Password = ComputeHash(model.Password) }; this.dbContext.Users.Add(user); this.dbContext.SaveChanges(); }
public async Task <IActionResult> RegisterEmployee(RegisterUserInputModel inputModel) { if (!this.ModelState.IsValid) { this.ViewData.Add("Position", "Supervisor"); return(this.View("RegisterUser", inputModel)); } inputModel.CompanyId = this.companyService.GetIdByUserName(this.User.Identity.Name); await this.userService.RegisterUserForCompanyAsync(inputModel); return(this.RedirectToAction("Details", "Company")); }
public ActionResult RegisterExistingUser(CommerceCustomer commerceUser) { try { Assert.ArgumentNotNull(commerceUser, "commerceUser"); RegisterBaseResultApiModel result = new RegisterBaseResultApiModel(); var userResponse = this.AccountManager.GetUser(commerceUser.Name); if (userResponse.Result == null) { // create the user in Sitecore var inputModel = new RegisterUserInputModel { UserName = commerceUser.Name, Password = System.Web.Security.Membership.GeneratePassword(8, 4) }; inputModel.FirstName = commerceUser.Properties["FirstName"] as string ?? string.Empty; inputModel.LastName = commerceUser.Properties["LastName"] as string ?? string.Empty; var response = this.AccountManager.RegisterUser(inputModel); if (!response.ServiceProviderResult.Success || response.Result == null) { result.SetErrors(response.ServiceProviderResult); return(this.Json(result, JsonRequestBehavior.AllowGet)); } } var isLoggedIn = this.AccountManager.Login(commerceUser.Name, false); if (isLoggedIn) { return(this.Redirect("/")); } else { result.SetErrors(new List <string> { "Could not create user" }); } return(this.Json(result)); } catch (Sitecore.Commerce.OpenIDConnectionClosedUnexpectedlyException) { this.CleanNotAuthorizedSession(); return(this.Redirect("/login")); } catch (Exception e) { return(this.Json(new ErrorApiModel("Register", e), JsonRequestBehavior.AllowGet)); } }
public async Task <Result <User> > Register(RegisterUserInputModel userInput) { var user = new User { Email = userInput.Email, UserName = userInput.Email, }; var identityResult = await this.userManager.CreateAsync(user, userInput.Password); var errors = identityResult.Errors.Select(e => e.Description); return(identityResult.Succeeded ? Result <User> .SuccessWith(user) : Result <User> .Failure(errors)); }
public void Register_Initialized_ShouldReturnOk(Database db, IOrderManager orderManager, IContactFactory contactFactory, ILogger logger, HttpContextBase httpContextBase) { // arrange FakeSiteContext.Database = db; var controller = new AccountController(new MockAccountManager(), contactFactory, logger, new MockAccountRepository()); var model = new RegisterUserInputModel { UserName = "******", Password = "******", ConfirmPassword = "******" }; // act var result = controller.Register(model); // assert result.As <JsonResult>().Should().NotBeNull(); result.As <JsonResult>().Data.As <RegisterBaseJsonResult>().Should().NotBeNull(); result.As <JsonResult>().Data.As <RegisterBaseJsonResult>().Success.Should().BeTrue(); }
public RegisterBaseJsonResult RegisterUser(RegisterUserInputModel inputModel) { var fixture = new Fixture(); var res = fixture.Create <RegisterBaseJsonResult>(); if (!inputModel.UserName.IsNullOrEmpty() && inputModel.UserName.Equals("fake") && !inputModel.Password.IsNullOrEmpty() && !inputModel.ConfirmPassword.IsNullOrEmpty() && inputModel.Password.Equals(inputModel.ConfirmPassword)) { res.Success = true; } else { res.Success = false; } return(res); }
public async Task <ActionResult> Register(RegisterUserInputModel input) { if (await usersService.IsUserExists(input.UserId)) { return(BadRequest(string.Format(UsersConstants.UserAlreadyExists, input.UserId))); } var result = await usersService .RegisterUser(input.UserId); if (!result.Succeeded) { return(BadRequest(result.Errors)); } return(Ok(result.Data)); }
public HttpResponse Register(RegisterUserInputModel model) { if (IsUserSignedIn()) { return(this.Redirect("/")); } if (string.IsNullOrEmpty(model.Username) || model.Username.Length < 5 || model.Username.Length > 20) { return(this.Error("Name should be between 5 and 20 characters long.")); } if (!this.usersService.IsUsernameAvailable(model)) { return(this.Error("Username not available.")); } if (string.IsNullOrEmpty(model.Email) || !new EmailAddressAttribute().IsValid(model.Email)) { return(this.Error("Email is required.")); } if (!this.usersService.IsEmailAvailable(model)) { return(this.Error("Email is not in the right format.")); } if (string.IsNullOrEmpty(model.Password) || model.Password.Length < 6 || model.Password.Length > 20) { return(this.Error("Password should be between 6 and 20 characters long.")); } if (model.ConfirmPassword != model.Password) { return(this.Error("Passwords do not match.")); } this.usersService.CreateUser(model); return(this.Redirect("/Users/Login")); }
public HttpResponse Register(RegisterUserInputModel model) { if (this.IsUserSignedIn()) { return(this.Redirect("/")); } if (string.IsNullOrEmpty(model.Username) || model.Username.Length < 5 || model.Username.Length > 20) { return(this.Error("Username should be between 5 and 20 characters long.")); } if (string.IsNullOrEmpty(model.Email) || !new EmailAddressAttribute().IsValid(model.Email)) { return(this.Error("Invalid email address.")); } if (string.IsNullOrEmpty(model.Password) || model.Password.Length < 6 || model.Password.Length > 20) { return(this.Error("Password is required and should be between 6 and 20 characters long.")); } if (model.ConfirmPassword != model.Password) { return(this.Error("Passwords do not match.")); } if (!this.usersService.IsEmailAvailable(model.Email)) { return(this.Error("The email address is already taken.")); } if (!this.usersService.IsUsernameAvailable(model.Username)) { return(this.Error("The username is already taken.")); } this.usersService.Create(model.Username, model.Email, model.Password); return(this.Redirect("/Users/Login")); }
public IActionResult Register(RegisterUserInputModel input) { if (!ModelState.IsValid) { return(this.Redirect("/Users/Register")); } if (input.Password != input.ConfirmPassword) { return(this.Redirect("/Users/Register")); } string userId = this.usersService.CreateUser(input.Username, input.Email, input.Password); this.SignIn(userId, input.Username, input.Email); return(this.Redirect("/")); }
public RegisterBaseJsonResult RegisterUser(RegisterUserInputModel inputModel) { RegisterBaseJsonResult result = new RegisterBaseJsonResult(); var anonymousVisitorId = this.CurrentVisitorContext.UserId; var response = this.AccountManager.RegisterUser(this.CurrentStorefront, inputModel); if (response.ServiceProviderResult.Success && response.Result != null) { result.Initialize(response.Result); this.AccountManager.Login(CurrentStorefront, CurrentVisitorContext, anonymousVisitorId, response.Result.UserName, inputModel.Password, false); } else { result.SetErrors(response.ServiceProviderResult); } return(result); }
public async Task <object> Register([FromBody] RegisterUserInputModel model) { try { await this.accountService.Register(model); return(this.Ok(new ReturnMessage() { Message = "You have successfully registered! Now you should be able to log in!" })); } catch (Exception e) { return(this.BadRequest(new ReturnMessage { Message = e.Message })); } }
public async Task SeedAdmin(RegisterUserInputModel model) { var user = this.Mapper.Map <RegisterUserInputModel, User>(model); user.IsActive = true; user.DateRegistered = DateTime.UtcNow; try { await this.UserManager.CreateAsync(user, model.Password); await this.UserManager.AddToRoleAsync(user, Enum.GetName(typeof(Roles), 1)); } catch (Exception e) { this.Logger.LogWarning(e, "Creation of ApplicationUser and its role resulted in failure: " + e.Message); } }
public async Task Register(string email, string password, string username) { var user = new RegisterUserInputModel { Email = email, Password = password, Username = username }; var json = new StringContent( JsonConvert.SerializeObject(user), Encoding.UTF8, "application/json"); var response = await client.PostAsync(RegisterEndpoint, json); response.EnsureSuccessStatusCode(); }
public ManagerResponse <CreateUserResult, CommerceUser> RegisterUser(RegisterUserInputModel inputModel) { Assert.ArgumentNotNull(inputModel, nameof(inputModel)); Assert.ArgumentNotNullOrEmpty(inputModel.UserName, nameof(inputModel.UserName)); Assert.ArgumentNotNullOrEmpty(inputModel.Password, nameof(inputModel.Password)); if (StorefrontContext.Current == null) { throw new InvalidOperationException("Cannot be called without a valid storefront context."); } CreateUserResult result; // Attempt to register the user try { var request = new CreateUserRequest(inputModel.UserName, inputModel.Password, inputModel.UserName, StorefrontContext.Current.ShopName); result = CustomerServiceProvider.CreateUser(request); result.WriteToSitecoreLog(); if (result.Success && result.CommerceUser == null && !result.SystemMessages.Any()) { // Connect bug: This is a work around to a Connect bug. When the user already exists,connect simply aborts the pipeline but // does not set the success flag nor does it return an error message. result.Success = false; result.SystemMessages.Add(new SystemMessage { Message = DictionaryPhraseRepository.Current.Get("/System Messages/Accounts/User Already Exists", "User name already exists. Please enter a different user name.") }); } } catch (MembershipCreateUserException e) { result = new CreateUserResult { Success = false }; result.SystemMessages.Add(new SystemMessage { Message = ErrorCodeToString(e.StatusCode) }); } return(new ManagerResponse <CreateUserResult, CommerceUser>(result, result.CommerceUser)); }
private async Task SeedUser(IRepository <User> userRepository, IConfiguration configuration, IAccountService accountService, ILogger <IDatabaseInitializer> logger) { string username = configuration.GetSection("UserSettings")["Username"]; if (!userRepository.Query().Any(u => u.UserName == username)) { logger.LogWarning("Start Seeding User..."); var adminModel = new RegisterUserInputModel() { Username = configuration.GetSection("UserSettings")["Username"], Email = configuration.GetSection("UserSettings")["Email"], Password = configuration.GetSection("UserSettings")["Password"], }; await accountService.SeedAdmin(adminModel); logger.LogWarning("End Seeding User Successfully"); } }
public async Task Register(RegisterUserInputModel model) { var user = this.Mapper.Map <RegisterUserInputModel, User>(model); if (this.UserManager.Users.Count(u => u.UserName == user.UserName) != 0) { throw new Exception("Username is already taken!"); } if (this.UserManager.Users.Count(u => u.Email == user.Email) != 0) { throw new Exception("Email is already taken!"); } user.DateRegistered = DateTime.UtcNow; await this.UserManager.CreateAsync(user, model.Password); await this.UserManager.AddToRoleAsync(user, Enum.GetName(typeof(Roles), 2)); }