protected override void ValidateFields(List <IFieldValidationResult> validationResults)
{
if (ProductRepository == null)
{
return;
}
if (ProductRepository.Product != null)
{
if (ProductRepository.Product.Name == null)
{
validationResults.Add(FieldValidationResult.CreateError("ProductRepository.Product", "Требуется выбрать продукт!"));
}
if (ProductRepository.ProductCount < 1)
{
validationResults.Add(FieldValidationResult.CreateError("ProductRepository.ProductCount", "Количество товара не может быть меньше 1!"));
}
if (ProductRepository.Product.Id != 0)
{
if (Products.Single((p) => p.Id == ProductRepository.Product.Id).Count < ProductRepository.ProductCount)
{
validationResults.Add(FieldValidationResult.CreateError("ProductRepository.ProductCount", "У нас нет такого количества товара!"));
}
}
}
else
{
validationResults.Add(FieldValidationResult.CreateError("ProductRepository.Product", "Требуется выбрать продукт!"));
}
}
protected override void ValidateFields(List <IFieldValidationResult> validationResults)
{
if (string.IsNullOrEmpty(Title))
{
validationResults.Add(FieldValidationResult.CreateError(TitleProperty, "Неверный формат ввода услуги!"));
}
}
public override FieldValidationResult ValidateData(object value, Field field)
{
var stringValue = (string)value;
//-- compulsory
if (String.IsNullOrEmpty(stringValue) && (this.Compulsory ?? false))
{
return(new FieldValidationResult(CompulsoryName));
}
stringValue = stringValue ?? "";
//-- minLength
int minLength = this.MinLength.HasValue ? this.MinLength.Value : 0;
if (stringValue.Length < minLength)
{
var result = new FieldValidationResult(MinLengthName);
result.AddParameter(MinLengthName, minLength);
return(result);
}
//-- maxLength
int maxLength = this.MaxLength.HasValue ? this.MaxLength.Value : Int32.MaxValue;
if (stringValue.Length > maxLength)
{
var result = new FieldValidationResult(MaxLengthName);
result.AddParameter(MaxLengthName, maxLength);
return(result);
}
return(FieldValidationResult.Successful);
}
public void ReturnsChangesForAddedFieldWarning()
{
var fieldValidationResults1 = new List <IFieldValidationResult>();
fieldValidationResults1.Add(FieldValidationResult.CreateError("MyProperty", "FieldError"));
var businessRuleValidationResults1 = new List <IBusinessRuleValidationResult>();
businessRuleValidationResults1.Add(BusinessRuleValidationResult.CreateWarning("BusinessRuleWarning"));
businessRuleValidationResults1.Add(BusinessRuleValidationResult.CreateError("BusinessRuleError"));
var context1 = new ValidationContext(fieldValidationResults1, businessRuleValidationResults1);
var fieldValidationResults2 = new List <IFieldValidationResult>();
fieldValidationResults2.Add(FieldValidationResult.CreateWarning("MyProperty", "FieldWarning"));
fieldValidationResults2.Add(FieldValidationResult.CreateError("MyProperty", "FieldError"));
var businessRuleValidationResults2 = new List <IBusinessRuleValidationResult>();
businessRuleValidationResults2.Add(BusinessRuleValidationResult.CreateWarning("BusinessRuleWarning"));
businessRuleValidationResults2.Add(BusinessRuleValidationResult.CreateError("BusinessRuleError"));
var context2 = new ValidationContext(fieldValidationResults2, businessRuleValidationResults2);
var changes = ValidationContextHelper.GetChanges(context1, context2);
Assert.AreEqual(1, changes.Count);
Assert.AreEqual("MyProperty", ((IFieldValidationResult)changes[0].ValidationResult).PropertyName);
Assert.AreEqual("FieldWarning", changes[0].ValidationResult.Message);
Assert.AreEqual(ValidationResultType.Warning, changes[0].ValidationResult.ValidationResultType);
Assert.AreEqual(ValidationContextChangeType.Added, changes[0].ChangeType);
}
private async Task OnEditSnapshotExecuteAsync(ISnapshot snapshot)
{
var modelValidation = snapshot as IValidatable;
void OnSnapshotValidating(object sender, ValidationEventArgs e)
{
if (_snapshotManager.Snapshots.Any(x => x.Title.EqualsIgnoreCase(snapshot.Title) && x != snapshot))
{
e.ValidationContext.Add(FieldValidationResult.CreateError("Title", _languageService.GetString("Snapshots_SnapshotWithCurrentTitleAlreadyExists")));
}
}
if (modelValidation is not null)
{
modelValidation.Validating += OnSnapshotValidating;
}
if (await _uiVisualizerService.ShowDialogAsync <SnapshotViewModel>(snapshot) ?? false)
{
if (modelValidation is not null)
{
modelValidation.Validating -= OnSnapshotValidating;
}
await _snapshotManager.SaveAsync();
}
}
private FieldValidationResult ValidatePaths(List <Node> list, Field field)
{
//-- Paths
if (this.SelectionRoots.Count > 0)
{
//-- Convert relative paths to absolute
var paths = new List <string>(); //-- test equality
var roots = new List <string>(); //-- ends with PathSeparator
foreach (string item in this.SelectionRoots)
{
var handler = field.Content.ContentHandler;
var handlerPath = RepositoryPath.Combine(RepositoryPath.GetParentPath(handler.Path), handler.Name);
var path = "/";
if (item.StartsWith("/"))
{
path = item;
}
else if (item == ".")
{
path = handlerPath;
}
else
{
path = RepositoryPath.Combine(handlerPath, item);
}
if (path.EndsWith(RepositoryPath.PathSeparator))
{
paths.Add(path.Substring(0, path.Length - 1));
roots.Add(path);
}
else
{
paths.Add(path);
roots.Add(String.Concat(path, RepositoryPath.PathSeparator));
}
}
foreach (Node node in list)
{
var ok = false;
for (int i = 0; i < paths.Count; i++)
{
if (node.Path == paths[i] || node.Path.StartsWith(roots[i]))
{
ok = true;
break;
}
}
if (ok)
{
continue;
}
var result = new FieldValidationResult(SelectionRootName);
result.AddParameter(SelectionRootName, node.Path);
return(result);
}
}
return(FieldValidationResult.Successful);
}
public void Validate_WhenFieldProviderDoesNotExistWithLaCode_ShouldReturnCorrectValidationResult()
{
// Arrange
IList <ProviderSummary> providerSummaries = CreateProviderSummaries().Values.ToList();
var providerExistsValidator = new ProviderExistsValidator(providerSummaries);
FieldDefinition definition = new FieldDefinition
{
Name = "LACode",
Description = "The LaCode identifier for the provider",
Id = "12345",
IdentifierFieldType = IdentifierFieldType.LACode,
MatchExpression = null,
Maximum = null,
Minimum = null,
Required = false,
Type = FieldType.String
};
Field field = new Field(new DatasetUploadCellReference(0, 2), "12345888", definition);
// Act
FieldValidationResult result = providerExistsValidator.ValidateField(field);
// Assert
result.FieldValidated
.Should().Be(field);
result.ReasonOfFailure
.Should().Be(FieldValidationResult.ReasonForFailure.ProviderIdMismatchWithServiceProvider);
}
protected override void ValidateFields(List <IFieldValidationResult> validationResults)
{
if (string.IsNullOrWhiteSpace(Name))
{
validationResults.Add(FieldValidationResult.CreateError(nameof(Name), "Name of room is required"));
}
}
/// <summary>
/// Validates the field values of this object. Override this method to enable
/// validation of field values.
/// </summary>
/// <param name="validationResults">The validation results, add additional results to this list.</param>
protected override void ValidateFields(List <IFieldValidationResult> validationResults)
{
if (string.IsNullOrEmpty(Name))
{
validationResults.Add(FieldValidationResult.CreateError(NameProperty, "Name is required"));
}
}
public void ValidateField_WhenFieldValueDoesConformToExpectedType_ShouldReturnNull()
{
// Arrange
DatatypeMismatchFieldValidator validatorUnderTest = new DatatypeMismatchFieldValidator();
FieldDefinition fieldDefinition = new FieldDefinition()
{
Description = "The name of the provider",
Id = "1100004",
IdentifierFieldType = null,
MatchExpression = null,
Maximum = null,
Minimum = null,
Name = "Provider Name",
Required = false,
Type = FieldType.String
};
const int anyRow = 1;
const int anyColumn = 1;
// Act
FieldValidationResult result =
validatorUnderTest
.ValidateField(new Field(new DatasetUploadCellReference(anyRow, anyColumn), "Correct value type", fieldDefinition));
// Assert
result
.Should().BeNull();
}
protected override void ValidateFields(ClassWithValidator instance, List <IFieldValidationResult> validationResults)
{
ValidateFieldsCount++;
validationResults.Add(FieldValidationResult.CreateWarning(ClassWithValidator.WarningPropertyProperty, "Warning"));
validationResults.Add(FieldValidationResult.CreateError(ClassWithValidator.ErrorPropertyProperty, "Error"));
}
protected override void ValidateFields(List <IFieldValidationResult> validationResults)
{
if (string.IsNullOrWhiteSpace(FamilyName))
{
validationResults.Add(FieldValidationResult.CreateError(FamilyNameProperty, "The family name is required"));
}
}
/// <summary>
/// Validates the field values of this object. Override this method to enable
/// validation of field values.
/// </summary>
/// <param name="validationResults">The validation results, add additional results to this list.</param>
protected override void ValidateFields(List <IFieldValidationResult> validationResults)
{
if (Shop == null)
{
validationResults.Add(FieldValidationResult.CreateError(ShopProperty, "Shop is required"));
}
}
protected override void OnValidating(IValidationContext validationContext)
{
if (string.IsNullOrWhiteSpace(Name))
{
validationContext.Add(FieldValidationResult.CreateError(nameof(Name), "'Name' for the LogFilterGroup is required"));
}
}
public void ValidateField_WhenGivenFieldIsLessThanMinimum_ShouldReturnCorrectResult()
{
// Arrange
DatasetUploadCellReference anyCellReference = new DatasetUploadCellReference(1, 1);
MaxAndMinFieldValidator maxAndMinFieldValidator = new MaxAndMinFieldValidator();
FieldDefinition fieldDefinition = new FieldDefinition
{
Description = "Count of high needs students aged 16-19 from the ILR R04 collection",
Id = "1100013",
IdentifierFieldType = null,
MatchExpression = null,
Maximum = 10000,
Minimum = 9000,
Name = "Number of students",
Required = false,
Type = FieldType.Integer
};
Field field = new Field(anyCellReference, 8999, fieldDefinition);
// Act
FieldValidationResult result = maxAndMinFieldValidator.ValidateField(field);
// Assert
result.FieldValidated.CellReference.Should().Be(anyCellReference);
result.ReasonOfFailure.Should().Be(FieldValidationResult.ReasonForFailure.MaxOrMinValueExceeded);
}
public void ValidateField_GivenProviderIdentifierIsNotBlank_ShouldReturnCorrectResult()
{
// Arrange
ProviderIdentifierBlankValidator validatorUnderTest = new ProviderIdentifierBlankValidator();
DatasetUploadCellReference anyCellReference = new DatasetUploadCellReference(0, 2);
FieldDefinition definition = new FieldDefinition
{
Name = "UPIN",
Description = "The UPIN identifier for the provider",
Id = "1100003",
IdentifierFieldType = IdentifierFieldType.UPIN,
MatchExpression = null,
Maximum = null,
Minimum = null,
Required = false,
Type = FieldType.String
};
Field field = new Field(anyCellReference, "107013", definition);
// Act
FieldValidationResult result = validatorUnderTest.ValidateField(field);
// Assert
result.Should().BeNull();
}
private List <Node> GetNodeList(object value, out FieldValidationResult result)
{
result = FieldValidationResult.Successful;
var list = new List <Node>();
var node = value as Node;
if (node != null)
{
list.Add(node);
return(list);
}
var enumerableNodes = value as IEnumerable <Node>;
if (enumerableNodes != null)
{
return(enumerableNodes.ToList());
}
var enumerable = value as IEnumerable;
if (enumerable != null)
{
foreach (Node item in enumerable)
{
if (item != null)
{
list.Add(item);
}
}
return(list);
}
result = new FieldValidationResult("ReferenceValue");
return(list);
}
public void ValidateField_GivenProviderIdentifierIsBlank_ShouldReturnCorrectResult()
{
// Arrange
ProviderIdentifierBlankValidator validatorUnderTest = new ProviderIdentifierBlankValidator();
FieldDefinition definition = new FieldDefinition
{
Name = "UPIN",
Description = "The UPIN identifier for the provider",
Id = "1100003",
IdentifierFieldType = IdentifierFieldType.UPIN,
MatchExpression = null,
Maximum = null,
Minimum = null,
Required = false,
Type = FieldType.String
};
Field field = new Field(AnyCellReference, string.Empty, definition);
// Act
FieldValidationResult result = validatorUnderTest.ValidateField(field);
// Assert
result.Should().NotBeNull();
result.ReasonOfFailure
.Should().Be(FieldValidationResult.ReasonForFailure.ProviderIdValueMissing);
}
public void Validate_WhenFieldProviderExists_ShouldReturnCorrectValidationResult()
{
// Arrange
IList <ProviderSummary> providerSummaries = CreateProviderSummaries().Values.ToList();
var providerExistsValidator = new ProviderExistsValidator(providerSummaries);
FieldDefinition definition = new FieldDefinition
{
Name = "UPIN",
Description = "The UPIN identifier for the provider",
Id = "1100003",
IdentifierFieldType = IdentifierFieldType.UPIN,
MatchExpression = null,
Maximum = null,
Minimum = null,
Required = false,
Type = FieldType.String
};
Field field = new Field(new DatasetUploadCellReference(0, 2), "107013", definition);
// Act
FieldValidationResult result = providerExistsValidator.ValidateField(field);
// Assert
result.Should().BeNull();
}
public void ValidateField_GivenAFieldThatIsNotAProviderIdentifier_ShouldIgnoreAndReturnCorrectResult()
{
// Arrange
const string someOtherField = "some other field";
ProviderIdentifierBlankValidator validatorUnderTest = new ProviderIdentifierBlankValidator();
FieldDefinition fieldDefinitionForSomeOtherField = new FieldDefinition
{
Description = "Some other field",
Id = "1100003",
IdentifierFieldType = null,
MatchExpression = null,
Maximum = null,
Minimum = null,
Name = someOtherField,
Required = false,
Type = FieldType.String
};
Field field = new Field(AnyCellReference, string.Empty, fieldDefinitionForSomeOtherField);
// Act
FieldValidationResult result = validatorUnderTest.ValidateField(field);
// Assert
result.Should().BeNull();
}
public void ReturnsEmptyCollectionForEqualValidationContexts()
{
var fieldValidationResults1 = new List <IFieldValidationResult>();
fieldValidationResults1.Add(FieldValidationResult.CreateWarning("MyProperty", "FieldWarning"));
fieldValidationResults1.Add(FieldValidationResult.CreateError("MyProperty", "FieldError"));
var businessRuleValidationResults1 = new List <IBusinessRuleValidationResult>();
businessRuleValidationResults1.Add(BusinessRuleValidationResult.CreateWarning("BusinessRuleWarning"));
businessRuleValidationResults1.Add(BusinessRuleValidationResult.CreateError("BusinessRuleError"));
var context1 = new ValidationContext(fieldValidationResults1, businessRuleValidationResults1);
var fieldValidationResults2 = new List <IFieldValidationResult>();
fieldValidationResults2.Add(FieldValidationResult.CreateWarning("MyProperty", "FieldWarning"));
fieldValidationResults2.Add(FieldValidationResult.CreateError("MyProperty", "FieldError"));
var businessRuleValidationResults2 = new List <IBusinessRuleValidationResult>();
businessRuleValidationResults2.Add(BusinessRuleValidationResult.CreateWarning("BusinessRuleWarning"));
businessRuleValidationResults2.Add(BusinessRuleValidationResult.CreateError("BusinessRuleError"));
var context2 = new ValidationContext(fieldValidationResults2, businessRuleValidationResults2);
var changes = ValidationContextHelper.GetChanges(context1, context2);
Assert.AreEqual(0, changes.Count);
}
public override FieldValidationResult ValidateData(object value, Field field)
{
if ((value == null) && (this.Compulsory ?? false))
{
return(new FieldValidationResult(CompulsoryName));
}
if (value != null)
{
var decimalValue = Convert.ToDecimal(value);
if (this.MinValue != null)
{
if (decimalValue < (decimal)this.MinValue)
{
var result = new FieldValidationResult(MinValueName);
result.AddParameter(MinValueName, this.MinValue);
return(result);
}
}
if (this.MaxValue != null)
{
if (decimalValue > (decimal)this.MaxValue)
{
var result = new FieldValidationResult(MaxValueName);
result.AddParameter(MaxValueName, this.MaxValue);
return(result);
}
}
}
return(FieldValidationResult.Successful);
}
/// <summary>
/// Validates the field values of this object. Override this method to enable
/// validation of field values.
/// </summary>
/// <param name="validationResults">The validation results, add additional results to this list.</param>
protected override void ValidateFields(List <IFieldValidationResult> validationResults)
{
if (string.IsNullOrWhiteSpace(ApiKey))
{
validationResults.Add(FieldValidationResult.CreateError(ApiKeyProperty, "Api key is required"));
}
}
protected override void ValidateFields(List <IFieldValidationResult> validationResults)
{
if (IsRedirect && RedirectType == null)
{
validationResults.Add(FieldValidationResult.CreateError(nameof(RedirectType),
"You need to specify a type to redirect to"));
}
if (IsIgnored && IsRedirect)
{
validationResults.Add(FieldValidationResult.CreateError(nameof(RedirectType),
"You cannot ignore and redirect a type at the same time"));
}
if (_typesService.HasType(Type))
{
validationResults.Add(FieldValidationResult.CreateError(nameof(TypeName),
"Another type with the same name already exists"));
validationResults.Add(FieldValidationResult.CreateError(nameof(SubTypeName),
"Another type with the same name already exists"));
}
base.ValidateFields(validationResults);
}
public override FieldValidationResult ValidateData(object value, Field field)
{
if ((value == null) && (this.Compulsory ?? false))
{
return(new FieldValidationResult(CompulsoryName));
}
if (value != null)
{
if (_slotMinValue == 0)
{
this.Initialize();
}
var intValue = (int)value;
var min = this.MinValue ?? _slotMinValue;
var max = this.MaxValue ?? _slotMaxValue;
if (intValue < min)
{
var result = new FieldValidationResult(MinValueName);
result.AddParameter(MinValueName, min);
return(result);
}
if (intValue > max)
{
var result = new FieldValidationResult(MaxValueName);
result.AddParameter(MaxValueName, max);
return(result);
}
}
return(FieldValidationResult.Successful);
}
protected override void ValidateFields(List <IFieldValidationResult> validationResults)
{
if (SelectedAddress == null)
{
validationResults.Add(FieldValidationResult.CreateError(SelectedAddressProperty, "Не указан адрес!"));
}
if (SelectedService == null)
{
validationResults.Add(FieldValidationResult.CreateError(SelectedServiceProperty, "Не указана услуга!"));
}
if (SelectedRate == null)
{
validationResults.Add(FieldValidationResult.CreateError(SelectedRateProperty, "Не указан тариф!"));
}
int output1;
if (!Int32.TryParse(PrevIndication, out output1))
{
validationResults.Add(FieldValidationResult.CreateError(PrevIndicationProperty, "Неверный формат ввода пред. показания!"));
}
int output2;
if (!Int32.TryParse(CurIndication, out output2))
{
validationResults.Add(FieldValidationResult.CreateError(CurIndicationProperty, "Неверный формат ввода текущ. показания!"));
}
}
/// <summary>
/// Validates the field values of this object. Override this method to enable
/// validation of field values.
/// </summary>
/// <param name="validationResults">The validation results, add additional results to this list.</param>
protected override void ValidateFields(List <IFieldValidationResult> validationResults)
{
if (!string.IsNullOrEmpty(CustomError))
{
validationResults.Add(FieldValidationResult.CreateError(CustomErrorProperty, CustomError));
}
}
public void ValidateField_WhenGivenDecimalFieldIsMin_ShouldReturnCorrectResult()
{
// Arrange
DatasetUploadCellReference anyCellReference = new DatasetUploadCellReference(1, 1);
MaxAndMinFieldValidator maxAndMinFieldValidator = new MaxAndMinFieldValidator();
FieldDefinition fieldDefinition = new FieldDefinition
{
Description = "Count of high needs students aged 16-19 from the ILR R04 collection",
Id = "1100013",
IdentifierFieldType = null,
MatchExpression = null,
Maximum = 10000,
Minimum = 9000,
Name = "Number of students",
Required = false,
Type = FieldType.Integer
};
Field field = new Field(anyCellReference, 10000m, fieldDefinition);
// Act
FieldValidationResult result = maxAndMinFieldValidator.ValidateField(field);
// Assert
result.Should().BeNull();
}
protected override void ValidateFields(PropertyExpression instance, List <IFieldValidationResult> validationResults)
{
if (instance.Property is null)
{
validationResults.Add(FieldValidationResult.CreateError("Property", "Property can not be null"));
}
}
protected override void ValidateFields(List <IFieldValidationResult> validationResults)
{
if (string.IsNullOrWhiteSpace(FamilyName))
{
validationResults.Add(FieldValidationResult.CreateError(FamilyNameProperty, "Фамилия обязательна"));
}
}
