public (bool isSuccess, Guid userId, string code) Register(NewUserDto newUser) { var verificationCode = $"{Guid.NewGuid():N}{Guid.NewGuid().ToString("N")}".Substring(0, 39); var _new = new User { Id = Guid.NewGuid(), Created = DateTime.Now, Phone = newUser.Phone, CreatedBy = Guid.Parse("00000000-0000-0000-0000-000000000001"), UpdatedBy = Guid.Parse("00000000-0000-0000-0000-000000000001"), DisplayName = newUser.DisplayName, IsActive = false, IsDeleted = false, MailAddress = newUser.Mail, Password = "******", Type = newUser.Type, Updated = DateTime.Now, UserName = newUser.UserName, VerificationCode = verificationCode }; users.Add(_new); var isSuccess = context.SaveChanges() > 0; return(isSuccess, _new.Id, verificationCode); }
public void Add(NewUserDto dto) { var newUser = (User)dto; newUser.Password = _securityService.Encrypt(newUser.Password, newUser.Email); base.Add(newUser); }
public NewUserResponseDto Register(NewUserDto newUserDto) { try { string hashedPassword = _hasher.HashPassword(newUserDto.Password); newUserDto.Password = hashedPassword; User user = _newUserAssembler.ToEntity(newUserDto); _userRepository.SaveOrUpdate(user); Customer customer = new Customer(); customer.FirstName = newUserDto.FirstName; customer.LastName = newUserDto.LastName; customer.CreatedAt = DateTime.UtcNow; customer.IdentityDocument = newUserDto.Document; customer.User = user.Id; customer.Active = true; _newCustomerRepository.SaveOrUpdate(customer); return(new NewUserResponseDto { HttpStatusCode = StatusCodes.Status201Created, Response = new ApiStringResponse(UserAppConstants.UserCreated) }); } catch (Exception ex) { //TODO: Log exception async, for now write exception in the console Console.WriteLine(ex.Message); return(new NewUserResponseDto { HttpStatusCode = StatusCodes.Status500InternalServerError, Response = new ApiStringResponse(ApiConstants.InternalServerError) }); } }
public void AddNewUser(NewUserDto dto) { if (dto != null) { _us.Add(dto); } }
public async Task <IdentityResult> CreateUserAsync(NewUserDto newUserDto) { var user = newUserDto.MapNewApplicationUser(); var result = await _userManager.CreateAsync(user, newUserDto.Password); return(result); }
public async Task <IActionResult> AddUser([FromBody] NewUserDto newUser) { try { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (await _userRepository.IsDuplicateUserAsync(newUser)) { ModelState.AddModelError("username", "Username already exists"); return(BadRequest(ModelState)); } var userId = await _userRepository.AddUserAsync(newUser); if (userId > 0) { return(Ok(userId)); } return(StatusCode(500, "An error ocurred in server")); } catch (Exception e) { _logger.LogCritical($"POST {Route}/ - {e.GetType().Name} - {e.Message} - {e.StackTrace}"); return(StatusCode(500, "An error ocurred in server")); } }
private async Task <long> CreateAdress(NewUserDto userInfo) { if (userInfo.City == null) { return(0); } if (userInfo.Country == null) { return(0); } if (userInfo.Province == null) { return(0); } if (string.IsNullOrWhiteSpace(userInfo.Street)) { return(0); } if (string.IsNullOrWhiteSpace(userInfo.StreetNumber)) { return(0); } Adress adress = new Adress(); adress.CityId = (long)userInfo.City; adress.ProvinceId = (long)userInfo.Province; adress.Street = userInfo.Street; adress.Number = userInfo.StreetNumber; return(await createAdressService.Save(adress)); }
public NewUserResponseDto Register(NewUserDto newUserDto) { try { string hashedPassword = _hasher.HashPassword(newUserDto.Password); newUserDto.Password = hashedPassword; User user = _newUserAssembler.ToEntity(newUserDto); _userRepository.SaveOrUpdate(user); return(new NewUserResponseDto { HttpStatusCode = StatusCodes.Status201Created, Response = new ApiStringResponse(UserAppConstants.UserCreated) }); } catch (Exception ex) { //TODO: Log exception async, for now write exception in the console Console.WriteLine(ex.Message); return(new NewUserResponseDto { HttpStatusCode = StatusCodes.Status500InternalServerError, Response = new ApiStringResponse(ApiConstants.InternalServerError) }); } }
public async Task AddAsync(NewUserDto dto) { var newUser = dto.DtoToEntity(); newUser.Password = _securityService.Encrypt(newUser.Password, newUser.Email); await _repository.AddAsync(newUser); }
public CreateUserResult CreateNewUser(NewUserDto newUserDto) { var isLoginUsed = UserDataStore.GetAll().Any(u => u.Login == newUserDto.Login); if (isLoginUsed) { return(new CreateUserResult { Success = false, Message = "Логин занят" }); } var user = new User { Login = newUserDto.Login, Name = newUserDto.Name, PasswordHash = string.Empty, Role = newUserDto.Role }; UserDataStore.Save(user); return(new CreateUserResult { Success = true }); }
public void Update_existing_user() { NewUserDto newUserDto = new NewUserDto { Name = "Martin", Surname = "Fowler", Username = "******", Password = "******", Email = "*****@*****.**", IsRoot = false }; UpdateUserDto updatedUserDto = new UpdateUserDto { Name = "John", Surname = "Smith", Username = "******", Password = "******", Email = "*****@*****.**", IsRoot = true }; NewUserIdDto newUserIdDto = _managementController.CreateUser(newUserDto); _managementController.UpdateUser(newUserIdDto.Id, updatedUserDto); UserInfoDto userInfoDto = _managementController.GetUser(newUserIdDto.Id); Assert.AreEqual(updatedUserDto.Name, userInfoDto.Name); Assert.AreEqual(updatedUserDto.Surname, userInfoDto.Surname); Assert.AreEqual(updatedUserDto.Email, userInfoDto.Email); Assert.AreEqual(updatedUserDto.Username, userInfoDto.Username); Assert.AreEqual(updatedUserDto.IsRoot, userInfoDto.IsRoot); }
public async Task <GenericResult <UserDto> > AddNewUser(NewUserDto newUserDto) { try { if (!await _peopleService.IsPersonExists(newUserDto.FKPersonID)) { return(GenericResult <UserDto> .UserSafeError("There is no person info with given id")); } var newUser = await _userRepo.InsertAsync(new User { FKPersonID = newUserDto.FKPersonID, Email = newUserDto.Email, UserName = newUserDto.UserName, PasswordHash = _cipherService.Encrypt(newUserDto.Password), }); return(GenericResult <UserDto> .Success(_mapper.Map <UserDto>(newUser))); } catch (Exception e) { return(GenericResult <UserDto> .Error(e)); } }
public void Raise_an_error_when_creating_a_user_with_existing_username() { NewUserDto newUserDto = new NewUserDto { Name = "Robert", Surname = "Martin", Username = "******", Password = "******", Email = "*****@*****.**", IsRoot = false }; NewUserDto duplicatedUserDto = new NewUserDto { Name = "John", Surname = "Smith", Username = "******", Password = "******", Email = "*****@*****.**", IsRoot = false }; NewUserIdDto newUserIdDto = _managementController.CreateUser(newUserDto); Exception exception = Assert.Throws <Exception>(() => _managementController.CreateUser(duplicatedUserDto)); Assert.AreEqual("Cannot create user. Username is duplicate. Username: UncleBob", exception.Message); }
public async Task <Contract.Models.User> Register(NewUserDto newUser) { ValidationHelper.ValidateAndThrow(newUser); var existUser = await _userGetOperations.ByUserName(newUser.Login); if (existUser is not null) { throw new ExistingUserException(); } var model = new Contract.Models.User { Id = Guid.NewGuid().ToString(), Bio = newUser.Bio, FirstName = newUser.FirstName, Login = newUser.Login, LastName = newUser.LastName, MiddleName = newUser.MiddleName }; var password = PasswordHelper.GeneratePassword(newUser.Password); model.Salt = password.Salt; model.Password = password.Hash; model.Token = Guid.NewGuid().ToString(); return(await _userWriteOperations.Create(model)); }
public async Task ValidateToken_CorrectToken_ResponseSuccessStatusAsync(NewUserDto data) { await Task.Delay(1000); data.Username = data.Password = data.Username + "cheburek"; var client = Factory.CreateClient(); await UserCreator.CreateUserAsync(Factory, _contentProvider, data, client); var authData = new AuthorizationDto { Username = data.Username, Password = data.Password }; var getTokenPath = GetControllerActionPath("GetToken"); var validatePath = GetControllerActionPath("ValidateToken"); var authDataContent = _contentProvider.GetJsonStringContent(authData); var response = await client.PostAsync(getTokenPath, authDataContent); response.EnsureSuccessStatusCode(); var result = await response.Content.ReadAsAsync <TokenDto>(); var query = $"?token={result.access_token}"; response = await client.GetAsync(validatePath + query); response.EnsureSuccessStatusCode(); }
public async Task <ActionResult> Register([FromBody] NewUserDto user) { if (!ModelState.IsValid) { var errors = ModelState.AsEnumerable(); foreach (var error in errors) { Debug.WriteLine($"{error.Key}:{error.Value}"); } return(BadRequest()); } var result = await _userManager.CreateAsync(new ApplicationUser() { UserName = user.Username, Email = user.Username }, user.Password); if (result.Succeeded) { return(Ok()); } else { return(StatusCode(500, result.ToString())); } }
private static async Task <bool> IsUserExists(NewUserDto user, WebApplicationFactory <Startup> factory) { using var scope = factory.Services.CreateScope(); var repository = scope.ServiceProvider.GetService <IUserRepository>(); var userDto = await repository.GetAsync(user.Username); return(userDto != null); }
public static ApplicationUser MapNewApplicationUser(this NewUserDto newUserDto) => new ApplicationUser { Name = newUserDto.Name, PhoneNumber = newUserDto.PhoneNumber, UserName = newUserDto.UserName, BirthDate = newUserDto.BirthDate, Email = newUserDto.Email };
public User Create(NewUserDto data) { var newUser = new User(data.FullName, data.Email, data.Role, data.PassWord); _context.Add(newUser); _context.SaveChanges(); return(newUser); }
public async Task <int> createNewAccount(NewUserDto user) { var userEntity = user.MapToUser(new User()); _users.Add(userEntity); await _context.SaveChangesAsync(); return(userEntity.Id); }
public void Add(NewUserDto dto) { using (_context) { IRepository <User> userRep = _context.GetRepository <User>(); User user = Mapper.Map <NewUserDto, User>(dto); userRep.Add(user); _context.SaveChanges(); } }
public async Task <IHttpActionResult> Register([FromBody] NewUserDto model) { if (!ModelState.IsValid) { return(BadRequest("Invalid model")); } var result = await _userService.Register(model); return(result.IsSuccess ? StatusCode(HttpStatusCode.NoContent) : StatusCode(HttpStatusCode.InternalServerError)); }
public IActionResult RegisterUser(NewUserDto newUser) { if (newUser.Role is null || newUser.Username is null || newUser.Password is null) { return(BadRequest(new ApiError("Role, username and password are required for new user"))); } _userService.RegisterUser(new NewUser(newUser.Role, newUser.Username, newUser.Password, newUser.Name, newUser.Surname)); return(NoContent()); }
public User ToEntity(NewUserDto newUserDto) { User user = _mapper.Map <User>(newUserDto); user.PasswordHash = newUserDto.Password; DateTime utcNow = DateTime.UtcNow; user.CreatedAt = utcNow; user.UpdatedAt = utcNow; return(user); }
public IActionResult Create(NewUserDto data) { var response = _userService.Create(data); if (response == null) { return(BadRequest(new { message = "Username information is incorrect" })); } return(Ok(response)); }
public IActionResult Registration([FromBody] NewUserDto requestNewUserDto) { var registrationExceptions = _registrationAppService.CheckEmailAndPhoneForDuplicates(requestNewUserDto); if (registrationExceptions.Count > 0) { return(BadRequest(registrationExceptions)); } _registrationAppService.RegisterNewUser(requestNewUserDto); return(Ok(requestNewUserDto)); }
public Tuple <UserReturnDto, LinkDto> CreateUser(NewUserDto user) { var department = _departmentOperations.GetDepartmentById(user.DepartmentId); if (department == null) { return(null); } var returnedUser = _userOperations.CreateUser(Mapper.Map <User>(user), department); return(new Tuple <UserReturnDto, LinkDto>(Mapper.Map <UserReturnDto>(returnedUser), CreateLink(returnedUser.UserID, "GetUserById", this._urlHelper))); }
private async Task AddNewAccount(NewUserDto newUserDto, UserERD newUser) { await _appContext.Accounts.AddAsync(new AccountERD { EmailAddress = newUserDto.EmailAddress, Password = newUserDto.Password, UserId = newUser.Id, IsDeleted = false }); _appContext.SaveChanges(); }
public async Task <UserDto> CreateAsync(NewUserDto newUser) { var inputData = _mapper.Map <UserDto>(newUser); var user = await _userRepository.GetAsync(newUser.Username); if (user != null) { throw new ArgumentException($"Пользователь {newUser.Username} уже существует."); } return(await _userRepository.CreateAsync(inputData)); }
public async Task <IActionResult> AddUserAsync([FromBody] NewUserDto dto) { var errors = GetErrorListFromModelState(); if (errors.Any()) { return(BadRequest(errors)); } await _userService.AddAsync(dto); return(Ok()); }