public async Task Update(int id, Domain.User.User user)
{
string query = "UPDATE users " +
"SET name = @Name, surname = @Surname, email = @Email, phonenumber = @Phonenumber " +
$"WHERE id = {id}";
await _dbConnection.ExecuteAsync(query, user);
}
public void ConvertToDatabaseTypeTest()
{
var domainUser = new Domain.User.User {
Id = Guid.NewGuid(),
FirstName = "test",
LastName = "test",
Address = new Address {
Country = "UK",
City = "London",
Street = "Baker street",
HouseNumber = "221B"
}
};
var domainTask = new Domain.Task.Task {
Id = Guid.NewGuid(),
Name = "test",
Time = DateTime.Now,
User = domainUser
};
var userMapper = new Mock <IUserDatabaseMapper>();
var mapper = new TaskDatabaseMapper(userMapper.Object);
var result = mapper.ConvertToDatabaseType(domainTask);
Assert.AreEqual(domainTask.Id, result.Id);
Assert.AreEqual(domainTask.Name, result.Name);
Assert.AreEqual(domainTask.Time, result.Time);
Assert.AreEqual(domainTask.User.Id, result.UserId);
}
public void GetBrokenRulesMissingFirstNameAndAddressCountryTest()
{
var user = new Domain.User.User
{
Id = Guid.NewGuid(),
FirstName = null,
LastName = "test",
Address = new Domain.Address.Address
{
Country = null,
City = "London",
Street = "Baker street",
HouseNumber = "221B"
}
};
var mockAddressValidator = new Mock <IValidator <Domain.Address.Address> >();
mockAddressValidator.Setup(x => x.GetBrokenRules(user.Address)).Returns(new List <BusinessRule> {
AddressBusinessRules.AddressCountryRequired
});
var validator = new UserValidator(new List <ISpecification <Domain.User.User> > {
new UserNameRequired()
}, mockAddressValidator.Object);
var broken = validator.GetBrokenRules(user);
Assert.IsTrue(broken.Any());
Assert.AreEqual(1, broken.Count());
Assert.AreEqual(UserBusinessRules.UserNameRequired.Description, broken.First().Description);
}
public void ConvertToDTOTest()
{
var user = new Domain.User.User {
Id = Guid.NewGuid(),
FirstName = "test",
LastName = "test",
Address = new Address {
Country = "UK",
City = "London",
Street = "Baker street",
HouseNumber = "221B"
}
};
var mapper = new UserDtoMapper();
var result = mapper.ConvertToDTO(user);
Assert.AreEqual(user.Id, result.Id);
Assert.AreEqual(user.FirstName, result.FirstName);
Assert.AreEqual(user.LastName, result.LastName);
Assert.AreEqual(user.Address.Country, result.Country);
Assert.AreEqual(user.Address.City, result.City);
Assert.AreEqual(user.Address.Street, result.Street);
Assert.AreEqual(user.Address.HouseNumber, result.HouseNumber);
}
public async Task <IActionResult> Register([FromBody] RegisterModel userDto)
{
// map dto to entity
var user = new Domain.User.User
{
UserName = userDto.Username,
EmailAddress = userDto.Email,
UserProfile = new Domain.User.UserProfile
{
FirstName = userDto.FirstName,
LastName = userDto.LastName,
Address = $"94, Bideford Road, Ruislip",
City = "London",
},
UserRoleId = 1
};
try
{
var userInfo = await _userService.CreateAsync(user, userDto.Password);
return(new OkObjectResult(userInfo));
}
catch (Exception ex)
{
return(BadRequest(new { message = ex.Message }));
}
}
public void CreateUser_Returns_Correct_Response()
{
var user = new Domain.User.User("Name", "Email", DateTime.UtcNow);
Assert.Equal("Email", user.UserEmail);
Assert.Equal("Name", user.UserName);
}
public async Task <int> CreateUser(CreatUser createUser)
{
var user = new Domain.User.User(createUser.UserName, createUser.Email, createUser.Password, createUser.Code);
int Id = await _userRepository.AddUser(user);
return(Id);
}
public void ConvertToDTOTest()
{
var user = new Domain.User.User {
Id = Guid.NewGuid(),
FirstName = "test",
LastName = "test",
Address = new Address {
Country = "UK"
}
};
var task = new Domain.Task.Task {
Id = Guid.NewGuid(),
Name = "test",
Time = DateTime.Now,
User = user
};
var mapper = new TaskDtoMapper();
var result = mapper.ConvertToDTO(task);
Assert.AreEqual(task.Id, result.Id);
Assert.AreEqual(task.Name, result.Name);
Assert.AreEqual(task.Time, result.Time);
Assert.AreEqual(user.Id, result.UserId);
Assert.AreEqual(user.FirstName, result.UserFirstName);
Assert.AreEqual(user.LastName, result.UserLastName);
}
public void DeleteUserTest()
{
var testGuid = Guid.NewGuid();
var usersRequest = new DeleteUserRequest(testGuid);
var expectedUser = new Domain.User.User {
Id = Guid.NewGuid(),
FirstName = "test",
LastName = "test",
Address = new Address {
Country = "UK"
}
};
var mockUow = new Mock <IUnitOfWork>();
var mockRepo = new Mock <IUserRepository>();
mockRepo.Setup(x => x.Delete(expectedUser));
mockRepo.Setup(x => x.FindBy(usersRequest.Id)).Returns(expectedUser);
var mockMapper = new Mock <IUserDtoMapper>();
var mockValidator = new Mock <IValidator <Domain.User.User> >();
var service = new UserService(mockUow.Object, mockRepo.Object, mockMapper.Object, mockValidator.Object);
var response = service.DeleteUser(usersRequest);
Assert.IsTrue(response.Result);
Assert.IsNull(response.Exception);
mockRepo.Verify(x => x.Delete(expectedUser), Times.Once);
mockUow.Verify(x => x.Commit(), Times.Once);
}
public void UpdateUserTest()
{
var testGuid = Guid.NewGuid();
var userRequest = new UpdateUserRequest(testGuid)
{
UserProperties = new UserEditDTO {
FirstName = "test2",
LastName = "test2",
Country = "UK",
City = "London",
Street = "Baker street",
HouseNumber = "221B"
}
};
var expectedUser = new Domain.User.User {
Id = testGuid,
FirstName = "test",
LastName = "test",
Address = new Address {
Country = "UK",
City = "London",
Street = "Baker street",
HouseNumber = "221B"
}
};
var expectedUpdatedUser = expectedUser;
expectedUpdatedUser.FirstName = userRequest.UserProperties.FirstName;
expectedUpdatedUser.LastName = userRequest.UserProperties.LastName;
var mockUow = new Mock <IUnitOfWork>();
var mockRepo = new Mock <IUserRepository>();
mockRepo.Setup(x => x.Update(expectedUser));
mockRepo.Setup(x => x.FindBy(userRequest.Id)).Returns(expectedUser);
var mockMapper = new Mock <IUserDtoMapper>();
mockMapper.Setup(x => x.PopulateDomainObject(expectedUser, userRequest.UserProperties))
.Returns(expectedUpdatedUser);
var mockValidator = new Mock <IValidator <Domain.User.User> >();
mockValidator.Setup(x => x.GetBrokenRules(expectedUser)).Returns(new List <BusinessRule>());
var service = new UserService(mockUow.Object, mockRepo.Object, mockMapper.Object, mockValidator.Object);
var response = service.UpdateUser(userRequest);
Assert.IsTrue(response.Result);
Assert.IsNull(response.Exception);
Assert.AreEqual(userRequest.UserProperties.FirstName, expectedUpdatedUser.FirstName);
Assert.AreEqual(userRequest.UserProperties.LastName, expectedUpdatedUser.LastName);
mockRepo.Verify(x => x.Update(expectedUser), Times.Once);
mockUow.Verify(x => x.Commit(), Times.Once);
}
public bool UpdateUser(int userID, Domain.User.User newUser)
{
bool isFound = true;
try
{
var oldUser = _appDbContext.Users.FirstOrDefault(user => user.UserID == userID);
if (oldUser == null)
{
isFound = false;
}
oldUser.Name = newUser.Name;
oldUser.EmailID = newUser.EmailID;
oldUser.IsAdmin = newUser.IsAdmin;
oldUser.MobileNumber = newUser.MobileNumber;
_appDbContext.SaveChanges();
return(isFound);
}
catch (Exception exception)
{
throw exception;
}
}
public void GetBrokenRulesValidAddressTest()
{
var user = new Domain.User.User
{
Id = Guid.NewGuid(),
FirstName = "test",
LastName = "test",
Address = new Domain.Address.Address
{
Country = "UK",
City = "London",
Street = "Baker street",
HouseNumber = "221B"
}
};
var mockAddressValidator = new Mock <IValidator <Domain.Address.Address> >();
mockAddressValidator.Setup(x => x.GetBrokenRules(user.Address)).Returns(new List <BusinessRule>());
var validator = new UserValidator(new List <ISpecification <Domain.User.User> >(),
mockAddressValidator.Object);
var broken = validator.GetBrokenRules(user);
Assert.IsTrue(!broken.Any());
}
public void ConvertToDTOMutipleTest()
{
var user1 = new Domain.User.User {
Id = Guid.NewGuid(),
FirstName = "test",
LastName = "test",
Address = new Address {
Country = "UK",
City = "London",
Street = "Baker street",
HouseNumber = "221B"
}
};
var user2 = new Domain.User.User {
Id = Guid.NewGuid(),
FirstName = "test2",
LastName = "test2",
Address = new Address {
Country = "US",
City = "New York",
Street = "Test street",
HouseNumber = "123"
}
};
var users = new List <Domain.User.User> {
user1,
user2
};
var mapper = new UserDtoMapper();
var results = mapper.ConvertToDTO(users);
Assert.AreEqual(2, results.Count());
var firstDto = results.First();
Assert.AreEqual(user1.Id, firstDto.Id);
Assert.AreEqual(user1.FirstName, firstDto.FirstName);
Assert.AreEqual(user1.LastName, firstDto.LastName);
Assert.AreEqual(user1.Address.Country, firstDto.Country);
Assert.AreEqual(user1.Address.City, firstDto.City);
Assert.AreEqual(user1.Address.Street, firstDto.Street);
Assert.AreEqual(user1.Address.HouseNumber, firstDto.HouseNumber);
var lastDto = results.Last();
Assert.AreEqual(user2.Id, lastDto.Id);
Assert.AreEqual(user2.FirstName, lastDto.FirstName);
Assert.AreEqual(user2.LastName, lastDto.LastName);
Assert.AreEqual(user2.Address.Country, lastDto.Country);
Assert.AreEqual(user2.Address.City, lastDto.City);
Assert.AreEqual(user2.Address.Street, lastDto.Street);
Assert.AreEqual(user2.Address.HouseNumber, lastDto.HouseNumber);
}
public void CreateUser_Returns_Correct_Response()
{
var user = new Domain.User.User("Name", "*****@*****.**", Gender.Male, DateTime.UtcNow);
Assert.Equal(Gender.Male, user.Gender);
Assert.Equal("*****@*****.**", user.Email);
Assert.Equal("Name", user.UserName);
}
public async Task <Domain.User.User> CreateUser(CreateUser createUser)
{
var user = new Domain.User.User(createUser.UserName, createUser.Email, createUser.Password, createUser.Gender, createUser.BirthDate);
user.Id = await _userRepository.AddUser(user);
return(user);
}
public void ConvertToDTOMutipleTest()
{
var user = new Domain.User.User
{
Id = Guid.NewGuid(),
FirstName = "test",
LastName = "test",
Address = new Address
{
Country = "UK"
}
};
var task1 = new Domain.Task.Task
{
Id = Guid.NewGuid(),
Name = "test",
Time = DateTime.Now,
User = user
};
var task2 = new Domain.Task.Task
{
Id = Guid.NewGuid(),
Name = "test2",
Time = DateTime.Now,
User = user
};
var tasks = new List <Domain.Task.Task> {
task1,
task2
};
var mapper = new TaskDtoMapper();
var results = mapper.ConvertToDTO(tasks);
Assert.AreEqual(2, results.Count());
var firstDto = results.First();
Assert.AreEqual(task1.Name, firstDto.Name);
Assert.AreEqual(task1.Time, firstDto.Time);
Assert.AreEqual(task1.User.Id, firstDto.UserId);
Assert.AreEqual(task1.User.FirstName, firstDto.UserFirstName);
Assert.AreEqual(task1.User.LastName, firstDto.UserLastName);
var lastDto = results.Last();
Assert.AreEqual(task2.Name, lastDto.Name);
Assert.AreEqual(task2.Time, lastDto.Time);
Assert.AreEqual(task2.User.Id, lastDto.UserId);
Assert.AreEqual(task2.User.FirstName, lastDto.UserFirstName);
Assert.AreEqual(task2.User.LastName, lastDto.UserLastName);
}
private void ThrowExceptionIfUserIsInvalid(Domain.User.User newUser)
{
var brokenRules = new BusinessRuleCollection(_userValidator.GetBrokenRules(newUser));
if (brokenRules.HasRules())
{
throw new ValidationException(brokenRules.GetRulesSummary());
}
}
public async Task EditUser(Domain.User.User user)
{
var editUser = await _context.User.FirstOrDefaultAsync(x => x.UserId == user.Id);
editUser.UserName = user.UserName;
editUser.Email = user.Email;
editUser.Gender = user.Gender;
editUser.BirthDate = user.BirthDate;
await _context.SaveChangesAsync();
}
public void AddUser(Domain.User.User user)
{
try
{
_userRepository.AddUser(user);
}
catch (Exception exception)
{
throw exception;
}
}
public bool UpdateUser(int userID, Domain.User.User newUser)
{
try
{
return(_userRepository.UpdateUser(userID, newUser));
}
catch (Exception exception)
{
throw exception;
}
}
public void AddPictureLocationToUser(string userId, string imgpath)
{
Domain.User.User user = this.GetUser(userId);
if (user == null)
{
throw new ArgumentException("User not found.");
}
user.ProfilePictureLocation = imgpath;
_userRepository.UpdateUser(user);
}
public void AddIdeaToUser(Idea idea, string userId)
{
Domain.User.User user = this.GetUser(userId);
if (user == null)
{
throw new ArgumentException("User not found.");
}
idea.CreatedBy = user;
user.Ideas.Add(idea);
_userRepository.UpdateUser(user);
}
public async Task SyncNameToAuth0Async(Domain.User.User internalUser, CancellationToken cancellationToken = default)
{
var client = await _auth0ManagementApiClientCreator.GetClient(cancellationToken);
var request = new UserUpdateRequest
{
Connection = _environmentSettings.Auth0.Connection,
FirstName = internalUser.GivenName,
LastName = $"{internalUser.MiddleName} {internalUser.FamilyName}".Trim()
};
await client.Users.UpdateAsync(internalUser.Id.ToString(), request, cancellationToken);
}
public void AddAnswerToUser(Answer answer, string userId)
{
Domain.User.User user = this.GetUser(userId);
if (user == null)
{
throw new ArgumentException("User not found.");
}
answer.User = user;
user.Answers.Add(answer);
_userRepository.UpdateUser(user);
}
public async Task <Domain.User.User> CreateAsync(Domain.User.User model)
{
if (model != null)
{
await this.userContext.AddAsync(new UserMapper(model).Destination);
await this.userContext.SaveChangesAsync();
return(model);
}
throw new ArgumentException("Model is null");
}
public DbModels.User ConvertToDatabaseType(Domain.User.User domainType)
{
return(new DbModels.User {
Id = domainType.Id,
FirstName = domainType.FirstName,
LastName = domainType.LastName,
Country = domainType.Address.Country,
City = domainType.Address.City,
Street = domainType.Address.Street,
HouseNumber = domainType.Address.HouseNumber
});
}
public void AddCommentToUser(Comment comment, string userId)
{
Domain.User.User user = GetUser(userId);
if (user == null)
{
throw new ArgumentException("User not found.");
}
comment.User = user;
user.Comments.Add(comment);
_userRepository.UpdateUser(user);
}
public void AddUser(Domain.User.User user)
{
try
{
user.Status = "Inactive";
_appDbContext.Users.Add(user);
_appDbContext.SaveChanges();
}
catch (Exception exception)
{
throw exception;
}
}
public UserDTO ConvertToDTO(Domain.User.User user)
{
return(new UserDTO
{
Id = user.Id,
FirstName = user.FirstName,
LastName = user.LastName,
Country = user.Address?.Country,
City = user.Address?.City,
Street = user.Address?.Street,
HouseNumber = user.Address?.HouseNumber
});
}
public async Task SyncEmailToAuth0Async(Domain.User.User internalUser, CancellationToken cancellationToken = default)
{
var client = await _auth0ManagementApiClientCreator.GetClient(cancellationToken);
var request = new UserUpdateRequest
{
Connection = _environmentSettings.Auth0.Connection,
Email = internalUser.Email,
EmailVerified = false,
VerifyEmail = true
};
await client.Users.UpdateAsync(internalUser.Id.ToString(), request, cancellationToken);
}
