public async Task BodValidator_Validate_Should_Return_True_When_Bods_Has_No_Duplicate_Record()
{
await Task.Run(() =>
{
//Arrange
List <Bod> bods = _mockData.GetBods();
List <ParticipantEnergyAsset> bmuUnit = _mockData.GetBMUParticipant();
bods[0].PairId = -5;
bods[1].PairId = -4;
bods[2].PairId = -3;
bods[3].PairId = -2;
bods[4].PairId = -1;
bods[5].PairId = 1;
bods[6].PairId = 2;
bods[7].PairId = 3;
bods[8].PairId = 4;
bods[9].PairId = 5;
Aggregate <Bod> aggregate = new Aggregate <Bod>(new Item(), bods, bmuUnit, null)
{
SettlementDuration = 30,
MinPairId = -5,
MaxPairId = 5
};
BodValidator validator = new BodValidator();
//Act
FluentValidation.Results.ValidationResult result = validator.Validate(aggregate, ruleSet: BusinessValidationConstants.WARNINGCHECK);
//Assert
Assert.True(result.IsValid);
});
}
public ActionResult ChangePassword(string id, ChangePasswordViewModel model)
{
try
{
ChangePasswordViewModelFluentValidation validator = new ChangePasswordViewModelFluentValidation();
FluentValidation.Results.ValidationResult result = validator.Validate(model);
if (!result.IsValid)
{
result.Errors.ToList().ForEach(error =>
{
ModelState.AddModelError(error.PropertyName, error.ErrorMessage);
});
}
if (ModelState.IsValid)
{
return(Json(new { success = true }));
}
}
catch (Exception)
{
throw;
}
return(PartialView("_ChangePassword", model));//Json(false,JsonRequestBehavior.AllowGet); // RedirectToAction("Details", new {id = id});;////null
}
public async Task <IEnumerable <ValidationFailure> > Validate(object validatorCaller, object validatingObject)
{
var fvValidator = _factory.GetType().GetMethod("GetValidator")
.MakeGenericMethod(validatingObject.GetType()).Invoke(_factory, null);
if (fvValidator == null)
{
return(Enumerable.Empty <ValidationFailure>());
}
if (fvValidator.GetType().IsGenericType)
{
if (fvValidator.GetType() == typeof(FluentModelValidator <>).MakeGenericType(fvValidator.GetType().GenericTypeArguments))
{
fvValidator.GetType().GetProperty("ValidatorCaller").SetValue(fvValidator, validatorCaller);
}
else if (fvValidator.GetType() == typeof(FluentModelValidator <,>).MakeGenericType(fvValidator.GetType().GenericTypeArguments))
{
fvValidator.GetType().GetProperty("ValidatorCaller").SetValue(fvValidator, validatorCaller.CastToReflected(validatorCaller.GetType()));
}
}
var Validator = await fvValidator.GetType().GetMethod("ValidateAsync").InvokeAsync(fvValidator, validatingObject);
ValidationResult validationResult = (ValidationResult)Validator;
var failures = validationResult.Errors
.Select(e => new ValidationFailure(e.PropertyName, e.ErrorMessage));
return(failures);
}
public ValidationResult(FluentValidation.Results.ValidationResult validationResult)
{
Errors = validationResult.Errors.Select(x => new ValidationError()
{
AttemptedValue = x.AttemptedValue, ErrorMessage = x.ErrorMessage, PropertyName = x.PropertyName
}).ToList();
}
public void Should_Success_Validate()
{
IPWovenTypeViewModelValidator validation = new IPWovenTypeViewModelValidator();
FluentValidation.Results.ValidationResult valid = validation.Validate(ViewModel);
Assert.True(valid.IsValid);
}
private static void HandleErrors(WeatherBaseCommand command, FluentValidation.Results.ValidationResult data)
{
foreach (var item in data.Errors)
{
command.Notifications.Add(item.ErrorCode, item.ErrorMessage);
}
}
private void ConfirmButton_Click(object sender, RoutedEventArgs e)
{
OwnerModel owner = (OwnerModel)OwnerList.SelectedItem;
if (owner != null)
{
Revenue = new RevenueModel();
Revenue.Staff = PublicVariables.Staff;
Revenue.Store = PublicVariables.Store;
Revenue.Date = DateTime.Now;
Revenue.TotalMoney = (decimal)RevenueValue.Value;
GlobalConfig.RevenueValidator = new RevenueValidator();
ValidationResult result = GlobalConfig.RevenueValidator.Validate(Revenue);
if (result.IsValid == false)
{
MessageBox.Show(result.Errors[0].ErrorMessage);
}
else
{
GlobalConfig.Connection.AddRevenueToTheDatabase(Revenue, owner);
SetInitialValues();
}
}
else
{
MessageBox.Show("Select Owner Please");
}
}
public bool Update(TeamModel entity)
{
var record = Repository.Get(entity.Id);
if (record == null)
{
return(false);
}
else
{
if (entity.LeagueId != 0)
{
record.LeagueId = entity.LeagueId;
}
if (!string.IsNullOrWhiteSpace(entity.Name))
{
record.Name = entity.Name;
}
ValidationTeam validator = new ValidationTeam();
FluentValidation.Results.ValidationResult result = validator.Validate(record);
if (result.IsValid)
{
record.UpdatedAt = DateTime.Now;
Repository.Update(record);
return(true);
}
else
{
return(false);
}
}
}
private void ConfitmButton_Click(object sender, RoutedEventArgs e)
{
StaffSalaryModel staffSalary = new StaffSalaryModel();
staffSalary.Store = PublicVariables.Store;
staffSalary.Staff = PublicVariables.Staff;
staffSalary.Date = DateTime.Now;
staffSalary.Salary = PayNowValue.Value.Value;
staffSalary.Details = StaffSalaryDetailsValue.Text;
staffSalary.ToStaff = Staff;
// validation
GlobalConfig.StaffSalaryValidator = new StaffSalaryValidator();
ValidationResult result = GlobalConfig.StaffSalaryValidator.Validate(staffSalary);
if (result.IsValid == false)
{
MessageBox.Show(result.Errors[0].ErrorMessage);
}
else
{
GlobalConfig.Connection.AddStaffSalaryToTheDatabase(staffSalary);
SetInitialValues();
}
}
private static void CheckValidate(FluentValidation.Results.ValidationResult result)
{
if (!result.IsValid)
{
throw new MessageException(result.Errors.Select(a => a.PropertyName + " --> " + a.ErrorMessage + " " + a.ErrorCode).ToList());
}
}
private void ConfitmButton_Click(object sender, RoutedEventArgs e)
{
OrignalProduct.Name = ProductNameValue.Text;
OrignalProduct.QuantityType = QuantityTypeValue.Text;
OrignalProduct.Size = SizeValue.Text;
OrignalProduct.Details = DetailsValue.Text;
OrignalProduct.SalePrice = SalePriceValue.Value.Value;
OrignalProduct.IncomePrice = IncomePriceValue.Value.Value;
OrignalProduct.ExpirationPeriod = ExpirationPerid.Value.Value;
OrignalProduct.AlarmQuantity = (int)QuantityAlarmValue.Value;
CategoryModel category = (CategoryModel)CategoryValue.SelectedItem;
if (category != null)
{
OrignalProduct.Category = category;
}
BrandModel brand = (BrandModel)BrandValue.SelectedItem;
if (brand != null)
{
OrignalProduct.Brand = brand;
}
// Update the product
GlobalConfig.Connection.UpdateProductDataWithTheDatabase(OrignalProduct);
if (NewProducts.Count > 0)
{
bool confirm = true;
for (int i = 1; i <= NewProducts.Count; i++)
{
ProductModel product = NewProducts[i - 1];
GlobalConfig.ProductValidator = new ProductValidator();
ValidationResult result = GlobalConfig.ProductValidator.Validate(product);
if (result.IsValid == false)
{
MessageBox.Show("number " + i + " " + result.Errors[0].ErrorMessage);
confirm = false;
}
else
{
}
}
if (confirm)
{
foreach (ProductModel product in NewProducts)
{
GlobalConfig.Connection.AddProductToTheDatabase(product);
}
}
}
SetInitialValues();
}
/// <summary>
/// 创建或更新角色
/// </summary>
/// <param name="dto"></param>
/// <returns>成功返回角色id</returns>
public async Task <DataResult <string> > CreateOrUpdateRoleAsync(ApplicationRole role)
{
FluentValidation.Results.ValidationResult v = await applicationRoleValidator.ValidateAsync(role).ConfigureAwait(false);
if (!v.IsValid)
{
return(FailedDataResult <string>(v));
}
IdentityResult result;
if (string.IsNullOrEmpty(role.Id))
{
role.Id = GuidEx.NewGuid().ToString();
//角色Id是空则创建
result = await roleManager.CreateAsync(role).ConfigureAwait(false);
}
else
{
//更新
result = await roleManager.UpdateAsync(role).ConfigureAwait(false);
}
if (result.Succeeded)
{
return(OkDataResult(role.Id));
}
return(FailedDataResult <string>(result.Errors.FirstOrDefault().Description));
}
public static async Task <HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Function, "post", Route = null)] HttpRequestMessage req, TraceWriter log)
{
HttpResponseMessage response = req.CreateResponse(HttpStatusCode.InternalServerError, "No data was send");
log.Info("C# HTTP trigger function processed a request.");
OrderModel order;
OrderModelValidator validator = new OrderModelValidator();
log.Info("Fluent Validator is running");
try
{
if (req.Method == HttpMethod.Post)
{
order = req.Content.IsMimeMultipartContent() ? await ReadMultipartContent(req.Content) : null;
order = req.Content.IsFormData() ? await ReadFormContent(req.Content) : order;
FluentValidation.Results.ValidationResult result = validator.Validate(order);
result.IsValid.Should().BeTrue();
response = req.CreateResponse(HttpStatusCode.OK, "Object structure and data was fine");
}
}
catch (Exception ex)
{
response = req.CreateErrorResponse(HttpStatusCode.BadRequest, ex.Message, ex);
}
return(response);
}
public async Task <IActionResult> Post([FromBody] CredentialsViewModel credentials)
{
CredentialsViewModelValidator validator = new CredentialsViewModelValidator();
FluentValidation.Results.ValidationResult results = validator.Validate(credentials);
if (!results.IsValid)
{
foreach (var failure in results.Errors)
{
Errors.AddErrorToModelState(failure.PropertyName, failure.ErrorMessage, ModelState);
}
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
// Checks if Username Password combination is correct.
var identity = await GetClaimsIdentity(credentials.EmailAddress, credentials.UserPassword);
if (identity == null)
{
return(BadRequest(Errors.AddErrorToModelState("login_failure", "Onjuiste email of wachtwoord.", ModelState)));
}
// Generates Token
var jwt = await Tokens.GenerateJwt(identity, _jwtGenerator, credentials.EmailAddress, _jwtOptions, new JsonSerializerSettings { Formatting = Formatting.Indented });
return(new OkObjectResult(jwt));
}
public override ValidationResult Validate(object value, CultureInfo cultureInfo)
{
FullPathValidator validator = new FullPathValidator();
FluentValidation.Results.ValidationResult results = validator.Validate(value.ToString());
return(new ValidationResult(results.IsValid, results.Errors.Count > 0 ? results.Errors[0] : null));
}
private void ModifyButtonClicked(object sender, RoutedEventArgs e)
{
CreateCoordinatorFromInputData();
FluentValidation.Results.ValidationResult dataValidationResult = ValidateData();
ShowUserFeedback(dataValidationResult);
try
{
bool thereIsAnotherCoordinatorWithTheSameInformation =
_unitOfWork.Coordinators.CoordinatorIsAlreadyRegistered(Coordinator, true);
if (dataValidationResult.IsValid)
{
if (thereIsAnotherCoordinatorWithTheSameInformation)
{
MessageBox.Show("El correo, correo alternativo o número " +
"de teléfono ingresado ya está ocupado por otro usuario");
}
else
{
bool userConfirmedAction = AskForConfirmation();
if (userConfirmedAction)
{
ModifyCoordinator();
}
}
}
}
catch (SqlException)
{
MessageBox.Show("No hay conexión a la base de datos. Intente más tarde.");
_unitOfWork.Dispose();
GoBackToCoordinatorConsultation();
}
}
private void TopDuzenleBtn_Click(object sender, EventArgs e)
{
if (_selectedModel != null)
{
CariValidator validator = new CariValidator();
FluentValidation.Results.ValidationResult
result = validator.Validate(_selectedModel);
if (result.IsValid == false)
{
string hataBilgi = string.Empty;
foreach (var item in result.Errors)
{
hataBilgi += $"{item.ErrorCode}:{item.ErrorMessage}\n";
}
MessageBox.Show($"Güncellenecek bilgiler tutarlı değil.Aşağıdaki açıklamayı dikkate alınız\n-------------\n{hataBilgi}\n------------\n", "Veriler Doğru Biçimde Girilmedi", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
else
{
topDuzenleBtn.Enabled = false;
topDuzenleBtn.Text = "Güncellendi...";
_cari.Update(_selectedModel);
}
}
}
public ValidationTemplate(INotifyPropertyChanged target)
{
this._target = target;
_validator = GetValidator(target.GetType());
_validationResult = _validator.Validate(target);
target.PropertyChanged += Validate;
}
public async Task <Unit> Handle(Update request, CancellationToken cancellationToken)
{
var builder = new DbContextOptionsBuilder <DataContext>();
EntityFrameworkExtensions.optionsAction(builder);
using var ctx = new DataContext(builder.Options);
var validator = new UpdateValidator();
FluentValidation.Results.ValidationResult result = validator.Validate(request);
if (!result.IsValid)
{
throw new ValidationException(result.Errors);
}
ctx.Configurations.Add(new Configuration
{
Values = request.Values.ToDictionary(value => value.Name, v => v.Value),
Created = DateTime.UtcNow,
});
await ctx.SaveChangesAsync();
ConfigurationProvider.Value.Reload();
return(Unit.Value);
}
public static ValidationResult ToScimValidationResult(this FluentValidation.Results.ValidationResult result)
{
return(new ValidationResult(
result.Errors.Any()
? result.Errors.Select(e => (ScimError)e.CustomState)
: null));
}
private bool ValidateCredentials(CredentialsModel credentialsModel)
{
CredentialsModelValidator validator = new CredentialsModelValidator();
FluentValidation.Results.ValidationResult result = validator.Validate(credentialsModel);
return(result.IsValid);
}
public async Task <HttpResponseMessage> DeleteReceiveAndPay([FromBody] int id)
{
var organId = Convert.ToInt32(SecurityManager.CurrentUserContext.OrganizationId);
FinanYearRule finanYearRule = new FinanYearRule();
var finanYerar = await finanYearRule.GetCurrentFinanYear(organId);
var res = await Rule.FindAsync(id);
PayRecevieDeleteValidate validator = new PayRecevieDeleteValidate();
FluentValidation.Results.ValidationResult results = validator.Validate(res);
string failurs = "";
if (!results.IsValid)
{
foreach (var error in results.Errors)
{
failurs += "<br/>" + error.ErrorMessage;
}
return(Request.CreateResponse(HttpStatusCode.OK, new { resultCode = ZhivarEnums.ResultCode.ValidationError, data = failurs }));
}
await Rule.DeleteAsync(id);
await Rule.SaveChangesAsync();
//var res = await payRecevieRule.GetAllByOrganIdAsync(organId);
return(Request.CreateResponse(HttpStatusCode.OK, new { resultCode = (int)ZhivarEnums.ResultCode.Successful, data = res }));
}
private void ConfirmButton_Click(object sender, RoutedEventArgs e)
{
StoreModel store = (StoreModel)StoreList.SelectedItem;
if (store != null)
{
Transform = new TransformModel();
Transform.Staff = PublicVariables.Staff;
Transform.Store = PublicVariables.Store;
Transform.Date = DateTime.Now;
Transform.TotalMoney = (decimal)TransformValue.Value;
Transform.ToStore = store;
GlobalConfig.TransformValidator = new TransformValidator();
ValidationResult result = GlobalConfig.TransformValidator.Validate(Transform);
if (result.IsValid == false)
{
MessageBox.Show(result.Errors[0].ErrorMessage);
}
else
{
GlobalConfig.Connection.AddTransformToTheDatase(Transform);
SetInitialValues();
}
}
else
{
MessageBox.Show("Select Store Please");
}
}
private void KaydetBtn_Click(object sender, EventArgs e)
{
StokValidator validator = new StokValidator();
FluentValidation.Results.ValidationResult
result = validator.Validate(stokModel);
if (result.IsValid == false)
{
HataTemizle();
foreach (var item in result.Errors)
{
hataList.Items.Add($"{item.ErrorCode}:\t{item.ErrorMessage}");
}
}
else if (result.IsValid)
{
HataTemizle();
_stok.Insert(model: stokModel);
_kasa.InsertStok(stok: stokModel);
stokModel = new Stoklar();
stoklarBindingSource.AllowNew = true;
stoklarBindingSource.DataSource = stokModel;
MessageBox.Show("Stok başarıyla kaydedildi", "Kaydedildi", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
}
public void WhenClickOnCreateButton()
{
A.CallTo(() => _futureDateValidator.Valid(A <DateTime> ._)).Returns(true);
var validator = new AssessmentViewModelValidator(_futureDateValidator);
_validatorResult = validator.Validate(_assessmentModel);
}
public static IActionResult Run([HttpTrigger(AuthorizationLevel.Function, "post", Route = null)] HttpRequest req, TraceWriter log)
{
ActionResult response = new OkResult();
IrisModelValidator validator = new IrisModelValidator();
try
{
log.Info("IrisExMachina started");
string requestBody = new StreamReader(req.Body).ReadToEnd();
IrisModel requestData = JsonConvert.DeserializeObject <IrisModel>(requestBody);
FluentValidation.Results.ValidationResult result = validator.Validate(requestData);
result.IsValid.Should().BeTrue();
PEngine engine = new PEngine("iris-data.txt");
var trainedModel = engine.Train();
IrisPredictedModel predicted = trainedModel.Predict(requestData);
response = new OkObjectResult($"Predicted flower type { predicted.PredictedLabel}");
}
catch (Exception ex)
{
response = new BadRequestObjectResult(ex.Message);
log.Error(ex.Message);
}
return(response);
}
public static void ProcessIETAValidationResult(FluentValidation.Results.ValidationResult result)
{
if (!result.IsValid)
{
throw new IETAValidationException(ValidationErrorsHelper.AggregateErrorMessages(result), HttpStatusCode.BadRequest);
}
}
public bool EhValido()
{
Validar();
ValidationResult = Validate(_notaFiscal);
return(ValidationResult.IsValid);
}
/// <summary>
/// Валидация.
/// </summary>
public async void Validate([CanBeNull] string propName = null)
{
if (validator == null)
{
return;
}
await Task.Run(() =>
{
validationResult = validator.Validate(new ValidationContext <object>(this));
Errors = new List <string>(validationResult.Errors.Select(s => s.ErrorMessage).ToList());
if (propName == null)
{
if (validationResult?.Errors?.Any() == true)
{
foreach (var error in validationResult.Errors)
{
RaiseErrorsChanged(error.PropertyName);
}
}
}
else
{
RaiseErrorsChanged(propName);
}
IsValidated = true;
Logger.Debug($"Validate {this}");
});
}
public async Task BodValidator_Validate_Should_Return_True_When_PairId_LevelToAndFrom_Have_Same_Sign()
{
await Task.Run(() =>
{
//Arrange
List <Bod> bods = _mockData.GetBods();
List <ParticipantEnergyAsset> bmuUnit = _mockData.GetBMUParticipant();
bods[0].PairId = -5;
bods[0].LevelFrom = -2;
bods[0].LevelTo = -6;
bods[5].PairId = 1;
bods[5].LevelFrom = 2;
bods[5].LevelTo = 6;
Aggregate <Bod> aggregate = new Aggregate <Bod>(new Item(), bods, bmuUnit, null)
{
SettlementDuration = 30,
MinPairId = -5,
MaxPairId = 5
};
BodValidator validator = new BodValidator();
//Act
FluentValidation.Results.ValidationResult result = validator.Validate(aggregate, ruleSet: BusinessValidationConstants.WARNINGCHECK);
//Assert
Assert.True(result.IsValid);
Assert.Empty(aggregate.InValidFlow.Distinct());
});
}
