private void ValidateIsImage(IAssetInfo asset, ImmutableQueue <string> path, AddError addError) { if (properties.MustBeImage && asset.Type != AssetType.Image && asset.MimeType != "image/svg+xml") { addError(path, T.Get("contents.validation.image")); } }
public async Task ValidateAsync(object value, ValidationContext context, AddError addError) { var count = context.Path.Count(); if (value != null && (count == 0 || (count == 2 && context.Path.Last() == InvariantPartitioning.Instance.Master.Key))) { FilterNode filter = null; if (value is string s) { filter = new FilterComparison(Path(context), FilterOperator.Equals, new FilterValue(s)); } else if (value is double d) { filter = new FilterComparison(Path(context), FilterOperator.Equals, new FilterValue(d)); } if (filter != null) { var found = await context.GetContentIdsAsync(context.SchemaId, filter); if (found.Any(x => x != context.ContentId)) { addError(context.Path, "Another content with the same value exists."); } } } }
public Task ValidateAsync(object?value, ValidationContext context, AddError addError) { if (value is string stringValue) { if (!string.IsNullOrEmpty(stringValue)) { try { if (!regex.IsMatch(stringValue)) { if (string.IsNullOrWhiteSpace(errorMessage)) { addError(context.Path, "Does not match to the pattern."); } else { addError(context.Path, errorMessage); } } } catch { addError(context.Path, "Regex is too slow."); } } } return(Task.CompletedTask); }
private void ValidateNonImage(ImmutableQueue <string> path, AddError addError) { if (properties.MustBeImage) { addError(path, T.Get("contents.validation.image")); } }
public async Task ValidateAsync(object?value, ValidationContext context, AddError addError) { if (context.Mode == ValidationMode.Optimized) { return; } var count = context.Path.Count(); if (value != null && (count == 0 || (count == 2 && context.Path.Last() == InvariantPartitioning.Key))) { FilterNode <ClrValue>?filter = null; if (value is string s) { filter = ClrFilter.Eq(Path(context), s); } else if (value is double d) { filter = ClrFilter.Eq(Path(context), d); } if (filter != null) { var found = await checkUniqueness(filter); if (found.Any(x => x.Id != context.ContentId)) { addError(context.Path, "Another content with the same value exists."); } } } }
public Task ValidateAsync(object?value, ValidationContext context, AddError addError) { if (value is string stringValue && !string.IsNullOrEmpty(stringValue)) { if (minLength.HasValue && maxLength.HasValue) { if (minLength == maxLength && minLength != stringValue.Length) { addError(context.Path, $"Must have exactly {maxLength} character(s)."); } else if (stringValue.Length < minLength || stringValue.Length > maxLength) { addError(context.Path, $"Must have between {minLength} and {maxLength} character(s)."); } } else { if (minLength.HasValue && stringValue.Length < minLength.Value) { addError(context.Path, $"Must have at least {minLength} character(s)."); } if (maxLength.HasValue && stringValue.Length > maxLength.Value) { addError(context.Path, $"Must not have more than {maxLength} character(s)."); } } } return(TaskHelper.Done); }
public async Task ValidateAsync(object?value, ValidationContext context, AddError addError) { var count = context.Path.Count(); if (value != null && (count == 0 || (count == 2 && context.Path.Last() == InvariantPartitioning.Key))) { FilterNode <ClrValue>?filter = null; if (value is string s) { filter = ClrFilter.Eq(Path(context), s); } else if (value is double d) { filter = ClrFilter.Eq(Path(context), d); } if (filter != null) { var found = await checkUniqueness(filter); if (found.Any(x => x.Id != context.ContentId)) { addError(context.Path, T.Get("contents.validation.unique")); } } } }
public async Task ValidateAsync(object?value, ValidationContext context, AddError addError) { if (context.Mode == ValidationMode.Optimized) { return; } if (value is ICollection <DomainId> contentIds) { var foundIds = await checkReferences(contentIds.ToHashSet()); foreach (var id in contentIds) { var(schemaId, _) = foundIds.FirstOrDefault(x => x.Id == id); if (schemaId == DomainId.Empty) { addError(context.Path, T.Get("common.referenceNotFound", new { id })); } else if (schemaIds?.Any() == true && !schemaIds.Contains(schemaId)) { addError(context.Path, T.Get("common.referenceToInvalidSchema", new { id })); } } } }
public async Task ValidateAsync(object value, ValidationContext context, AddError addError) { try { var typedValue = value; if (value is IJsonValue jsonValue) { if (jsonValue.Type == JsonValueType.Null) { typedValue = null; } else { typedValue = JsonValueConverter.ConvertValue(field, jsonValue); } } if (validators?.Length > 0) { var tasks = new List <Task>(); foreach (var validator in validators) { tasks.Add(validator.ValidateAsync(typedValue, context, addError)); } await Task.WhenAll(tasks); } } catch { addError(context.Path, "Not a valid value."); } }
public Task ValidateAsync(object?value, ValidationContext context, AddError addError) { if (value is TValue typedValue) { if (min != null && max != null) { if (Equals(min, max) && Equals(min.Value, max.Value)) { addError(context.Path, T.Get("contents.validation.exactValue", new { value = max.Value })); } else if (typedValue.CompareTo(min.Value) < 0 || typedValue.CompareTo(max.Value) > 0) { addError(context.Path, T.Get("contents.validation.between", new { min, max })); } } else { if (min != null && typedValue.CompareTo(min.Value) < 0) { addError(context.Path, T.Get("contents.validation.min", new { min })); } if (max != null && typedValue.CompareTo(max.Value) > 0) { addError(context.Path, T.Get("contents.validation.max", new { max })); } } } return(Task.CompletedTask); }
private void ValidateDimensions(int w, int h, ImmutableQueue <string> path, AddError addError) { var actualRatio = (double)w / h; if (properties.MinWidth != null && w < properties.MinWidth) { addError(path, T.Get("contents.validation.minimumWidth", new { width = w, min = properties.MinWidth })); } if (properties.MaxWidth != null && w > properties.MaxWidth) { addError(path, T.Get("contents.validation.maximumWidth", new { width = w, max = properties.MaxWidth })); } if (properties.MinHeight != null && h < properties.MinHeight) { addError(path, T.Get("contents.validation.minimumHeight", new { height = h, min = properties.MinHeight })); } if (properties.MaxHeight != null && h > properties.MaxHeight) { addError(path, T.Get("contents.validation.maximumHeight", new { height = h, max = properties.MaxHeight })); } if (properties.AspectHeight != null && properties.AspectWidth != null) { var expectedRatio = (double)properties.AspectWidth.Value / properties.AspectHeight.Value; if (Math.Abs(expectedRatio - actualRatio) > double.Epsilon) { addError(path, T.Get("contents.validation.aspectRatio", new { width = properties.AspectWidth, height = properties.AspectHeight })); } } }
public Task ValidateAsync(object?value, ValidationContext context, AddError addError) { if (value is string stringValue && !string.IsNullOrEmpty(stringValue)) { if (minLength != null && maxLength != null) { if (minLength == maxLength && minLength != stringValue.Length) { addError(context.Path, T.Get("contents.validation.characterCount", new { count = minLength })); } else if (stringValue.Length < minLength || stringValue.Length > maxLength) { addError(context.Path, T.Get("contents.validation.charactersBetween", new { min = minLength, max = maxLength })); } } else { if (minLength != null && stringValue.Length < minLength) { addError(context.Path, T.Get("contents.validation.minLength", new { min = minLength })); } if (maxLength != null && stringValue.Length > maxLength) { addError(context.Path, T.Get("contents.validation.maxLength", new { max = maxLength })); } } } return(Task.CompletedTask); }
public Task ValidateAsync(object?value, ValidationContext context, AddError addError) { if (value != null && value is T typedValue) { if (min.HasValue && max.HasValue) { if (Equals(min, max) && Equals(min.Value, max.Value)) { addError(context.Path, $"Must be exactly '{max}'."); } else if (typedValue.CompareTo(min.Value) < 0 || typedValue.CompareTo(max.Value) > 0) { addError(context.Path, $"Must be between '{min}' and '{max}'."); } } else { if (min.HasValue && typedValue.CompareTo(min.Value) < 0) { addError(context.Path, $"Must be greater or equal to '{min}'."); } if (max.HasValue && typedValue.CompareTo(max.Value) > 0) { addError(context.Path, $"Must be less or equal to '{max}'."); } } } return(TaskHelper.Done); }
public async Task ValidateAsync(object value, ValidationContext context, AddError addError) { try { object typedValue = null; if (value is JToken jToken) { typedValue = jToken.IsNull() ? null : JsonValueConverter.ConvertValue(field, jToken); } var tasks = new List <Task>(); foreach (var validator in validators) { tasks.Add(validator.ValidateAsync(typedValue, context, addError)); } await Task.WhenAll(tasks); } catch { addError(context.Path, "Not a valid value."); } }
public async Task ValidateAsync(object?value, ValidationContext context, AddError addError) { var typedValue = value; try { if (value is IJsonValue jsonValue) { if (jsonValue.Type == JsonValueType.Null) { typedValue = null; } else { var(json, error) = JsonValueConverter.ConvertValue(field, jsonValue); if (error != null) { addError(context.Path, error.Error); } else { typedValue = json; } } } } catch { addError(context.Path, T.Get("contents.validation.invalid")); return; } await fieldValueValidator.ValidateAsync(typedValue, context, addError); }
public Task ValidateAsync(object value, ValidationContext context, AddError addError) { if (value is string stringValue) { if (!string.IsNullOrEmpty(stringValue)) { try { if (!regex.IsMatch(stringValue)) { if (string.IsNullOrWhiteSpace(errorMessage)) { addError(context.Path, "Not valid."); } else { addError(context.Path, errorMessage); } } } catch { addError(context.Path, "Regex is too slow."); } } } return(TaskHelper.Done); }
public Task ValidateAsync(object?value, ValidationContext context, AddError addError) { if (value is string stringValue) { if (!string.IsNullOrEmpty(stringValue)) { try { if (!regex.IsMatch(stringValue)) { if (string.IsNullOrWhiteSpace(errorMessage)) { addError(context.Path, T.Get("contents.validation.pattern")); } else { addError(context.Path, errorMessage); } } } catch { addError(context.Path, T.Get("contents.validation.regexTooSlow")); } } } return(Task.CompletedTask); }
public async Task ValidateAsync(object value, ValidationContext context, AddError addError) { if (value is ContentData data) { var validateableFields = context.Schema.Fields.Where(IsValidateableField); var filters = new List <FilterNode <ClrValue> >(); foreach (var field in validateableFields) { var fieldValue = TryGetValue(field, data); if (fieldValue != null) { filters.Add(ClrFilter.Eq($"data.{field.Name}.iv", fieldValue)); } } if (filters.Count > 0) { var filter = ClrFilter.And(filters); var found = await contentRepository.QueryIdsAsync(context.AppId.Id, context.SchemaId.Id, filter); if (found.Any(x => x.Id != context.ContentId)) { addError(Enumerable.Empty <string>(), "A content with the same values already exist."); } } } }
public async Task ValidateAsync(object?value, ValidationContext context, AddError addError) { if (context.Mode == ValidationMode.Optimized) { return; } if (value is ICollection <Guid> contentIds) { var foundIds = await context.GetContentIdsAsync(contentIds.ToHashSet()); foreach (var id in contentIds) { var(schemaId, _) = foundIds.FirstOrDefault(x => x.Id == id); if (schemaId == Guid.Empty) { addError(context.Path, $"Contains invalid reference '{id}'."); } else if (schemaIds?.Any() == true && !schemaIds.Contains(schemaId)) { addError(context.Path, $"Contains reference '{id}' to invalid schema."); } } } }
public async Task ValidateAsync(object value, ValidationContext context, AddError addError) { var count = context.Path.Count(); if (value != null && (count == 0 || (count == 2 && context.Path.Last() == InvariantPartitioning.Key))) { FilterNode <ClrValue> filter = null; if (value is string s) { filter = ClrFilter.Eq(Path(context), s); } else if (value is double d) { filter = ClrFilter.Eq(Path(context), d); } if (filter != null) { var found = await context.GetContentIdsAsync(context.SchemaId, filter); if (found.Any(x => x != context.ContentId)) { addError(context.Path, "Another content with the same value exists."); } } } }
static void AddErrors(AddError addError, IEnumerable<string> messages) { foreach (string message in messages) { BuildError error = CreateBuildError (message); addError (error.FileName, error.Line, error.Column, error.ErrorNumber, error.ErrorText); } }
public async Task ValidateAsync(object?value, ValidationContext context, AddError addError) { var foundIds = new List <DomainId>(); if (value is ICollection <DomainId> contentIds && contentIds.Count > 0) { var references = await checkReferences(contentIds.ToHashSet()); var index = 0; foreach (var id in contentIds) { index++; var path = context.Path.Enqueue($"[{index}]"); var(schemaId, _, status) = references.FirstOrDefault(x => x.Id == id); if (schemaId == DomainId.Empty) { if (context.Action == ValidationAction.Upsert) { addError(path, T.Get("contents.validation.referenceNotFound", new { id })); } continue; } var isValid = true; if (properties.SchemaIds?.Any() == true && !properties.SchemaIds.Contains(schemaId)) { if (context.Action == ValidationAction.Upsert) { addError(path, T.Get("contents.validation.referenceToInvalidSchema", new { id })); } isValid = false; } isValid &= (!properties.MustBePublished || status == Status.Published); if (isValid) { foundIds.Add(id); } } } if (collectionValidator != null) { await collectionValidator.ValidateAsync(foundIds, context, addError); } if (uniqueValidator != null) { await uniqueValidator.ValidateAsync(foundIds, context, addError); } }
public ValueTask ValidateAsync(object?value, ValidationContext context, AddError addError) { if (value.IsNullOrUndefined() && !context.IsOptional) { addError(context.Path, T.Get("contents.validation.required")); } return(default);
public ValueTask ValidateAsync(object?value, ValidationContext context, AddError addError) { if (!value.IsUndefined()) { addError(context.Path, T.Get("contents.validation.mustBeEmpty")); } return(default);
static void AddErrors(AddError addError, IEnumerable <string> messages) { foreach (string message in messages) { BuildError error = CreateBuildError(message); addError(error.FileName, error.Line, error.Column, error.ErrorNumber, error.ErrorText); } }
public ValueTask ValidateAsync(object?value, ValidationContext context, AddError addError) { if (value is TValue typedValue && !allowedValues.Contains(typedValue)) { addError(context.Path, T.Get("contents.validation.notAllowed")); } return(default);
public Task ValidateAsync(object value, ValidationContext context, AddError addError) { if (validators?.Length > 0) { return(Task.WhenAll(validators.Select(x => x.ValidateAsync(value, context, addError)))); } return(Task.CompletedTask); }
private void ValidateType(IAssetInfo asset, ImmutableQueue <string> path, AddError addError) { var type = asset.MimeType == "image/svg+xml" ? AssetType.Image : asset.Type; if (properties.ExpectedType != null && properties.ExpectedType != type) { addError(path, T.Get("contents.validation.assetType", new { type = properties.ExpectedType })); } }
public Task ValidateAsync(object value, ValidationContext context, AddError addError) { if (!value.IsUndefined()) { addError(context.Path, "Value must not be defined."); } return(Task.CompletedTask); }
public Task ValidateAsync(object value, ValidationContext context, AddError addError) { if (value.IsNullOrUndefined() && !context.IsOptional) { addError(context.Path, "Field is required."); } return(TaskHelper.Done); }
public Task ValidateAsync(object value, ValidationContext context, AddError addError) { if (value != null && value is T typedValue && !allowedValues.Contains(typedValue)) { addError(context.Path, "Not an allowed value."); } return(TaskHelper.Done); }