public IEnumerable <ValidationResult> Validate(ValidationContext validationContext)
{
IValidationResultHelper <SubjectModel> helper = new ValidationResultHelper <SubjectModel>(this);
helper.Validate(model => model.Code).Required(true).ErrorMsg("Code field is required");
helper.Validate(model => model.Level).Required(true).GreaterThan(0).ErrorMsg("Year level field is required");
helper.Validate(model => model.Units).Required(true).GreaterThan(0).ErrorMsg("Units field is required");
helper.Validate(model => model.Status).Required(true).GreaterThan(0).ErrorMsg("Status field is required");
if (!helper.Failed)
{
Transaction.Scope(scope => scope.Service <SubjectValidatorService>(service =>
{
helper.Validate(model => model.Code).Required(true).IF(service.CheckSubjectCodeExists(Id, Code)).ErrorMsg(string.Format("Subject \"{0}\" is already exists!", Code));
}));
}
if (helper.Failed)
{
foreach (var error in helper.Errors)
{
yield return(error);
}
}
}
public void Validate_FileStreamIsNull_ReturnFalse()
{
// Act
var result = _validator.Validate("Test.jpg", null);
// Assert
Assert.False(result.IsValid);
Assert.AreEqual("FileStreamIsNull", ValidationResultHelper.GetFirstErrorCodeName(result));
}
public void Validate_FileNameIsNullOrEmpty_ReturnFalse()
{
// Act
var result = _validator.Validate("", null);
// Assert
Assert.False(result.IsValid);
Assert.AreEqual("FileNameNullOrWhitespace", ValidationResultHelper.GetFirstErrorCodeName(result));
}
public void Validate_FileExtensionIsInvalid_ReturnFalse()
{
// Act
var result = _validator.Validate("Test.tiff", null);
// Assert
Assert.False(result.IsValid);
Assert.AreEqual("FileExtensionEmptyOrInvalid", ValidationResultHelper.GetFirstErrorCodeName(result));
}
public DateTimeValidator(ValidationResultHelper <TModel> helper, IModelProperty <DateTime?> property)
{
_helper = helper;
_property = property;
if (_property.Value < (DateTime)SqlDateTime.MinValue)
{
Failed = true;
}
}
public void Validate_InvalidJweToken_ReturnFalse(string input)
{
// Act
var result = _validator.Validate(input);
// Assert
Assert.False(result.IsValid);
Assert.AreEqual("NotJweToken", ValidationResultHelper.GetFirstErrorCodeName(result));
}
public void Validate_HashIsNotSHA256_ReturnFalse(string passwordHash)
{
// Act
var result = _validator.Validate(passwordHash);
// Assert
Assert.False(result.IsValid);
Assert.AreEqual("NotSha256", ValidationResultHelper.GetFirstErrorCodeName(result));
}
public void Validate_NullOrEmpty_ReturnFalse(string passwordHash)
{
// Act
var result = _validator.Validate(passwordHash);
// Assert
Assert.False(result.IsValid);
Assert.AreEqual("NullOrEmpty", ValidationResultHelper.GetFirstErrorCodeName(result));
}
public void Validate_FileStreamIsTooShort_ReturnFalse()
{
// Arrange
var stream = new MemoryStream(new byte[] { 1 });
// Act
var result = _validator.Validate("Test.jpg", stream);
// Assert
Assert.False(result.IsValid);
Assert.AreEqual("FileStreamIsTooShort", ValidationResultHelper.GetFirstErrorCodeName(result));
}
public async Task <BaseResponse> Handle(CreateRentCommandRequest request, CancellationToken cancellationToken)
{
_logger.LogInformation($"[Begin] - Creating rent : { JsonSerializer.Serialize(request) }");
try
{
var validationResult = request.Validate();
if (!validationResult.IsValid)
{
var validationResultErrors = ValidationResultHelper.GetValidationResultErrors(validationResult);
_logger.LogInformation($"[Error] - Request not valid: { validationResultErrors }");
return(new BaseResponse(false, "Ocorreu um problema ao criar o empréstimo!", HttpStatusCode.BadRequest, validationResultErrors));
}
request.SetGames(await _repository.GetGamesFromIds(request.GameIds));
if (!_rentService.CheckIfGamesAreValid(request.GetGames()))
{
_logger.LogInformation($"[Error] - Request not valid: { request }");
return(new BaseResponse(false, "Um ou mais jogos não estão disponíveis para empréstimo!", HttpStatusCode.BadRequest, request));
}
if (!await _rentService.CheckIfClientExists(request.ClientId))
{
_logger.LogInformation($"[Error] - Request not valid: { request }");
return(new BaseResponse(false, "Cliente não encontrado na base dados!", HttpStatusCode.NotFound, request));
}
request.SetClient(await _repository.GetClientById(request.ClientId));
var rent = new Domain.Aggregates.Rent(request.EndDate);
rent.AddGamesRent(request.GetGames());
rent.SetClient(request.GetClient());
await _repository.Create(rent);
_logger.LogInformation($"[End] - Rent successfully created: { JsonSerializer.Serialize(rent) }");
return(new BaseResponse(true, "Empréstimo criado com sucesso!", HttpStatusCode.OK, rent));
}
catch (Exception ex)
{
_logger.LogInformation($"[Error] - An error occurred while creating the rent: { JsonSerializer.Serialize(ex) }");
return(new BaseResponse(false, "Ocorreu um problema ao criar o empréstimo!", HttpStatusCode.InternalServerError, ex.InnerException.ToString()));
}
}
public void Validate_FileHasInvalidSignature_ReturnFalse(
ImageTypeTestDataDto dto)
{
// Act
var result = _validator.Validate(dto.File.FileName, dto.Stream);
// Assert
Assert.False(result.IsValid);
Assert.AreEqual("InvalidHexSignature", ValidationResultHelper.GetFirstErrorCodeName(result));
// Dispose
dto.Stream?.Dispose();
}
public void Validate_NullOrEmpty_ReturnFalse(string input)
{
// Arrange
var validator = new NoSpecialCharactersValidator();
// Act
var result = validator.Validate(input);
var errorCode = ValidationResultHelper.GetFirstErrorCodeName(result);
// Assert
Assert.False(result.IsValid);
Assert.AreEqual("NullOrEmpty", errorCode);
}
public void Validate_InvalidStringWithAdditionalRestrictedCharacters_ReturnsFalse(string input,
char[] additionalRestrictedCharacters)
{
// Arrange
var validator = new NoSpecialCharactersValidator(c => { c.SetRestricted(additionalRestrictedCharacters); });
// Act
var result = validator.Validate(input);
var errorCode = ValidationResultHelper.GetFirstErrorCodeName(result);
// Assert
Assert.False(result.IsValid);
Assert.AreEqual("ContainsSpecialCharacters", errorCode);
}
public async Task <BaseResponse> Handle(UpdateGameCommandRequest request, CancellationToken cancellationToken)
{
_logger.LogInformation($"[Begin] - Updating game : { JsonSerializer.Serialize(request) }");
try
{
var validationResult = request.Validate();
if (!validationResult.IsValid)
{
var validationResultErrors = ValidationResultHelper.GetValidationResultErrors(validationResult);
_logger.LogInformation($"[Error] - Request not valid: { validationResultErrors }");
return(new BaseResponse(false, "Ocorreu um problema ao atualizar o jogo!", HttpStatusCode.BadRequest, validationResultErrors));
}
if (await _gameService.CheckIfGameExists(request.Id))
{
_logger.LogInformation($"[Error] - Request not valid: { request }");
return(new BaseResponse(false, "Jogo não existe na base de dados!", HttpStatusCode.NotFound, request));
}
if (!await _gameService.CheckIfGameNameIsUnique(request.Name, request.Id))
{
_logger.LogInformation($"[Error] - Request not valid: { request }");
return(new BaseResponse(false, "Já existe um jogo cadastrado com o mesmo nome!", HttpStatusCode.BadRequest, request));
}
var game = new Domain.Entities.Game(request.Id, request.Name, request.Genre, request.Synopsis, request.Platform, request.LaunchDate, request.IsAvailable, request.IsActive);
await _repository.Update(game);
_logger.LogInformation($"[End] - Game successfully updated: { JsonSerializer.Serialize(game) }");
return(new BaseResponse(true, "Jogo atualizado com sucesso!", HttpStatusCode.OK, game));
}
catch (Exception ex)
{
_logger.LogInformation($"[Error] - An error occurred while updating the game: { JsonSerializer.Serialize(ex) }");
return(new BaseResponse(false, "Ocorreu um problema ao atualizar o jogo!", HttpStatusCode.InternalServerError, ex.InnerException.ToString()));
}
}
public async Task <BaseResponse> Handle(UpdateClientCommandRequest request, CancellationToken cancellationToken)
{
_logger.LogInformation($"[Begin] - Updating client : { JsonSerializer.Serialize(request) }");
try
{
var validationResult = request.Validate();
if (!validationResult.IsValid)
{
var validationResultErrors = ValidationResultHelper.GetValidationResultErrors(validationResult);
_logger.LogInformation($"[Error] - Request not valid: { validationResultErrors }");
return(new BaseResponse(false, "Ocorreu um problema ao atualizar o cliente!", HttpStatusCode.BadRequest, validationResultErrors));
}
if (await _clientService.CheckIfClientExists(request.Id))
{
_logger.LogInformation($"[Error] - Request not valid: { request }");
return(new BaseResponse(false, "Cliente não existe na base de dados!", HttpStatusCode.NotFound, request));
}
if (!await _clientService.CheckIfClientCpfIsUnique(request.Cpf, request.Id))
{
_logger.LogInformation($"[Error] - Request not valid: { request }");
return(new BaseResponse(false, "Já existe um cliente cadastrado com o mesmo cpf!", HttpStatusCode.BadRequest, request));
}
var client = new Domain.Entities.Client(request.Id, request.FirstName, request.LastName, request.Cpf, request.Email, request.Username, request.Password, request.Role, request.IsActive);
await _repository.Update(client);
_logger.LogInformation($"[End] - Client successfully updated: { JsonSerializer.Serialize(client) }");
return(new BaseResponse(true, "Cliente atualizado com sucesso!", HttpStatusCode.OK, client));
}
catch (Exception ex)
{
_logger.LogInformation($"[Error] - An error occurred while updating the client: { JsonSerializer.Serialize(ex) }");
return(new BaseResponse(false, "Ocorreu um problema ao atualizar o cliente!", HttpStatusCode.InternalServerError, ex.InnerException.ToString()));
}
}
public IEnumerable <ValidationResult> Validate(ValidationContext validationContext)
{
IValidationResultHelper <StudentModel> helper = new ValidationResultHelper <StudentModel>(this);
helper.Validate(model => model.CourseId).Required(true).GreaterThan(0).ErrorMsg("Course field is required");
helper.Validate(model => model.Level).Required(true).GreaterThan(0).ErrorMsg("Level field is required");
helper.Validate(model => model.SectionId).Required(true).GreaterThan(0).ErrorMsg("Section field is required");
helper.Validate(model => model.FirstName).Required(true).NotEmpty().ErrorMsg("First Name field is required")
.MaxLength(20).ErrorMsg("First Name is too long").MinLength(2).ErrorMsg("First Name is too short");
helper.Validate(model => model.LastName).Required(true).NotEmpty().ErrorMsg("Last Name field is required");
helper.Validate(model => model.BirthDate).Required(true).LessThan(DateTime.Now).ErrorMsg("Invalid date of birth");
helper.Validate(model => model.Gender).Required(true).GreaterThan(0).ErrorMsg("Gender field is required");
helper.Validate(model => model.Status).Required(true).GreaterThan(0).ErrorMsg("Status field is required");
helper.Validate(model => model.Email).Required(false).EmailAddress().ErrorMsg("Invalid email address");
helper.IF(string.IsNullOrEmpty(Email) && string.IsNullOrEmpty(Telephone) && string.IsNullOrEmpty(Mobile)).ErrorMsg("Please fill atleast one of the contact information");
if (!helper.Failed)
{
Transaction.Scope(scope => scope.Service <ValidatorService>(service =>
{
helper.Validate(model => model.FirstName).Required(true).IF(service.CheckPersonExists(Id, FirstName, LastName, BirthDate))
.ErrorMsg(string.Format("Person with name \"{0} {1}\" and birth date \"{2}\" is already exists!", FirstName, LastName, ((DateTime)BirthDate).ToShortDateString()));
helper.Validate(model => model.Email).Required(false).IF(service.CheckEmailExists(ContactInfoId, Email))
.ErrorMsg(string.Format("Email address \"{0}\" is already exists!", Email));
}));
}
if (helper.Failed)
{
foreach (var error in helper.Errors)
{
yield return(error);
}
}
}
public async Task <BaseResponse> Handle(LoginCommandRequest request, CancellationToken cancellationToken)
{
_logger.LogInformation($"[Begin] - Authenticating user : { JsonSerializer.Serialize(request) }");
try
{
var validationResult = request.Validate();
if (!validationResult.IsValid)
{
var validationResultErrors = ValidationResultHelper.GetValidationResultErrors(validationResult);
_logger.LogInformation($"[Error] - Request not valid: { validationResultErrors }");
return(new BaseResponse(false, "Ocorreu um problema ao autenticar o usuário!", HttpStatusCode.BadRequest, validationResultErrors));
}
var user = await _repository.GetByUsernameAndPassword(request.Username, request.Password);
if (user == null)
{
_logger.LogInformation($"[Error] - Request not valid: { JsonSerializer.Serialize(request) }");
return(new BaseResponse(false, "Usuário não encontrado na base de dados!", HttpStatusCode.NotFound, request));
}
var tokenResponse = await _tokenService.GenerateToken(user);
if (!tokenResponse.Success)
{
return(new BaseResponse(false, "Ocorreu um problema ao gerar o token para o usuário!", tokenResponse.Data));
}
return(new BaseResponse(true, "Usuário autenticado com sucesso!", HttpStatusCode.OK, new { request.Username, Token = tokenResponse.Data }));
}
catch (Exception ex)
{
_logger.LogInformation($"[Error] - An error occurred while authenticating the user: { JsonSerializer.Serialize(ex) }");
return(new BaseResponse(false, "Ocorreu um problema ao autenticar o usuário!", HttpStatusCode.InternalServerError, ex.InnerException.ToString()));
}
}
public async Task <Airport> GetAirportAsync(string iata)
{
ValidationResultHelper.ProcessIETAValidationResult(_iataValidator.Validate(iata));
HttpResponseMessage result = await _appConfig.CTeleportAPI
.AllowAnyHttpStatus()
.AppendPathSegment(iata)
.GetAsync();
string response = result.Content.ReadAsStringAsync().Result;
if (!result.IsSuccessStatusCode)
{
throw new IETAValidationException(response, (Nancy.HttpStatusCode)result.StatusCode);
}
Airport airport = JsonConvert.DeserializeObject <Airport>(response);
ValidationResultHelper.ProcessAirportValidationResult(_validator.Validate(airport));
return(airport);
}
public override ValidationRuleResult Validate(T instance)
{
var monthlyOrders = _orderRepository.GetOrdersForCustomerForMonth(CustomerId(instance), OrderDateTime(instance)).ToList();
if (ValidatingRequestAction != null)
{
Validating(monthlyOrders);
}
var monthlyTotal = monthlyOrders.Sum(s => s.SubTotal);
if (!FreeShipping(instance) || (FreeShipping(instance) && monthlyTotal >= (decimal)100.00))
{
return(ValidationRuleResult.ValidationPassedResult());
}
ValidIf(o => FreeShipping(instance) && monthlyTotal >= (decimal)100.00);
return(new ValidationRuleResult
{
IsValid = false,
ValidationResults = ValidationResultHelper.NewResult("Free shipping not valid.")
});
}
public async Task <BaseResponse> Handle(FinishRentCommandRequest request, CancellationToken cancellationToken)
{
_logger.LogInformation($"[Begin] - Finishing rent : { JsonSerializer.Serialize(request) }");
try
{
var validationResult = request.Validate();
if (!validationResult.IsValid)
{
var validationResultErrors = ValidationResultHelper.GetValidationResultErrors(validationResult);
_logger.LogInformation($"[Error] - Request not valid: { validationResultErrors }");
return(new BaseResponse(false, "Ocorreu um problema ao encerrar o empréstimo!", HttpStatusCode.BadRequest, validationResultErrors));
}
if (!await _rentService.CheckIfRentExists(request.Id))
{
_logger.LogInformation($"[Error] - Request not valid: { request }");
return(new BaseResponse(false, "Empréstimo não existe na base de dados!", HttpStatusCode.NotFound, request));
}
await _repository.Finish(request.Id);
_logger.LogInformation($"[End] - Rent successfully finished: { JsonSerializer.Serialize(request) }");
return(new BaseResponse(true, "Empréstimo encerrado com sucesso!", HttpStatusCode.OK));
}
catch (Exception ex)
{
_logger.LogInformation($"[Error] - An error occurred while finishing the rent: { JsonSerializer.Serialize(ex) }");
return(new BaseResponse(false, "Ocorreu um problema ao encerrar o empréstimo!", HttpStatusCode.InternalServerError, ex.InnerException.ToString()));
}
}
public async Task <BaseResponse> Handle(DeleteGameCommandRequest request, CancellationToken cancellationToken)
{
_logger.LogInformation($"[Begin] - Deleting game : { JsonSerializer.Serialize(request) }");
try
{
var validationResult = request.Validate();
if (!validationResult.IsValid)
{
var validationResultErrors = ValidationResultHelper.GetValidationResultErrors(validationResult);
_logger.LogInformation($"[Error] - Request not valid: { validationResultErrors }");
return(new BaseResponse(false, "Ocorreu um problema ao deletar o jogo!", HttpStatusCode.BadRequest, validationResultErrors));
}
if (await _gameService.CheckIfGameExists(request.Id))
{
_logger.LogInformation($"[Error] - Request not valid: { request }");
return(new BaseResponse(false, "Jogo não existe na base de dados!", HttpStatusCode.NotFound, request));
}
await _repository.Delete(request.Id);
_logger.LogInformation($"[End] - Game successfully deleted: { JsonSerializer.Serialize(request) }");
return(new BaseResponse(true, "Jogo deletado com sucesso!", HttpStatusCode.OK));
}
catch (Exception ex)
{
_logger.LogInformation($"[Error] - An error occurred while deleting the game: { JsonSerializer.Serialize(ex) }");
return(new BaseResponse(false, "Ocorreu um problema ao deletar o jogo!", HttpStatusCode.InternalServerError, ex.InnerException.ToString()));
}
}
public NumberValidator(ValidationResultHelper <TModel> helper, IModelProperty <int?> property)
{
_helper = helper;
_property = property;
}
public IEnumerable <ValidationResult> Validate(ValidationContext validationContext)
{
if (DayId != 0)
{
Days[0] = DayId;
}
IValidationResultHelper <ClassScheduleModel> helper = new ValidationResultHelper <ClassScheduleModel>(this);
helper.Validate(model => model.TimeStart).Required(true).ErrorMsg("Time Start field is required");
helper.Validate(model => model.TimeEnd).Required(true).ErrorMsg("Time End field is required")
.IF(TimeStart >= TimeEnd).ErrorMsg("Time End field must be greater than Time Start");
helper.Validate(model => model.DayId).Required(true).IF(Days == null || Days.Length <= 0 || (Days.Length == 1 && Days[0] == null)).ErrorMsg("Status field is required");
helper.Validate(model => model.RoomId).Required(true).GreaterThan(0).ErrorMsg("Room field is required");
helper.Validate(model => model.SectionId).Required(true).GreaterThan(0).ErrorMsg("Section field is required");
helper.Validate(model => model.SubjectId).Required(true).GreaterThan(0).ErrorMsg("Subject field is required");
helper.Validate(model => model.InstructorId).Required(true).GreaterThan(0).ErrorMsg("Instructor field is required");
helper.Validate(model => model.Capacity).Required(true).GreaterThan(0).ErrorMsg("Capacity field is required and must be greater than to 0(Zero)");
if (!helper.Failed)
{
Transaction.Scope(scope =>
{
foreach (DayOfWeek day in Days)
{
helper.Validate(model => model.RoomId).IF(!scope.Service <RoomValidatorService, bool>(service => service.CheckRoomAvailavility(
Id, RoomId, (DateTime)TimeStart, (DateTime)TimeEnd, day)))
.ErrorMsg(string.Format("Room is not available, between {0} to {1}",
((DateTime)TimeStart).ToShortTimeString(),
((DateTime)TimeEnd).ToShortTimeString())
);
helper.Validate(model => model.SectionId).IF(!scope.Service <SectionValidatorService, bool>(service => service.CheckSectionAvailability(
Id, SectionId, (DateTime)TimeStart, (DateTime)TimeEnd, day)))
.ErrorMsg(string.Format("Section is not available, between {0} to {1}",
((DateTime)TimeStart).ToShortTimeString(),
((DateTime)TimeEnd).ToShortTimeString())
);
helper.Validate(model => model.InstructorId).IF(!scope.Service <InstructorValidatorService, bool>(service => service.CheckInstructorAvailability(
Id, InstructorId, (DateTime)TimeStart, (DateTime)TimeEnd, day)))
.ErrorMsg(string.Format("Instructor is not available, between {0} to {1}",
((DateTime)TimeStart).ToShortTimeString(),
((DateTime)TimeEnd).ToShortTimeString())
);
if (helper.Failed)
{
break;
}
}
});
}
if (helper.Failed)
{
foreach (var error in helper.Errors)
{
yield return(error);
}
}
}
public TypeValidator(ValidationResultHelper <TModel> helper, IModelProperty <T> property)
{
_helper = helper;
_property = property;
}
public ConditionValidator(ValidationResultHelper helper)
{
_helper = helper;
}
