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