public void RegisterUser(string email)
{
// check if email is valid
if (_emailValidator.Validate(email) == false)
{
throw new ArgumentException("Invalid email address");
}
// check if email is not taken
if (_usersDatabase.IsEmailTaken(email))
{
throw new InvalidOperationException("Email already taken");
}
// create new user
var newUser = new User
{
Email = email,
RegistrationToken = Guid.NewGuid().ToString(),
};
// insert user
_usersDatabase.InsertUser(newUser);
// generate activation link
string registrationLink = _activationLinkGenerator.GenerateLink(newUser.RegistrationToken, newUser.Email);
_emailService.RegistrationEmail(newUser.Email, registrationLink);
}
private bool InvalidFields(AddPatientRequest request, ref PdrValidationResult result)
{
var errors = new List <string>();
if (string.IsNullOrEmpty(request.FirstName))
{
errors.Add("FirstName must be populated");
}
if (string.IsNullOrEmpty(request.LastName))
{
errors.Add("LastName must be populated");
}
if (string.IsNullOrEmpty(request.Email))
{
errors.Add("Email must be populated");
}
if (!_emailValidator.Validate(request.Email))
{
errors.Add("Email must be a valid email address");
}
if (errors.Any())
{
result.PassedValidation = false;
result.Errors.AddRange(errors);
return(true);
}
return(false);
}
private void ValidateUser(UserProxy user)
{
if (user == null)
{
ThrowHttp.BadRequest(ErrorMessage.USER_REQUIRED);
}
var emailError = _emailValidator.Validate(user.Email);
if (emailError != null)
{
ThrowHttp.BadRequest(emailError);
}
var passwordError = _passwordValidator.Validate(user.Password);
if (passwordError != null)
{
ThrowHttp.BadRequest(passwordError);
}
if (string.IsNullOrWhiteSpace(user.FirstName))
{
ThrowHttp.BadRequest(ErrorMessage.FIRST_NAME_REQUIRED);
}
if (string.IsNullOrWhiteSpace(user.LastName))
{
ThrowHttp.BadRequest(ErrorMessage.LAST_NAME_REQUIRED);
}
}
public void throws_when_email_not_valid()
{
_emailValidator.Validate(_email).Returns(false);
Assert.Throws <ArgumentException>(
() => execute()
);
}
public SmtpResponse VerifyRecipientTo(ISmtpSessionInfo sessionInfo, MailAddressWithParameters mailAddressWithParameters)
{
if (!_emailValidator.Validate(mailAddressWithParameters.MailAddress))
{
return(SmtpResponses.SyntaxError);
}
return(SmtpResponses.OK);
}
/// <summary>
/// Creates a User
/// </summary>
internal static void CreateUser()
{
UserDTO user = new UserDTO();
user.Name = "test";
user.Age = 15;
user.Email = "test.com";
user.ValidateUser();
user.ValidateEmail();
user.SaveUser();
// Using Single Responsibility
GetInstances();
userValidator.IsValid(user);
emailValidator.Validate(user.Email);
userCreateService.Save(user);
}
public async Task ValidateAsync(Guid?userId, string email, string displayName, string password, string postalCode)
{
ArgumentNotNullValidator.Validate(email, nameof(email));
ArgumentNotNullValidator.Validate(displayName, nameof(displayName));
ArgumentNotNullValidator.Validate(password, nameof(password));
ArgumentNotNullValidator.Validate(postalCode, nameof(postalCode));
if (string.IsNullOrWhiteSpace(password))
{
throw new DomainValidationException(new ArgumentException(string.Format("Password cannot be empty or whitespace")));
}
_emailValidator.Validate(email);
await _postalCodeValidator.ValidateAsync(
postalCode,
PostalCodeValidatorTypes.Format | PostalCodeValidatorTypes.Exists);
await CheckIfEmailInUse(userId, email);
ValidateDisplayName(displayName);
}
public bool Login(string email, string password)
{
if (!_emailValidator.Validate(email))
{
throw new InvalidEmailException(email);
}
if (!_passwordValidator.Validate(password))
{
throw new InvalidPasswordException();
}
var user = _userRepository.FindUser(email);
if (user == null)
{
throw new UserNotFoundException(email);
}
var comparePass = user.Password.Equals(password);
if (!comparePass)
{
throw new NotPasswordMatchException();
}
return(true);
}
private bool Execute()
{
return(_validator.Validate(_email));
}
