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());
}
