public async Task <TDocument> FindById(string id)
{
var filter = MongoExtension.GetBuilders <TDocument>().Eq(x => x.Id, id)
& MongoExtension.GetBuilders <TDocument>().Ne(x => x.IsDeleted, true);
return(await(await Collection.FindAsync(filter)).FirstAsync());
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddCors();
services.AddControllers();
var healthCheckBuilder = services.AddHealthChecks();
services
.AddScoped <IOrganisationService, OrganisationService>()
.AddScoped <IApplicationService, ApplicationService>()
.AddScoped <IVersionService, ApplicationService>()
.AddScoped <ITeamService, TeamService>()
.AddScoped <IUserService, UserService>()
.AddScoped <IGithubEventResultService, GithubEventResultService>()
.AddSingleton <IGitHubWebHookService, GitHubWebHookService>(svc =>
{
return(new GitHubWebHookService(
(IGithubEventResultRepository)MongoExtension.GetRepository <IGithubEventResultRepository>(),
(IApplicationRepository)MongoExtension.GetRepository <IApplicationRepository>()
));
})
.AddMapping()
//.AddLiteDb(Configuration)
.AddMongoDB(Configuration, healthCheckBuilder)
.AddAuthorization(options =>
{
options.DefaultPolicy = new AuthorizationPolicyBuilder(JwtBearerDefaults.AuthenticationScheme)
.RequireAuthenticatedUser()
.Build();
})
.AddBearerTokenValidation(Configuration.GetValue <string>("Auth:SecretKey"), TimeSpan.FromMinutes(120));
}
public void ShouldAddMongoToExcludedAssemblies()
{
//Act
var result = new MongoExtension(registrationHelper);
//Assert
Assert.IsNotNull(result);
Assert.IsTrue(Bootstrapper.Excluding.Assemblies.Contains("MongoDB.Bson"));
Assert.IsTrue(Bootstrapper.Excluding.Assemblies.Contains("MongoDB.Driver"));
}
public void ShouldCreateAMongoExtension()
{
//Act
var result = new MongoExtension(registrationHelper);
//Assert
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(IBootstrapperExtension));
Assert.IsInstanceOfType(result, typeof(MongoExtension));
}
public async Task <UserDto> Get(string userId)
{
var userRepo = _unitOfWork.GetRepository <User>();
var userQuery = MongoExtension.GetBuilders <User>()
.Eq(x => x.Id, userId);
var user = await userRepo.FirstOrDefault(userQuery);
MyMethod();
return(user != null?_mapper.Map <UserDto>(user) : null);
}
public async Task <BaseResponseDto <LoginResponseDto> > GoogleLogin(GoogleLoginRequestDto loginRequestDto)
{
if (loginRequestDto == null || string.IsNullOrEmpty(loginRequestDto.Token))
{
return(new BaseResponseDto <LoginResponseDto>()
.GenerateFailedResponse(ErrorCodes.BadRequest));
}
var payload = await GoogleJsonWebSignature.ValidateAsync(loginRequestDto.Token);
var jwtSetting = GetJwtSetting();
var userRepo = _unitOfWork.GetRepository <User>();
var userQuery = MongoExtension.GetBuilders <User>()
.Regex(x => x.Email, payload.Email.MongoIgnoreCase());
var user = await userRepo.FirstOrDefault(userQuery);
LoginResponseDto loginResponseDto;
if (user == null)
{
user = new User
{
Email = payload.Email,
FirstName = payload.GivenName,
LastName = payload.FamilyName,
Role = UserRole.User,
GooglePassword = Guid.NewGuid().ToString().HashMd5()
};
await userRepo.Insert(user);
loginResponseDto = new LoginResponseDto
{
User = _mapper.Map <UserResponseDto>(user),
Token = user.GenerateAccessToken(jwtSetting, true)
};
return(new BaseResponseDto <LoginResponseDto>().GenerateSuccessResponse(loginResponseDto));
}
loginResponseDto = new LoginResponseDto
{
User = _mapper.Map <UserResponseDto>(user),
Token = user.GenerateAccessToken(jwtSetting, true)
};
return(new BaseResponseDto <LoginResponseDto>().GenerateSuccessResponse(loginResponseDto));
}
public async Task <BaseResponseDto <LoginResponseDto> > ConfirmAccount(string token)
{
var userRepo = _unitOfWork.GetRepository <User>();
var userQuery = MongoExtension.GetBuilders <User>()
.Regex(x => x.ConfirmationToken, token.MongoIgnoreCase());
var user = await userRepo.FirstOrDefault(userQuery);
if (user == null)
{
_logger.LogError($"Unable to find any user with this confirmation token: {token}");
return(new BaseResponseDto <LoginResponseDto>()
.GenerateFailedResponse(ErrorCodes.NotFound));
}
var jwtSetting = GetJwtSetting();
LoginResponseDto loginResponseDto;
if (user.IsConfirmed)
{
loginResponseDto = new LoginResponseDto
{
User = _mapper.Map <UserResponseDto>(user),
Token = user.GenerateAccessToken(jwtSetting, true)
};
return(new BaseResponseDto <LoginResponseDto>().GenerateSuccessResponse(loginResponseDto));
}
user.IsConfirmed = true;
user.ConfirmationToken = null;
var updateDefinition = new UpdateDefinitionBuilder <User>()
.Set(x => x.IsConfirmed, user.IsConfirmed)
.Set(x => x.ConfirmationToken, user.ConfirmationToken);
await userRepo.UpdatePartial(user, updateDefinition);
loginResponseDto = new LoginResponseDto
{
User = _mapper.Map <UserResponseDto>(user),
Token = user.GenerateAccessToken(jwtSetting)
};
return(new BaseResponseDto <LoginResponseDto>().GenerateSuccessResponse(loginResponseDto));
}
public async Task <BaseResponseDto <LoginResponseDto> > Register(RegisterDto registerDto)
{
if (registerDto == null ||
string.IsNullOrEmpty(registerDto.Email) ||
string.IsNullOrEmpty(registerDto.Password))
{
return(new BaseResponseDto <LoginResponseDto>().GenerateFailedResponse(ErrorCodes.BadRequest));
}
var userRepo = _unitOfWork.GetRepository <User>();
var userQuery = MongoExtension.GetBuilders <User>()
.Regex(x => x.Email, registerDto.Email.MongoIgnoreCase());
var existed = await userRepo.Count(userQuery);
if (existed != 0)
{
return(new BaseResponseDto <LoginResponseDto>().GenerateFailedResponse(ErrorCodes.EmailExists));
}
var user = _mapper.Map <User>(registerDto);
user.FirstName = user.FirstName.Trim();
user.LastName = user.LastName.Trim();
user.Email = user.Email.Trim();
user.Password = user.Password.HashMd5();
user.ConfirmationToken = Guid.NewGuid().ToString().HashMd5();
user.Role = UserRole.User;
await userRepo.Insert(user);
await _emailService.Send(new EmailDto
{
Title = EmailTemplates.ConfirmAccountTitle,
Address = user.Email,
Content = EmailTemplates.ConfirmAccountBody
.Replace("#name#", user.FirstName)
.Replace("#link#", $"{_configuration[AppSettingKeys.FrontEndHost]}/confirm-account/{user.ConfirmationToken}")
});
return(await Login(new LoginRequestDto
{
Email = registerDto.Email,
Password = registerDto.Password
}));
}
public void ShouldInvokeConfigureForAllProfilesWhenNoContainerExtensionHasBeenDeclared()
{
//Arrange
var profiles = new List <BsonClassMap> {
new TestMongoClassMap()
};
A.CallTo(() => registrationHelper.GetInstancesOfTypesImplementing <BsonClassMap>()).Returns(profiles);
var mapperExtension = new MongoExtension(registrationHelper);
//Act
mapperExtension.Run();
//Assert
A.CallTo(() => registrationHelper.GetInstancesOfTypesImplementing <BsonClassMap>()).MustHaveHappened();
Assert.IsTrue(BsonClassMap.IsClassMapRegistered(typeof(TestMongo)));
}
public void ShouldInvokeConfigureForAllRegisteredProfiles()
{
//Arrange
var containerExtension = A.Fake <IBootstrapperContainerExtension>();
var profiles = new List <BsonClassMap> {
new TestMongoClassMap()
};
A.CallTo(() => containerExtension.ResolveAll <BsonClassMap>()).Returns(profiles);
Bootstrapper.With.Extension(containerExtension);
var mapperExtension = new MongoExtension(registrationHelper);
//Act
mapperExtension.Run();
//Assert
A.CallTo(() => containerExtension.ResolveAll <BsonClassMap>()).MustHaveHappened();
Assert.IsTrue(BsonClassMap.IsClassMapRegistered(typeof(TestMongo)));
}
public async Task <BaseResponseDto <bool> > SendAccountConfirmation()
{
var userId = _httpContextAccessor.HttpContext.UserId();
var userRepo = _unitOfWork.GetRepository <User>();
var userQuery = MongoExtension.GetBuilders <User>()
.Eq(x => x.Id, userId);
var user = await userRepo.FirstOrDefault(userQuery);
if (user == null)
{
_logger.LogError("user is null");
return(new BaseResponseDto <bool>().GenerateFailedResponse(ErrorCodes.NotFound));
}
if (user.IsConfirmed)
{
_logger.LogError("user is confirmed");
return(new BaseResponseDto <bool>().GenerateSuccessResponse(true));
}
if (string.IsNullOrEmpty(user.ConfirmationToken))
{
user.ConfirmationToken = Guid.NewGuid().ToString().HashMd5();
var updateDefinition = new UpdateDefinitionBuilder <User>()
.Set(x => x.ConfirmationToken, user.ConfirmationToken);
await userRepo.UpdatePartial(user, updateDefinition);
}
var result = await _emailService.Send(new EmailDto
{
Title = EmailTemplates.ConfirmAccountTitle,
Address = user.Email,
Content = EmailTemplates.ConfirmAccountBody
.Replace("#name#", user.FirstName)
.Replace("#link#", $"{_configuration[AppSettingKeys.FrontEndHost]}/confirm-account/{user.ConfirmationToken}")
});
return(new BaseResponseDto <bool>().GenerateSuccessResponse(result));
}
public async Task <BaseResponseDto <bool> > ForgotPassword(string email)
{
if (string.IsNullOrEmpty(email))
{
return(new BaseResponseDto <bool>()
.GenerateFailedResponse(ErrorCodes.BadRequest));
}
var userRepo = _unitOfWork.GetRepository <User>();
var queryBuilder = MongoExtension.GetBuilders <User>();
var userQuery = queryBuilder
.Regex(x => x.Email, email.MongoIgnoreCase());
var user = await userRepo.FirstOrDefault(userQuery);
if (user == null)
{
return(new BaseResponseDto <bool>()
.GenerateFailedResponse(ErrorCodes.EmailExists));
}
var newPassword = 8.GenerateRandomPassword();
user.Password = newPassword.HashMd5();
var updateDefinition = new UpdateDefinitionBuilder <User>()
.Set(x => x.Password, user.Password);
await userRepo.UpdatePartial(user, updateDefinition);
var result = await _emailService.Send(new EmailDto
{
Title = EmailTemplates.ForgotPasswordTitle,
Address = user.Email,
Content = EmailTemplates.ForgotPasswordBody
.Replace("#name#", user.FirstName)
.Replace("#password#", newPassword)
});
return(new BaseResponseDto <bool>().GenerateSuccessResponse(result));
}
public async Task <BaseResponseDto <bool> > Insert(InsertUserDto insertUserDto)
{
if (insertUserDto == null)
{
_logger.LogError("InsertUserDto is null");
return(new BaseResponseDto <bool>().GenerateFailedResponse(ErrorCodes.BadRequest));
}
if (string.IsNullOrEmpty(insertUserDto.Email) ||
string.IsNullOrEmpty(insertUserDto.Password))
{
_logger.LogError("Email or password is empty");
return(new BaseResponseDto <bool>().GenerateFailedResponse(ErrorCodes.BadRequest));
}
var userRepo = _unitOfWork.GetRepository <User>();
var userQuery = MongoExtension.GetBuilders <User>()
.Regex(x => x.Email, insertUserDto.Email.MongoIgnoreCase());
var existed = await userRepo.Count(userQuery);
if (existed != 0)
{
_logger.LogError($"Email exists: {insertUserDto.Email}");
return(new BaseResponseDto <bool>().GenerateFailedResponse(ErrorCodes.EmailExists));
}
var user = _mapper.Map <User>(insertUserDto);
user.Password = user.Password.HashMd5();
user.Role = UserRole.User;
await userRepo.Insert(user);
_logger.LogInformation("Insert user success");
return(new BaseResponseDto <bool>().GenerateSuccessResponse(true));
}
public async Task <BaseResponseDto <LoginResponseDto> > Login(LoginRequestDto loginRequestDto)
{
if (loginRequestDto == null)
{
return(new BaseResponseDto <LoginResponseDto>()
.GenerateFailedResponse(ErrorCodes.BadRequest));
}
if (string.IsNullOrEmpty(loginRequestDto.Email) ||
string.IsNullOrEmpty(loginRequestDto.Password))
{
return(new BaseResponseDto <LoginResponseDto>()
.GenerateFailedResponse(ErrorCodes.InvalidCredential));
}
var userRepo = _unitOfWork.GetRepository <User>();
var queryBuilder = MongoExtension.GetBuilders <User>();
var userQuery = queryBuilder
.Regex(x => x.Email, loginRequestDto.Email.MongoIgnoreCase());
var user = await userRepo.FirstOrDefault(userQuery);
if (user == null || user.Password != loginRequestDto.Password.HashMd5())
{
return(new BaseResponseDto <LoginResponseDto>()
.GenerateFailedResponse(ErrorCodes.InvalidCredential));
}
var jwtSetting = GetJwtSetting();
var loginResponseDto = new LoginResponseDto
{
User = _mapper.Map <UserResponseDto>(user),
Token = user.GenerateAccessToken(jwtSetting)
};
return(new BaseResponseDto <LoginResponseDto>().GenerateSuccessResponse(loginResponseDto));
}
public async Task <BaseResponseDto <ChangePasswordResponseDto> > ChangePassword(ChangePasswordRequestDto changePasswordRequestDto)
{
if (changePasswordRequestDto == null)
{
_logger.LogError("changePasswordRequestDto is null");
return(new BaseResponseDto <ChangePasswordResponseDto>().GenerateFailedResponse(ErrorCodes.BadRequest));
}
if (string.IsNullOrEmpty(changePasswordRequestDto.NewPassword))
{
_logger.LogError("NewPassword is null");
return(new BaseResponseDto <ChangePasswordResponseDto>().GenerateFailedResponse(ErrorCodes.BadRequest));
}
if (changePasswordRequestDto.CurrentPassword == changePasswordRequestDto.NewPassword)
{
_logger.LogError("NewPassword is the same as current password");
return(new BaseResponseDto <ChangePasswordResponseDto>().GenerateFailedResponse(ErrorCodes.SameNewPassword));
}
var hashCurrentPassword = changePasswordRequestDto.CurrentPassword.HashMd5();
var userId = _httpContextAccessor.HttpContext.UserId();
var builder = MongoExtension.GetBuilders <User>();
var userRepo = _unitOfWork.GetRepository <User>();
var user = await userRepo.FirstOrDefault(builder.Eq(x => x.Id, userId));
if (user == null)
{
_logger.LogError("User is null");
return(new BaseResponseDto <ChangePasswordResponseDto>().GenerateFailedResponse(ErrorCodes.NotFound));
}
if (!user.IsConfirmed)
{
return(new BaseResponseDto <ChangePasswordResponseDto>().GenerateFailedResponse(ErrorCodes.AccountHasNotBeenConfirmed));
}
if (!_httpContextAccessor.HttpContext.IsGoogleLogin() && user.Password != hashCurrentPassword)
{
_logger.LogError("Incorrect password");
return(new BaseResponseDto <ChangePasswordResponseDto>().GenerateFailedResponse(ErrorCodes.IncorrectCurrentPassword));
}
var hashNewPassword = changePasswordRequestDto.NewPassword.HashMd5();
user.Password = hashNewPassword;
var updateDefinition = new UpdateDefinitionBuilder <User>()
.Set(x => x.Password, user.Password);
await userRepo.UpdatePartial(user, updateDefinition);
var jwtSetting = GetJwtSetting();
return(new BaseResponseDto <ChangePasswordResponseDto>().GenerateSuccessResponse(new ChangePasswordResponseDto
{
Token = user.GenerateAccessToken(jwtSetting)
}));
}
public async Task <TDocument> FirstOrDefault(FilterDefinition <TDocument> filter, FindOptions <TDocument, TDocument> options = null)
{
filter &= MongoExtension.GetBuilders <TDocument>().Ne(x => x.IsDeleted, true);
return(await(await Collection.FindAsync(filter, options)).FirstOrDefaultAsync());
}
public async Task <long> Count(FilterDefinition <TDocument> filter, CountOptions options = null)
{
filter &= MongoExtension.GetBuilders <TDocument>().Ne(x => x.IsDeleted, true);
return(await Collection.CountDocumentsAsync(filter, options));
}
public async Task <IEnumerable <TDocument> > FindAll()
{
var filter = MongoExtension.GetBuilders <TDocument>().Ne(x => x.IsDeleted, true);
return(await(await Collection.FindAsync(filter)).ToListAsync());
}
