public virtual async Task <T> Add(T entity) { if (_validator == null) { throw new ArgumentException($"Não foi informado o validador da classe {nameof(entity)}"); } var validated = await _validator.ValidateAsync(entity, strategy => { strategy.IncludeRuleSets("new"); }); entity.ValidationResult = validated; if (!validated.IsValid) { return(entity); } _uow.BeginTransaction(); var entityTemp = await _sqlServerRepository.Create(entity); _uow.Commit(); await _redisRepository.Set(entityTemp); return(entityTemp); }
public async Task <IEnumerable <AttemptDto> > GetTestResultsForStudentAsync(UserDto student, string topicId) { await _userValidator.ValidateAsync(student); return(_attemptService.GetEntitiesByPrincipalId(student.Id) .Where(a => a.TopicId.Equals(topicId)).ToEnumerable()); }
public async Task CreateEntityAsync(AnswerDto model) { await _validator.ValidateAsync(model); await _context.Answers.AddAsync(model.AdaptToAnswer()); await _context.SaveChangesAsync(); }
public async Task CreateAsync(ProductDto productDto) { await _validator.ValidateAsync(productDto); await _dbContext.Products.AddAsync(_mapper.Map <Product>(productDto)); await _dbContext.SaveChangesAsync(); }
public async Task CreateEntityAsync(TopicDto model) { await _validator.ValidateAsync(model); await _context.Topics.AddAsync(model.AdaptToTopic()); await _context.SaveChangesAsync(); }
public async Task CreateEntityAsync(QuestionDto model) { await _validator.ValidateAsync(model); await _context.Questions.AddAsync(model.AdaptToQuestion()); await _context.SaveChangesAsync(); }
public async Task CreateEntityAsync(AttemptDto model) { await _validator.ValidateAsync(model); await _context.Attempts.AddAsync(model.AdaptToAttempt()); await _context.SaveChangesAsync(); }
public async Task AddAsync(ProductDto model) { await _validator.ValidateAsync(model); await _dbContext.Products.AddAsync(_mapper.Map <Product>(model)); await _dbContext.SaveChangesAsync(); }
public async Task CreateEntityAsync(SubjectDto model) { await _validator.ValidateAsync(model); await _context.Subjects.AddAsync(model.AdaptToSubject()); await _context.SaveChangesAsync(); }
public async Task AddAsync(CategoryDto model) { await _validator.ValidateAsync(model); await _dbContext.Categories.AddAsync(_mapper.Map <Category>(model)); await _dbContext.SaveChangesAsync(); }
public async Task CreateAsync(CartDto cartDto) { await _validator.ValidateAsync(cartDto); await _dbContext.Carts.AddAsync(_mapper.Map <Cart>(cartDto)); await _dbContext.SaveChangesAsync(); }
public async Task Should_fail_when_players_max_quantity_argument_is_less_than_or_equal_to_zero(int playersMaxQuantity) { using (var cts = new CancellationTokenSource()) { //Act var result = await _sut.ValidateAsync(new GetLeaderboardsRequest { PlayersMaxQuantity = playersMaxQuantity }, cts.Token); //Assert Assert.NotNull(result); Assert.False(result.IsValid); Assert.NotNull(result.Errors); Assert.True(result.Errors.Any()); } }
public async Task <ValidationResult> ValidateTextAnalysisInputAsync(TextAnalysisInput textAnalysisInput) { // Null objects are not handled by Fluent Validation so it has to be handled first if (textAnalysisInput == null) { return(new ValidationResult("VE_TextAnalysisInput_NotNull_001", "TextAnalysisInput should NOT be NULL")); } if (textAnalysisInput.Text == null) { return(new ValidationResult("VE_TextAnalysisInput_Text_NotNull_001", "Text should NOT be NULL")); } if (textAnalysisInput.Subtext == null) { return(new ValidationResult("VE_TextAnalysisInput_Subtext_NotNull_001", "Subtext should NOT be NULL")); } // Fluent Validation var fluentValidationResult = await _textAnalysisInputValidator.ValidateAsync(textAnalysisInput); // Mapping through extension methods var validationResult = fluentValidationResult.MapToValidationResultModel(); return(validationResult); }
public async Task <IBusinessResultValue <QuantityCondition> > AddOrUpdateQuantityConditionAsync(QuantityCondition entity) { var result = new BusinessResultValue <QuantityCondition>(); try { var validatorResult = await validator.ValidateAsync(entity); if (validatorResult.IsValid == false) { result.PopulateValidationErrors(validatorResult.Errors); result.ReturnStatus = false; return(result); } unitOfWork.QuantityConditionDataService.InsertOrUpdate(entity); await unitOfWork.CommitAsync(); result.ResultValue = entity; result.ReturnStatus = true; result.ReturnMessage.Add("ثبت اطلاعات با موفقیت انجام گردید"); } catch (DbEntityValidationException ex) { result.PopulateValidationErrors(ex); result.ReturnStatus = false; Logger.Error(ex, ""); } catch (Exception ex) { CatchException(ex, result, ""); } return(result); }
public async Task <IBusinessResult> SaveAsync(List <FulfillmentPromotionCondition> lstGeneralGoal) { var result = new BusinessResult(); try { lstGeneralGoal = lstGeneralGoal.Where(x => x.ManagerPromotion.HasValue || x.TotalSalesFulfilledPercent.HasValue || x.PrivateReceiptFulfilledPercent.HasValue || x.SellerPromotion.HasValue || x.TotalReceiptFulfilledPercent.HasValue).ToList(); var validatorResult = await validator.ValidateAsync(lstGeneralGoal); if (validatorResult.IsValid == false) { result.PopulateValidationErrors(validatorResult.Errors); return(result); } var totalFulfillEnity = lstGeneralGoal.FirstOrDefault(); lstGeneralGoal.ForEach(x => unitOfWork.TotalFulfillPromotionPercentDataService.InsertOrUpdate(x)); await unitOfWork.CommitAsync(); result.ReturnMessage.Add(MESSAGE_ADD_ENTITY); } catch (Exception ex) { CatchException(ex, result, ""); } return(result); }
public async Task <ActionResult <PlayerResource> > CreatePlayer([FromBody] SavePlayerResource savePlayerResource) { var validationResult = await _validator.ValidateAsync(savePlayerResource); if (!validationResult.IsValid) { return(BadRequest(validationResult.Errors)); } var playerToCreate = _mapper.Map <SavePlayerResource, Player>(savePlayerResource); var newPlayer = await _playerService.CreatePlayer(playerToCreate); var playerResource = _mapper.Map <Player, PlayerResource>(newPlayer); return(Ok(playerResource)); }
protected virtual async Task ValidateProductsAsync(CatalogProduct[] products) { if (products == null) { throw new ArgumentNullException(nameof(products)); } //Validate products var validator = new ProductValidator(); foreach (var product in products) { validator.ValidateAndThrow(product); } await LoadDependenciesAsync(products); ApplyInheritanceRules(products); var targets = products.OfType <IHasProperties>(); foreach (var item in targets) { var validationResult = await _hasPropertyValidator.ValidateAsync(item); if (!validationResult.IsValid) { throw new ValidationException($"Product properties has validation error: {string.Join(Environment.NewLine, validationResult.Errors.Select(x => x.ToString()))}"); } } }
public async Task <ActionResult <PatientResource> > CreatePatient([FromBody] SavePatientResource savePatientResource) { var validationResult = await _validator.ValidateAsync(savePatientResource); if (!validationResult.IsValid) { return(BadRequest(validationResult.Errors)); } var patientToCreate = _mapper.Map <SavePatientResource, Patient>(savePatientResource); var newPatient = await _patientService.CreatePatient(patientToCreate); var patientResource = _mapper.Map <Patient, PatientResource>(newPatient); return(Ok(patientResource)); }
public virtual async Task <IBusinessResult> UpdateAsync(TEntity entity) { var result = new BusinessResult(); try { if (validator != null) { ValidationResult results = await validator.ValidateAsync(entity); bool validationSucceeded = results.IsValid; IList <ValidationFailure> failures = results.Errors; if (validationSucceeded == false) { result.PopulateValidationErrors(failures); return(result); } } dataRepository.Update(entity); await unitOfWork.CommitAsync(); result.ReturnStatus = true; result.ReturnMessage.Add(".ویرایش اطلاعات با موفقیت انجام شد"); } catch (Exception ex) { CatchException(ex, result, ""); } return(result); }
public virtual async Task <IBusinessResultValue <TEntity> > CreateAsync(TEntity entity) { var result = new BusinessResultValue <TEntity>(); try { if (validator != null) { ValidationResult results = await validator.ValidateAsync(entity); if (results.IsValid == false) { result.PopulateValidationErrors(results.Errors); return(await Task <TEntity> .Run(() => result)); } } dataRepository.Insert(entity); await unitOfWork.CommitAsync(); result.ReturnStatus = true; result.ResultValue = entity; result.ReturnMessage.Add(MESSAGE_ADD_ENTITY); } catch (Exception ex) { CatchException(ex, result, ""); } return(result); }
public async Task <ActionResult <ArtistResource> > CreateArtist([FromBody] SaveArtistResource saveArtistResource) { var validationResult = await _validator.ValidateAsync(saveArtistResource); if (!validationResult.IsValid) { return(BadRequest(validationResult.Errors)); } var artistToCreate = _mapper.Map <SaveArtistResource, Artist>(saveArtistResource); var newArtist = await _artistService.CreateArtist(artistToCreate); var artistResource = _mapper.Map <Artist, ArtistResource>(newArtist); return(Ok(artistResource)); }
public async Task <ValidationResult> ValidateAsync(TModel instance, CancellationToken cancellation = new CancellationToken()) { var context = new ValidationContext <TModel>(instance, new PropertyChain(), ValidatorOptions.ValidatorSelectors.DefaultValidatorSelectorFactory()); await SetupContextAsync(context); return(await _validator.ValidateAsync(context, cancellation)); }
public async Task SubmitTestAsync(TestModel test) { await _testValidator.ValidateAsync(test); test.DateTimePassed = DateTime.Now; var score = 0; List <QuestionResultDto> results = new(); foreach (var question in test.Questions) { var all = true; foreach (var answer in question.Answers) { if (answer.IsCorrect.Equals((await _answerService.GetByIdAsync(answer.Id)).IsCorrect)) { continue; } all = false; break; } QuestionResultDto result = new() { Id = Guid.NewGuid().ToString(), QuestionId = question.Id, Result = false }; if (all) { result.Result = true; score++; } results.Add(result); } test.Score = score; AttemptDto attemptDto = new() { Id = Guid.NewGuid().ToString(), StudentId = test.Student.Id, TopicId = test.Topic.Id, Score = test.Score, DateTime = test.DateTimePassed }; results.ForEach(qr => qr.AttemptId = attemptDto.Id); await _attemptService.CreateEntityAsync(attemptDto); results.ForEach(async qr => await _questionResultService.CreateEntityAsync(qr)); } } }
public static async Task ValidateConvertAndThrowAsync <T>(this AbstractValidator <T> validator, T entity, CancellationToken cancellationToken) { var result = await validator.ValidateAsync(entity, cancellationToken); if (!result.IsValid) { throw new Contracts.Common.Validators.ValidationException("Invalid filter", result.Convert()); } }
public async Task <AirplaneTypeDto> AddEntityAsync(AirplaneTypeDto entity) { var validationResult = await _validator.ValidateAsync(entity); if (!validationResult.IsValid) { throw new BadRequestException(); } var mapedEntity = _mapper.Map <AirplaneTypeDto, AirplaneType>(entity); await _repository.AddEntityAsync(mapedEntity); if (!_repository.SaveAsync().Result) { throw new Exception("Adding AirplaneType failed on save."); } return(_mapper.Map <AirplaneType, AirplaneTypeDto>(mapedEntity)); }
public virtual async Task <TDto> AddEntityAsync(TDto entity) { var validationResult = await _validator.ValidateAsync(entity); if (!validationResult.IsValid) { throw new BadRequestException(); } var mapedEntity = _mapper.Map <TDto, TEntity>(entity); await _repository.AddEntityAsync(mapedEntity); if (!_repository.SaveAsync().Result) { throw new Exception("Adding EntityType failed on save."); } return(_mapper.Map <TEntity, TDto>(mapedEntity)); }
public async Task <StewardessDto> AddEntityAsync(StewardessDto entity) { var validationResult = await _validator.ValidateAsync(entity); if (!validationResult.IsValid) { throw new BadRequestException(); } var mapedEntity = _mapper.Map <StewardessDto, Stewardess>(entity); await _repository.AddEntityAsync(mapedEntity); if (!_repository.SaveAsync().Result) { throw new Exception("Adding Stewardess failed on save."); } return(_mapper.Map <Stewardess, StewardessDto>(mapedEntity)); }
public virtual async Task <TViewModel> CreateEntityAsync(TModel model) { var validationResult = await _validator.ValidateAsync(model); if (!validationResult.IsValid) { throw new ConflictRequestException(validationResult.Errors.ToAggregateResult()); } var album = _mapper.Map <TDomainModel>(model); var result = await _repository.CreateEntityAsync(album); if (result != null) { return(_mapper.Map <TViewModel>(result)); } throw new BadResultException("An entity has not been created"); }
public async Task <object> AddAsync(TDto dto) { if (dto == null) { throw new NullBodyException(); } var model = _mapper.Map <TDto, TEntity>(dto); var validationResult = await _validator.ValidateAsync(model); if (validationResult.IsValid) { return(await _repository.CreateAsync(model)); } else { throw new ValidationException(validationResult.Errors); } }
/// <summary> /// Validate this command. /// </summary> /// <typeparam name="T">Model type to validate.</typeparam> /// <param name="validator">Validator implementation.</param> /// <param name="model">Model to validate.</param> /// <returns>Validation result.</returns> public static async Task <ValidationResult> ValidateCommandAsync <T>(AbstractValidator <T> validator, T model) { ValidationResult result = await validator.ValidateAsync(model); if (result.Errors.Where(e => e.Severity == Severity.Error).Any()) { throw new ValidationException(result.Errors); } return(result); }