public IncomingUser ToIncomingUser(RegisterUserModel apiModel) { return new IncomingUser { Email = apiModel.Email, Name = apiModel.Login, Password = apiModel.Password }; }
public async Task <IHttpActionResult> Register(RegisterUserModel userModel) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } try { var user = new RegisterUserDTO { UserName = userModel.UserName, PasswordHash = userModel.Password }; _userService.CreateUser(user); return(Ok( )); } catch (Exception e) { return(BadRequest(e.Message)); } }
public Task <HttpResponseMessage> Post(RegisterUserModel model) { HttpResponseMessage response = new HttpResponseMessage(); try { _service.Register(model.Name, model.Email, model.Password, model.ConfirmPassword); response = Request.CreateResponse(HttpStatusCode.OK, new { name = model.Name, email = model.Email }); } catch (Exception ex) { response = Request.CreateResponse(HttpStatusCode.BadRequest, ex.Message); } var tsc = new TaskCompletionSource <HttpResponseMessage>(); tsc.SetResult(response); return(tsc.Task); }
public async Task <IHttpActionResult> Create(RegisterUserModel userModel) { var claims = Helper.GetClaims(User.Identity as ClaimsIdentity); int workSpaceId = Convert.ToInt32(claims["WorkSpaceId"]); var workSpace = _repository.GetWorkSpace(workSpaceId, claims[ClaimTypes.Name]); if (workSpace == null) { return(BadRequest("Ocurrio un error al obtener datos del espacio de trabajo.")); } if (!_repository.IsValidCreateUser(workSpaceId, workSpace.MaxUsers)) { return(BadRequest("Supero el máximo de usuarios permitidos.")); } userModel.Password = userModel.UserName; userModel.ConfirmPassword = userModel.UserName; userModel.UserName = userModel.UserName.ToLower() + "@" + workSpace.Domain + ".com"; userModel.Role = "Usuario"; userModel.WorkSpaceId = workSpaceId; ModelState.Remove("userModel.Password"); ModelState.Remove("userModel.Role"); if (!ModelState.IsValid) { return(BadRequest(ModelState)); } IdentityResult result = await _repository.RegisterUser(userModel); IHttpActionResult errorResult = GetErrorResult(result); if (errorResult != null) { return(errorResult); } _log.Info("se ha registrado un nuevo usuario: " + userModel.UserName, "AuthenticationAPI", claims[ClaimTypes.Name]); return(Ok()); }
private async Task SaveImagesAsync(RegisterUserModel userModel) { var host = AppDomain.CurrentDomain.GetData("DataDirectory").ToString(); try { if (!Directory.Exists($"{host}\\Images")) { Directory.CreateDirectory($"{host}\\Images"); } var imageBytes = string.IsNullOrEmpty(userModel.ImageBase64String) ? null : Convert.FromBase64String(userModel.ImageBase64String); if (imageBytes != null) { await SaveImageAsync($"{host}\\Images\\{userModel.Id}-avatar.jpg", imageBytes); } } catch (Exception) { // ignore } try { var backgroundBytes = string.IsNullOrEmpty(userModel.BackgroundImageBase64String) ? null : Convert.FromBase64String(userModel.BackgroundImageBase64String); if (!Directory.Exists($"{host}\\Images")) { Directory.CreateDirectory($"{host}\\Images"); } if (backgroundBytes != null) { await SaveImageAsync($"{host}\\Images\\{userModel.Id}-background.jpg", backgroundBytes); } } catch (Exception) { // ignore } }
public async Task <IActionResult> Register(RegisterUserModel model) { if (!ModelState.IsValid) { return(View(model)); } var user = await _userManager.FindByEmailAsync(model.Email); if (user == null) { user = new UserDTO { Id = Guid.NewGuid(), FirstName = model.FirstName, LastName = model.LastName, Email = model.Email, BirthDate = model.BirthDate }; var activationLink = Url.Action("ConfirmEmail", "Account", new { token = Security.Encrypt(await _userManager.GenerateEmailConfirmationTokenAsync(user)), email = Security.Encrypt(model.Email) }, Request.Scheme); var create = await _userManager.CreateAsync(user, Security.Decrypt(model.PasswordHash)); if (create.Succeeded && await _emailSender.SendAsync(model.Email, activationLink, "Confirm your email account")) { ViewBag.Succeeded = 200; } else { foreach (var error in create.Errors) { Handler.Error(error.Description, this); } } } else { Handler.Error("This email already exists", this); } return(View()); }
public IHttpActionResult Post(RegisterUserModel user) { if (user.Password != user.ConfirmPassword) { return(BadRequest("Hasłą nie są takie same.")); } if (string.IsNullOrEmpty(user.Email)) { return(BadRequest("Adres e-mail jest niepoprawny.")); } if (string.IsNullOrEmpty(user.Password) || string.IsNullOrEmpty(user.ConfirmPassword) || string.IsNullOrEmpty(user.Email) || string.IsNullOrEmpty(user.FirstName) || string.IsNullOrEmpty(user.LastName) || string.IsNullOrEmpty(user.PhoneNumber) || string.IsNullOrEmpty(user.TicketNumber)) { return(BadRequest("Wszystkie pola muszą być wypełnione.")); } var userExists = _userRepository.Get().Where(x => x.Email == user.Email).Count() > 0; if (userExists) { return(BadRequest("Istnieje już użytkownik z takim adresem e-mail.")); } var ticketExists = _userRepository.Get().FirstOrDefault(x => x.TicketNumber == user.TicketNumber); if (ticketExists == null) { return(BadRequest("Niestety, zaproszenie jest niepoprawne.")); } ticketExists.Email = user.Email; ticketExists.Password = user.Password; ticketExists.FirstName = user.FirstName; ticketExists.LastName = user.LastName; ticketExists.PhoneNumber = user.PhoneNumber; ticketExists.Active = true; _userRepository.Put(ticketExists); return(Ok("Rejestracja przebiegła pomyślnie. Można się już zalogować.")); }
public async Task SendCreateUser(RegisterUserModel messageObject) { // Retrieve storage account from connection string. CloudStorageAccount storageAccount = CloudStorageAccount.Parse(_cloudStorageAccountSetting.ConnectionString); // Create the queue client. CloudQueueClient queueClient = storageAccount.CreateCloudQueueClient(); // Retrieve a reference to a queue. CloudQueue queue = queueClient.GetQueueReference(_cloudStorageAccountSetting.CreateUserQeue); // Create the queue if it doesn't already exist. await queue.CreateIfNotExistsAsync(); // Create a message and add it to the queue. string serializedMessage = JsonConvert.SerializeObject(messageObject); CloudQueueMessage cloudQueueMessage = new CloudQueueMessage(serializedMessage); await queue.AddMessageAsync(cloudQueueMessage); }
private async void CreateFunction() { Console.WriteLine(Email); Console.WriteLine(Username); Console.WriteLine(Password); Console.WriteLine(ConfirmPassword); var user = new MobileUser() { Email = Email, Username = Username, Password = Password }; var userr = new RegisterUserModel() { Email = Email, UserName = Username, Password = Password }; await database.createUser(user); await server.RegisterUser(userr); Console.WriteLine("adadsf"); }
/// <summary> /// Получает Сущность из <paramref name="model"/> /// </summary> /// <param name="model"></param> /// <returns></returns> public static User CreateUser(RegisterUserModel model) { User user = new User() { UserName = model.Email, UserPhone = model.Phone, Password = model.Password, AccessRoleId = model.RoleId, UserInfo = new UserInfo() { Name = model.Name, LastName = model.LastName, Company = model.Company, Position = model.Position, }, }; StatusService.ChangeStatus(user, UserStatusType.System); return(user); }
public IActionResult Register([FromBody] RegisterUserModel model) { // map model to entity var user = _mapper.Map <User>(model); try { // create user _userService.Create(user, model.Password); return(Ok(new { data = user, message = "Successfully registered user." })); } catch (AppException ex) { // return error message if there was an exception return(BadRequest(new { message = ex.Message })); } }
public IActionResult Register([FromBody] RegisterUserModel userIn) { if (ModelState.IsValid == false) { return(BadRequest(ModelState)); } var user = new User() { FirstName = userIn.FirstName, LastName = userIn.LastName, Username = userIn.Username, Email = userIn.Email, DateOfBirth = userIn.DateOfBirth, Image = userIn.Image }; _userService.Register(user, userIn.Password); return(CreatedAtAction("GetMovieCollection", new { id = user.Id }, user)); }
public async Task <Guid> Register(RegisterUserModel model) { var userToRegister = new User { Id = Guid.NewGuid(), FirstName = model.FirstName, LastName = model.LastName, Email = model.Email, // encrypt password Password = _passwordHasher.HashPassword(model.Password), CreatedAtTimestamp = DateTime.UtcNow, PasswordChangedTimestamp = DateTime.UtcNow }; await _authContext.Users.AddAsync(userToRegister); await _authContext.SaveChangesAsync(); return(userToRegister.Id); }
public async Task <IActionResult> Register(RegisterUserModel model) { var applicationUser = new IdentityUser() { UserName = model.Username.ToLower(), Email = model.Email.ToLower() }; try { var result = await _userManager.CreateAsync(applicationUser, model.Password); return(Ok(result)); } catch (Exception ex) { // TODO: log exceptions return(BadRequest(new { message = "Something went wrong. Please try again later." })); } }
public async Task <object> RegisterUser(RegisterUserModel model) { //if (!ModelState.IsValid) return BadRequest(model); var user = new User { UserName = model.UserName, Email = model.Email }; try { var result = await _userManager.CreateAsync(user, model.Password); return(Ok(result)); } catch (Exception ex) { throw ex; } }
public async void Execute_WithValidModel_Successful() { // arrange RegisterUserModel registrationModel = new RegisterUserModel { Username = "******" }; this.userAccessMock.Setup(x => x.TryGetByName(registrationModel.Username)).Returns(Maybe <User> .Empty); this.userAccessMock.Setup(x => x.Add(registrationModel.Username)).Returns(new User { Name = registrationModel.Username }); var command = this.commandRepository.RegisterNewUser(registrationModel); // act var commandResult = await this.CommandExecutor.ExecuteAsync(command); // assert CommandAssert.IsSuccessful(commandResult); Assert.AreEqual(registrationModel.Username, commandResult.SuccessData.Name); }
public Task <IActionResult> Add([FromBody] RegisterUserModel userModel) { IActionResult result; try { _service.Add(userModel); result = Ok(new ResultViewModel { Success = true, Message = "Usuário cadastrado com sucesso" }); } catch (Exception ex) { result = BadRequest(new ResultViewModel { Success = false, Message = ex.Message, Docs = ex }); } return(GetResult(result)); }
public async Task <User> Register(RegisterUserModel userModel) { var existingUser = await _userRepository.GetAsync(userModel.Email); if (existingUser != null) { throw new LibraryDomainException($"User with email {userModel.Email} already exists."); } var user = new User(userModel.FirstName, userModel.LastName, new Email(userModel.Email), userModel.Role); var(passwordHash, passwordSalt) = _passwordHashService.CreatePasswordHash(userModel.Password); user.PasswordHash = passwordHash; user.PasswordSalt = passwordSalt; _userRepository.Create(user); await _userRepository.UnitOfWork.SaveChangesAsync(); return(user); }
public ActionResult Register([FromBody] RegisterUserModel model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var result = _userManager.RegisterUser(model.Email, model.Password); if (!string.IsNullOrEmpty(result.Message)) { var errors = new List <string>() { result.Message }; return(GetErrorResult(new ErrorResult(errors, false))); } return(Ok()); }
public async Task <UserReturnModel> Register([FromBody] RegisterUserModel creds) { // Console.WriteLine("Here it should be"); // Console.WriteLine(creds); if (ModelState.IsValid) { UserReturnModel user = _db.Register(creds); if (user != null) { ClaimsPrincipal principal = user.SetClaims(); await HttpContext.SignInAsync(principal); return(user); } } // Console.WriteLine("It didnt validate, better figure out why."); return(null); }
public void Register_Post_Fail_Unknown_Reason() { // arrange var auth = new Mock <IAuthenticationService>(); var notification = new Mock <INotificationService>(); var redirect = new RedirectService(); var controller = new RegistrationController(auth.Object, notification.Object, redirect); var model = new RegisterUserModel() { Email = "*****@*****.**", Password = "******", ConfirmPassword = "******" }; auth.Setup(a => a.ValidateCaptcha()).Returns(true); auth.Setup(a => a.RegisterNewUser("*****@*****.**", "password")).Throws(new Exception()); //act / post var result = controller.Register(model) as ViewResult; }
public async Task <ActionResult> RegisterUserAsync(RegisterUserModel model) { model.AcceptUserAgreement = true; if (ModelState.IsValid) { var user = new ApplicationUser { UserName = model.Email, Email = model.Email, FirstName = model.Name, IsActive = true, Registered = DateTime.Now, EmailConfirmed = true }; try { 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(PartialView("_RegisterUserPartial", model)); } AddUserErrors(result); } catch (Exception e) { } } // If we got this far, something failed, redisplay form return(PartialView("_RegisterUserPartial", model)); }
public ActionResult Register([FromBody] RegisterUserModel userModel) { // map userModel to entity var user = _mapper.Map <User>(userModel); try { _userService.Create(user, userModel.Password); } catch (RequestException ex) { if (ex.Code == UserExceptionCodes.BadPassword) { return(BadRequest(new { message = "Password doesn't meet requirements" })); } if (ex.Code == UserExceptionCodes.EmailAlreadyExists) { return(BadRequest(new { message = "Email already in use" })); } return(BadRequest(new { message = "unknown error" })); } return(Ok()); }
public async Task RegisterAlreadyExist_Valid() { var model = new UserDTO { FirstName = "Anton", LastName = "Molch", Email = "*****@*****.**", Password = "******", UserJobCategories = new List <string>() { "Programmer", "QA" } }; _mockService.Setup(s => s.Register(model)).ReturnsAsync(ForTestComment().FirstOrDefault(u => u.Email == model.Email).ToString()); var RegisterModel = new RegisterUserModel { FirstName = "Anton", LastName = "Molch", Email = "*****@*****.**", Password = "******", UserJobCategories = new List <string>() { "Programmer", "QA" } }; var result = await _controller.Register(RegisterModel); Assert.IsInstanceOf <OkResult>(result); }
public async Task <IActionResult> Register(RegisterUserModel model) { // The obsolete check for old custom identiy // model.Username = model.Username.ToLower(); // if (await this.repo.UserExistsAsync(model.Username)) // return BadRequest("Username already exists"); User userToCreate = this.mapper.Map <User>(model); var result = await this.userManager.CreateAsync(userToCreate, model.Password); if (result.Succeeded) { DetailedUserModel userToReturn = this.mapper.Map <DetailedUserModel>(userToCreate); return(CreatedAtRoute("GetUser", new { controller = "Users", id = userToCreate.Id }, userToReturn)); } return(BadRequest(result.Errors)); }
public void createUser(RegisterUserModel userModel) { try { using (SqlConnection conn = new SqlConnection(connectionString)) { conn.Open(); SqlCommand cmd = new SqlCommand(SQL_RegisterUser, conn); cmd.Parameters.AddWithValue("@username", userModel.userName); cmd.Parameters.AddWithValue("@firstName", userModel.firstName); cmd.Parameters.AddWithValue("@lastName", userModel.lastName); cmd.Parameters.AddWithValue("@password", userModel.password); cmd.Parameters.AddWithValue("@salt", userModel.salt); cmd.ExecuteNonQuery(); } } catch (SqlException) { throw; } }
public async Task <bool> DoesUserExist(RegisterUserModel model) { try { // Verifying if user exists var result = await _gatewayRepository.ApiAccountsUsersExistsGetAsync(model.Email); return(result != null); } catch (ApiException apiExc) { if (apiExc.StatusCode == 404) { throw new BusinessException("Cet utilisateur n'existe pas. Veuillez vous inscrire via la page précédente."); } else { throw new TechnicalException(ErrorMessages.serverErrorText + apiExc.StatusCode); } } }
public static bool RegisterUser(RegisterUserModel model) { try { var stringContent = new StringContent( JsonConvert.SerializeObject(model), Encoding.UTF8, "application/json"); var response = HttpClient.PostAsync(WebApiUrls.RegisterUser, stringContent) .GetAwaiter() .GetResult(); return(response.IsSuccessStatusCode); } catch (Exception e) { Console.WriteLine(e); throw; } }
public ActionResult Employee(RegisterUserModel model) { if (ModelState.IsValid) { try { //Insert Employee UserBusinessLogic.CreateEmployee(model.Nama, model.TempatLahir, model.TanggalLahir, model.NoTelpon, model.Email, model.Jabatan); //Insert User UserBusinessLogic.CreateUser(model.Username, model.Password, model.IdRole); } catch (System.Exception ex) { ModelState.AddModelError("", ex.Message); } } return View(model); }
public RegisterUserViewModel() { userModel = new RegisterUserModel(); SaveCommand = new Command(async() => { string username = userModel.Username; string password = userModel.Password; if (string.IsNullOrEmpty(username) || string.IsNullOrEmpty(password) || string.IsNullOrEmpty(cpassword)) { ErrorIdentified = "Hay uno o mas campos vacios. Por favor llene todos."; } else if (password != cpassword) { ErrorIdentified = "The passwords do not match"; } else { await App.Current.MainPage.Navigation.PushAsync(new HomePage(null)); } }); }
public async Task Register_Should_Return_Validation_Errors( RegisterUserModel model, User userToRegister, IdentityError[] expectedErrors) { // Arrange MockMapper(model, userToRegister); _userManagerMock.Setup(userManager => userManager .CreateAsync(userToRegister, model.Password)) .ReturnsAsync(IdentityResult.Failed(expectedErrors)); // Act var result = await _usersService.Register(model); // Assert result.HasValue.ShouldBeFalse(); result.MatchNone(error => error.Messages .ShouldAllBe(message => expectedErrors .Any(expectedError => expectedError.Description == message))); }
public void Map_FieldsAreEqual() { //Arrange var initial = new RegisterUserModel { Email = "*****@*****.**", Login = "******", Password = "******" }; var expected = new User { Email = "*****@*****.**", Name = "Roman", Password = "******" }; //Act var actual = (new UserMapper()).Map(initial); //Assert Assert.AreEqual(expected.Email, actual.Email); Assert.AreEqual(expected.Name, actual.Name); Assert.AreEqual(expected.Password, actual.Password); }
public ActionResult RegisterUser(RegisterUserModel model, string[] Companies, string[] Permissions) { if (ModelState.IsValid) { // Attempt to register the user MembershipCreateStatus createStatus; Membership.CreateUser(model.UserName, model.Password, model.Email, null, null, true, null, out createStatus); if (createStatus == MembershipCreateStatus.Success) { Roles.AddUserToRoles(model.UserName, Companies); Roles.AddUserToRoles(model.UserName, Permissions); FormsAuthentication.SetAuthCookie(model.UserName, false /* createPersistentCookie */); User newUser = new User(); newUser.Username = model.UserName; newUser.UserId = secRep.GetUserId(model.UserName); newUser = secRep.AddUser(newUser); Account_Rep.SetUserLogin(model.UserName); return RedirectToAction("Home", "Home"); } else { ModelState.AddModelError("", ErrorCodeToString(createStatus)); } } // If we got this far, something failed, redisplay form return View(model); }
public ActionResult RegisterCompany(RegisterCompanyModel model) { if (ModelState.IsValid) { // Attempt to register the comapny string rolename = "u_" + model.CompanyName; Roles.CreateRole(rolename); // Add Company to Database Company comp = new Company(); comp.Name = model.CompanyName; comp.RoleId = secRep.GetRoleId(rolename); comp.Removed = false; comp = secRep.AddCompany(comp); RegisterUserModel userNew = new RegisterUserModel(); userNew.CompanyRole = rolename; return RedirectToAction("RegisterUser", "Account", new { CompanyName = model.CompanyName}); } // If we got this far, something failed, redisplay form return View(model); }