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