/// <summary>
/// Provides the validation logic for this keyword.
/// </summary>
/// <param name="context">The context object.</param>
/// <returns>Results object containing a final result and any errors that may have been found.</returns>
public SchemaValidationResults Validate(SchemaValidationContext context)
{
var results = new SchemaValidationResults(Name, context)
{
AnnotationValue = Value.Key
};
if (!JsonSchemaOptions.ValidateFormatKeyword)
{
return(results);
}
if (context.Instance.Type != JsonValueType.String)
{
return(results);
}
var format = Value;
if (!format.Validate(context.Instance.String))
{
results.IsValid = false;
results.AdditionalInfo["actual"] = context.Instance;
results.AdditionalInfo["format"] = format.Key;
results.AdditionalInfo["isKnownFormat"] = format.IsKnown;
results.ErrorMessage = ErrorTemplate.ResolveTokens(results.AdditionalInfo);
}
;
return(results);
}
/// <summary>
/// Provides the validation logic for this dependency.
/// </summary>
/// <param name="context">The context object.</param>
/// <returns>Results object containing a final result and any errors that may have been found.</returns>
public SchemaValidationResults Validate(SchemaValidationContext context)
{
var results = new SchemaValidationResults(PropertyName, context)
{
Keyword = $"{context.Misc["dependencyParent"]}/{PropertyName}"
};
if (context.Instance.Type != JsonValueType.Object)
{
Log.Schema("Instance not an object; not applicable");
return(results);
}
if (!context.Instance.Object.ContainsKey(PropertyName))
{
Log.Schema($"Property {PropertyName} not found; not applicable");
return(results);
}
var missingProperties = _dependencies.Except(context.Instance.Object.Keys).ToList();
if (missingProperties.Any())
{
Log.Schema($"Properties {missingProperties} not found but required by property {PropertyName}");
results.IsValid = false;
results.AdditionalInfo["required"] = missingProperties.ToJson();
results.AdditionalInfo["dependency"] = PropertyName;
results.ErrorMessage = ErrorTemplate.ResolveTokens(results.AdditionalInfo);
}
return(results);
}
/// <summary>
/// Provides the validation logic for this keyword.
/// </summary>
/// <param name="context">The context object.</param>
/// <returns>Results object containing a final result and any errors that may have been found.</returns>
public SchemaValidationResults Validate(SchemaValidationContext context)
{
var results = new SchemaValidationResults(Name, context);
if (context.Instance.Type != JsonValueType.Array)
{
return(results);
}
if (!context.Misc.TryGetValue("containsCount", out var value))
{
return(results);
}
var containsCount = (int)value;
if (containsCount > Value)
{
results.IsValid = false;
results.AdditionalInfo["actual"] = containsCount;
results.AdditionalInfo["upperBound"] = Value;
results.ErrorMessage = ErrorTemplate.ResolveTokens(results.AdditionalInfo);
}
return(results);
}
/// <summary>
/// Provides the validation logic for this keyword.
/// </summary>
/// <param name="context">The context object.</param>
/// <returns>Results object containing a final result and any errors that may have been found.</returns>
public SchemaValidationResults Validate(SchemaValidationContext context)
{
var results = new SchemaValidationResults(Name, context);
if (context.Instance.Type != JsonValueType.Number)
{
Log.Schema("Instance not a number; not applicable");
return(results);
}
var keyword = context.Local.Get <MaximumKeyword>();
if (keyword == null)
{
Log.Schema("`maximum` keyword not defined; not applicable");
return(results);
}
if (!Value)
{
Log.Schema("Not exclusive; see `maximum` results");
return(results);
}
if (context.Instance.Number >= keyword.Value)
{
Log.Schema($"Bounds check failed: {context.Instance.Number} >= {keyword.Value}");
results.IsValid = false;
results.AdditionalInfo["upperBound"] = keyword.Value;
results.AdditionalInfo["actual"] = context.Instance;
results.ErrorMessage = ErrorTemplate.ResolveTokens(results.AdditionalInfo);
}
return(results);
}
/// <summary>
/// Provides the validation logic for this keyword.
/// </summary>
/// <param name="context">The context object.</param>
/// <returns>Results object containing a final result and any errors that may have been found.</returns>
public SchemaValidationResults Validate(SchemaValidationContext context)
{
var results = new SchemaValidationResults(Name, context);
if (context.Instance.Type != JsonValueType.Array)
{
Log.Schema(() => "Instance not an array; not applicable");
return(results);
}
if (!context.Misc.TryGetValue("containsCount", out var value))
{
Log.Schema(() => "`contains` keyword not present; not applicable");
return(results);
}
var containsCount = (int)value;
if (containsCount > Value)
{
Log.Schema(() => $"Required no more than {Value} matching items, but {containsCount} found");
results.IsValid = false;
results.AdditionalInfo["actual"] = containsCount;
results.AdditionalInfo["upperBound"] = Value;
results.ErrorMessage = ErrorTemplate.ResolveTokens(results.AdditionalInfo);
}
return(results);
}
/// <summary>
/// Provides the validation logic for this keyword.
/// </summary>
/// <param name="context">The context object.</param>
/// <returns>Results object containing a final result and any errors that may have been found.</returns>
public SchemaValidationResults Validate(SchemaValidationContext context)
{
var results = new SchemaValidationResults(Name, context);
if (context.Instance.Type != JsonValueType.Object)
{
Log.Schema(() => "Instance not an object; not applicable");
return(results);
}
var baseRelativeLocation = context.BaseRelativeLocation?.CloneAndAppend(Name);
var relativeLocation = context.RelativeLocation.CloneAndAppend(Name);
var valid = true;
var reportChildErrors = context.Options.ShouldReportChildErrors(this, context);
var nestedResults = new List <SchemaValidationResults>();
var invalidPropertyNames = new JsonArray();
foreach (var propertyName in context.Instance.Object.Keys)
{
var newContext = new SchemaValidationContext(context)
{
Instance = propertyName,
BaseRelativeLocation = baseRelativeLocation,
RelativeLocation = relativeLocation,
InstanceLocation = context.InstanceLocation.CloneAndAppend(propertyName),
};
var localResults = Value.Validate(newContext);
valid &= localResults.IsValid;
if (!valid)
{
invalidPropertyNames.Add(propertyName);
}
if (context.Options.OutputFormat == SchemaValidationOutputFormat.Flag)
{
if (!valid)
{
Log.Schema(() => "Subschema failed; halting validation early");
break;
}
}
else if (reportChildErrors)
{
nestedResults.Add(localResults);
}
}
results.IsValid = valid;
results.NestedResults = nestedResults;
if (!results.IsValid)
{
Log.Schema(() => $"Property names {invalidPropertyNames.ToJson()} failed");
results.AdditionalInfo["properties"] = invalidPropertyNames;
results.ErrorMessage = ErrorTemplate.ResolveTokens(results.AdditionalInfo);
}
return(results);
}
/// <summary>
/// Provides the validation logic for this keyword.
/// </summary>
/// <param name="context">The context object.</param>
/// <returns>Results object containing a final result and any errors that may have been found.</returns>
public SchemaValidationResults Validate(SchemaValidationContext context)
{
var valid = false;
var reportChildErrors = context.Options.ShouldReportChildErrors(this, context);
var i = 0;
var nestedResults = new List <SchemaValidationResults>();
var baseContext = new SchemaValidationContext(context);
baseContext.EvaluatedPropertyNames.Clear();
baseContext.LocallyEvaluatedPropertyNames.Clear();
baseContext.LastEvaluatedIndex = -1;
baseContext.LocalTierLastEvaluatedIndex = -1;
foreach (var s in this)
{
var newContext = new SchemaValidationContext(baseContext)
{
BaseRelativeLocation = context.BaseRelativeLocation?.CloneAndAppend(Name, i.ToString()),
RelativeLocation = context.RelativeLocation.CloneAndAppend(Name, i.ToString()),
};
var localResults = s.Validate(newContext);
valid |= localResults.IsValid;
Log.Schema(() => $"`{Name}` {(valid ? "valid" : "invalid")} so far");
if (localResults.IsValid)
{
context.UpdateEvaluatedPropertiesAndItemsFromSubschemaValidation(newContext);
}
if (context.Options.OutputFormat == SchemaValidationOutputFormat.Flag)
{
if (valid)
{
Log.Schema(() => "Subschema passed; halting validation early");
break;
}
}
else if (reportChildErrors)
{
nestedResults.Add(localResults);
}
i++;
}
var resultsList = nestedResults.ToList();
var results = new SchemaValidationResults(Name, context)
{
NestedResults = resultsList,
IsValid = valid
};
if (!results.IsValid)
{
results.ErrorMessage = ErrorTemplate.ResolveTokens(results.AdditionalInfo);
}
return(results);
}
/// <summary>
/// Provides the validation logic for this keyword.
/// </summary>
/// <param name="context">The context object.</param>
/// <returns>Results object containing a final result and any errors that may have been found.</returns>
public SchemaValidationResults Validate(SchemaValidationContext context)
{
var valid = true;
var reportChildErrors = context.Options.ShouldReportChildErrors(this, context);
var i = 0;
var nestedResults = new List <SchemaValidationResults>();
var failedCount = 0;
foreach (var s in this)
{
var newContext = new SchemaValidationContext(context)
{
BaseRelativeLocation = context.BaseRelativeLocation?.CloneAndAppend(Name, i.ToString()),
RelativeLocation = context.RelativeLocation.CloneAndAppend(Name, i.ToString()),
};
var localResults = s.Validate(newContext);
valid &= localResults.IsValid;
Log.Schema(() => $"`{Name}` {(valid ? "valid" : "invalid")} so far");
if (!localResults.IsValid)
{
failedCount++;
}
else
{
context.UpdateEvaluatedPropertiesAndItemsFromSubschemaValidation(newContext);
}
if (context.Options.OutputFormat == SchemaValidationOutputFormat.Flag)
{
if (!valid)
{
Log.Schema(() => "Subschema failed; halting validation early");
break;
}
}
else if (reportChildErrors)
{
nestedResults.Add(localResults);
}
i++;
}
var results = new SchemaValidationResults(Name, context)
{
NestedResults = nestedResults,
IsValid = valid
};
if (!results.IsValid)
{
results.AdditionalInfo["failed"] = failedCount;
results.AdditionalInfo["total"] = Count;
results.ErrorMessage = ErrorTemplate.ResolveTokens(results.AdditionalInfo);
}
return(results);
}
/// <summary>
/// Provides the validation logic for this keyword.
/// </summary>
/// <param name="context">The context object.</param>
/// <returns>Results object containing a final result and any errors that may have been found.</returns>
public SchemaValidationResults Validate(SchemaValidationContext context)
{
var reportChildErrors = context.Options.ShouldReportChildErrors(this, context);
var i = 0;
var nestedResults = new List <SchemaValidationResults>();
var validCount = 0;
var contextCopy = new SchemaValidationContext(context);
foreach (var s in this)
{
var newContext = new SchemaValidationContext(context)
{
BaseRelativeLocation = context.BaseRelativeLocation?.CloneAndAppend(Name, i.ToString()),
RelativeLocation = context.RelativeLocation.CloneAndAppend(Name, i.ToString()),
};
var localResults = s.Validate(newContext);
if (localResults.IsValid)
{
validCount++;
contextCopy.UpdateEvaluatedPropertiesAndItemsFromSubschemaValidation(newContext);
}
Log.Schema(() => $"`{Name}` {validCount} items valid so far");
if (context.Options.OutputFormat == SchemaValidationOutputFormat.Flag)
{
if (validCount > 1)
{
Log.Schema(() => "More than one subschema succeeded; halting validation early");
break;
}
}
else if (reportChildErrors)
{
nestedResults.Add(localResults);
}
}
var results = new SchemaValidationResults(Name, context)
{
IsValid = validCount == 1,
NestedResults = nestedResults
};
if (!results.IsValid)
{
Log.Schema(() => $"{validCount} subschemas passed validation; expected only one");
results.AdditionalInfo["passed"] = validCount;
results.ErrorMessage = ErrorTemplate.ResolveTokens(results.AdditionalInfo);
}
else
{
context.UpdateEvaluatedPropertiesAndItemsFromSubschemaValidation(contextCopy);
}
return(results);
}
/// <summary>
/// Provides the validation logic for this keyword.
/// </summary>
/// <param name="context">The context object.</param>
/// <returns>Results object containing a final result and any errors that may have been found.</returns>
public SchemaValidationResults Validate(SchemaValidationContext context)
{
var baseRelativeLocation = context.BaseRelativeLocation?.CloneAndAppend(Name);
var relativeLocation = context.RelativeLocation.CloneAndAppend(Name);
var valid = true;
var reportChildErrors = JsonSchemaOptions.ShouldReportChildErrors(this, context);
var nestedResults = new List <SchemaValidationResults>();
var failedCount = 0;
foreach (var d in this)
{
var newContext = new SchemaValidationContext(context)
{
BaseRelativeLocation = baseRelativeLocation,
RelativeLocation = relativeLocation,
Misc = { ["dependencyParent"] = Name }
};
var localResults = d.Validate(newContext);
valid &= localResults.IsValid;
if (!valid)
{
failedCount++;
}
if (JsonSchemaOptions.OutputFormat == SchemaValidationOutputFormat.Flag)
{
if (!valid)
{
Log.Schema("Dependency failed; halting validation early");
break;
}
}
else if (reportChildErrors)
{
nestedResults.Add(localResults);
}
}
var results = new SchemaValidationResults(Name, context)
{
IsValid = valid
};
if (JsonSchemaOptions.OutputFormat == SchemaValidationOutputFormat.Flag)
{
results.NestedResults = nestedResults;
}
else if (!results.IsValid)
{
results.AdditionalInfo["failed"] = failedCount;
results.AdditionalInfo["total"] = Count;
results.ErrorMessage = ErrorTemplate.ResolveTokens(results.AdditionalInfo);
}
return(results);
}
/// <summary>
/// Provides the validation logic for this keyword.
/// </summary>
/// <param name="context">The context object.</param>
/// <returns>Results object containing a final result and any errors that may have been found.</returns>
public SchemaValidationResults Validate(SchemaValidationContext context)
{
var nestedResults = this.Select((s, i) =>
{
var newContext = new SchemaValidationContext(context)
{
BaseRelativeLocation = context.BaseRelativeLocation.CloneAndAppend(Name, i.ToString()),
RelativeLocation = context.RelativeLocation.CloneAndAppend(Name, i.ToString()),
};
var result = s.Validate(newContext);
context.EvaluatedPropertyNames.AddRange(newContext.EvaluatedPropertyNames);
context.EvaluatedPropertyNames.AddRange(newContext.LocallyEvaluatedPropertyNames);
return(result);
});
SchemaValidationResults results;
var validCount = 0;
if (JsonSchemaOptions.OutputFormat == SchemaValidationOutputFormat.Flag)
{
results = new SchemaValidationResults(Name, context);
foreach (var result in nestedResults)
{
if (result.IsValid)
{
if (validCount != 0)
{
results.IsValid = false;
return(results);
}
validCount++;
}
}
results.IsValid = validCount == 1;
}
else
{
var resultsList = nestedResults.ToList();
validCount = resultsList.Count(r => r.IsValid);
results = new SchemaValidationResults(Name, context)
{
NestedResults = resultsList,
IsValid = validCount == 1
};
}
if (!results.IsValid)
{
results.AdditionalInfo["passed"] = validCount;
results.ErrorMessage = ErrorTemplate.ResolveTokens(results.AdditionalInfo);
}
return(results);
}
/// <summary>
/// Provides the validation logic for this keyword.
/// </summary>
/// <param name="context">The context object.</param>
/// <returns>Results object containing a final result and any errors that may have been found.</returns>
public SchemaValidationResults Validate(SchemaValidationContext context)
{
var results = new SchemaValidationResults(Name, context)
{
IsValid = Contains(context.Instance)
};
if (!results.IsValid)
{
results.AdditionalInfo["value"] = context.Instance;
results.ErrorMessage = ErrorTemplate.ResolveTokens(results.AdditionalInfo);
}
return(results);
}
/// <summary>
/// Provides the validation logic for this keyword.
/// </summary>
/// <param name="context">The context object.</param>
/// <returns>Results object containing a final result and any errors that may have been found.</returns>
public SchemaValidationResults Validate(SchemaValidationContext context)
{
Log.Schema("Checking defined values for instance");
var results = new SchemaValidationResults(Name, context)
{
IsValid = Contains(context.Instance)
};
if (!results.IsValid)
{
Log.Schema("Instance does not match any of the defined values");
results.AdditionalInfo["value"] = context.Instance;
results.ErrorMessage = ErrorTemplate.ResolveTokens(results.AdditionalInfo);
}
return(results);
}
/// <summary>
/// Provides the validation logic for this keyword.
/// </summary>
/// <param name="context">The context object.</param>
/// <returns>Results object containing a final result and any errors that may have been found.</returns>
public SchemaValidationResults Validate(SchemaValidationContext context)
{
var nestedResults = this.Select((s, i) =>
{
var newContext = new SchemaValidationContext(context)
{
BaseRelativeLocation = context.BaseRelativeLocation.CloneAndAppend(Name, i.ToString()),
RelativeLocation = context.RelativeLocation.CloneAndAppend(Name, i.ToString()),
};
var result = s.Validate(newContext);
context.EvaluatedPropertyNames.AddRange(newContext.EvaluatedPropertyNames);
context.EvaluatedPropertyNames.AddRange(newContext.LocallyEvaluatedPropertyNames);
context.LastEvaluatedIndex = Math.Max(context.LastEvaluatedIndex, newContext.LastEvaluatedIndex);
return(result);
});
SchemaValidationResults results;
if (JsonSchemaOptions.OutputFormat == SchemaValidationOutputFormat.Flag)
{
results = new SchemaValidationResults(Name, context)
{
IsValid = nestedResults.All(r => r.IsValid)
}
}
;
else
{
var resultsList = nestedResults.ToList();
results = new SchemaValidationResults(Name, context)
{
NestedResults = resultsList,
IsValid = resultsList.All(r => r.IsValid)
};
if (!results.IsValid)
{
results.AdditionalInfo["failed"] = resultsList.Count(r => !r.IsValid);
results.AdditionalInfo["total"] = Count;
results.ErrorMessage = ErrorTemplate.ResolveTokens(results.AdditionalInfo);
}
}
return(results);
}
/// <summary>
/// Provides the validation logic for this keyword.
/// </summary>
/// <param name="context">The context object.</param>
/// <returns>Results object containing a final result and any errors that may have been found.</returns>
public SchemaValidationResults Validate(SchemaValidationContext context)
{
var results = new SchemaValidationResults(Name, context);
if (context.Instance.Type != JsonValueType.Object)
{
return(results);
}
if (context.Instance.Object.Count < Value)
{
results.IsValid = false;
results.AdditionalInfo["lowerBound"] = Value;
results.AdditionalInfo["actual"] = context.Instance.Object.Count;
results.ErrorMessage = ErrorTemplate.ResolveTokens(results.AdditionalInfo);
}
return(results);
}
/// <summary>
/// Provides the validation logic for this keyword.
/// </summary>
/// <param name="context">The context object.</param>
/// <returns>Results object containing a final result and any errors that may have been found.</returns>
public SchemaValidationResults Validate(SchemaValidationContext context)
{
var results = new SchemaValidationResults(Name, context);
if (context.Instance.Type != JsonValueType.String)
{
return(results);
}
if (!Value.IsMatch(context.Instance.String))
{
results.IsValid = false;
results.AdditionalInfo["actual"] = context.Instance;
results.AdditionalInfo["pattern"] = Value.ToString();
results.ErrorMessage = ErrorTemplate.ResolveTokens(results.AdditionalInfo);
}
return(results);
}
/// <summary>
/// Provides the validation logic for this keyword.
/// </summary>
/// <param name="context">The context object.</param>
/// <returns>Results object containing a final result and any errors that may have been found.</returns>
public SchemaValidationResults Validate(SchemaValidationContext context)
{
var results = new SchemaValidationResults(Name, context);
if (context.Instance.Type != JsonValueType.Object)
{
return(results);
}
var baseRelativeLocation = context.BaseRelativeLocation.CloneAndAppend(Name);
var relativeLocation = context.RelativeLocation.CloneAndAppend(Name);
var nestedResults = context.Instance.Object.Keys.Select(propertyName =>
{
var newContext = new SchemaValidationContext(context)
{
Instance = propertyName,
BaseRelativeLocation = baseRelativeLocation,
RelativeLocation = relativeLocation,
InstanceLocation = context.InstanceLocation.CloneAndAppend(propertyName),
};
var result = Value.Validate(newContext);
return(new { propertyName, result });
}).ToList();
if (JsonSchemaOptions.OutputFormat == SchemaValidationOutputFormat.Flag)
{
results.IsValid = nestedResults.All(r => r.result.IsValid);
}
else
{
results.NestedResults = nestedResults.Select(r => r.result).ToList();
results.IsValid = nestedResults.All(r => r.result.IsValid);
}
if (!results.IsValid)
{
results.AdditionalInfo["properties"] = nestedResults.Select(r => r.propertyName).ToJson();
results.ErrorMessage = ErrorTemplate.ResolveTokens(results.AdditionalInfo);
}
return(results);
}
/// <summary>
/// Provides the validation logic for this keyword.
/// </summary>
/// <param name="context">The context object.</param>
/// <returns>Results object containing a final result and any errors that may have been found.</returns>
public SchemaValidationResults Validate(SchemaValidationContext context)
{
var results = new SchemaValidationResults(Name, context);
if (context.Instance.Type != JsonValueType.Number)
{
return(results);
}
if ((decimal)context.Instance.Number % (decimal?)Value != 0)
{
results.IsValid = false;
results.AdditionalInfo["divisor"] = Value;
results.AdditionalInfo["actual"] = context.Instance.Number % Value;
results.ErrorMessage = ErrorTemplate.ResolveTokens(results.AdditionalInfo);
}
return(results);
}
/// <summary>
/// Provides the validation logic for this keyword.
/// </summary>
/// <param name="context">The context object.</param>
/// <returns>Results object containing a final result and any errors that may have been found.</returns>
public SchemaValidationResults Validate(SchemaValidationContext context)
{
var baseRelativeLocation = context.BaseRelativeLocation.CloneAndAppend(Name);
var relativeLocation = context.RelativeLocation.CloneAndAppend(Name);
var nestedResults = this.Select(d =>
{
var newContext = new SchemaValidationContext(context)
{
BaseRelativeLocation = baseRelativeLocation,
RelativeLocation = relativeLocation,
};
return(d.Validate(newContext));
});
SchemaValidationResults results;
if (JsonSchemaOptions.OutputFormat == SchemaValidationOutputFormat.Flag)
{
results = new SchemaValidationResults(Name, context)
{
IsValid = nestedResults.All(r => r.IsValid)
};
}
else
{
var resultsList = nestedResults.ToList();
results = new SchemaValidationResults(Name, context)
{
NestedResults = resultsList,
IsValid = resultsList.All(r => r.IsValid)
};
}
if (!results.IsValid)
{
results.AdditionalInfo["failed"] = nestedResults.Count(r => !r.IsValid);
results.AdditionalInfo["total"] = Count;
results.ErrorMessage = ErrorTemplate.ResolveTokens(results.AdditionalInfo);
}
return(results);
}
/// <summary>
/// Provides the validation logic for this keyword.
/// </summary>
/// <param name="context">The context object.</param>
/// <returns>Results object containing a final result and any errors that may have been found.</returns>
public SchemaValidationResults Validate(SchemaValidationContext context)
{
var results = new SchemaValidationResults(Name, context)
{
AnnotationValue = Value
};
if (!context.Options.ValidateFormatKeyword)
{
Log.Schema(() => "Options indicate skipping format validation");
return(results);
}
var validator = Formats.GetFormat(Value);
if (validator == null)
{
results.AdditionalInfo["actual"] = context.Instance;
results.AdditionalInfo["format"] = Value;
results.AdditionalInfo["isKnownFormat"] = false;
if (context.Options.AllowUnknownFormats)
{
results.IsValid = true;
}
else
{
results.IsValid = false;
results.ErrorMessage = ErrorTemplate.ResolveTokens(results.AdditionalInfo);
}
}
else if (!validator.Validate(context.Instance))
{
results.IsValid = false;
results.AdditionalInfo["actual"] = context.Instance;
results.AdditionalInfo["format"] = Value;
results.AdditionalInfo["isKnownFormat"] = true;
results.ErrorMessage = ErrorTemplate.ResolveTokens(results.AdditionalInfo);
}
return(results);
}
/// <summary>
/// Provides the validation logic for this keyword.
/// </summary>
/// <param name="context">The context object.</param>
/// <returns>Results object containing a final result and any errors that may have been found.</returns>
public SchemaValidationResults Validate(SchemaValidationContext context)
{
var results = new SchemaValidationResults(Name, context);
if (context.Instance.Type != JsonValueType.Array)
{
Log.Schema("Instance not an array; not applicable");
return(results);
}
if (context.Instance.Array.Count > Value)
{
Log.Schema($"Bounds check failed: {context.Instance.Array.Count} > {Value}");
results.IsValid = false;
results.AdditionalInfo["upperBound"] = Value;
results.AdditionalInfo["actual"] = context.Instance.Array.Count;
results.ErrorMessage = ErrorTemplate.ResolveTokens(results.AdditionalInfo);
}
return(results);
}
/// <summary>
/// Provides the validation logic for this keyword.
/// </summary>
/// <param name="context">The context object.</param>
/// <returns>Results object containing a final result and any errors that may have been found.</returns>
public SchemaValidationResults Validate(SchemaValidationContext context)
{
var results = new SchemaValidationResults(Name, context);
if (context.Instance.Type != JsonValueType.Number)
{
Log.Schema(() => "Instance not a number; not applicable");
return(results);
}
if (context.Instance.Number <= Value)
{
Log.Schema(() => $"Bounds check failed: {context.Instance.Number} <= {Value}");
results.IsValid = false;
results.AdditionalInfo["lowerBound"] = Value;
results.AdditionalInfo["actual"] = context.Instance;
results.ErrorMessage = ErrorTemplate.ResolveTokens(results.AdditionalInfo);
}
return(results);
}
/// <summary>
/// Provides the validation logic for this keyword.
/// </summary>
/// <param name="context">The context object.</param>
/// <returns>Results object containing a final result and any errors that may have been found.</returns>
public SchemaValidationResults Validate(SchemaValidationContext context)
{
var results = new SchemaValidationResults(Name, context);
if (context.Instance.Type != JsonValueType.String)
{
return(results);
}
var length = new StringInfo(context.Instance.String).LengthInTextElements;
if (length > Value)
{
results.IsValid = false;
results.AdditionalInfo["upperBound"] = Value;
results.AdditionalInfo["actual"] = context.Instance.String.Length;
results.ErrorMessage = ErrorTemplate.ResolveTokens(results.AdditionalInfo);
}
return(results);
}
/// <summary>
/// Provides the validation logic for this keyword.
/// </summary>
/// <param name="context">The context object.</param>
/// <returns>Results object containing a final result and any errors that may have been found.</returns>
public SchemaValidationResults Validate(SchemaValidationContext context)
{
var results = new SchemaValidationResults(Name, context);
if (context.Instance.Type != JsonValueType.Number)
{
Log.Schema(() => "Instance not a number; not applicable");
return(results);
}
if ((decimal)context.Instance.Number % (decimal?)Value != 0)
{
Log.Schema(() => $"{context.Instance.Number} is not a multiple of {Value}");
results.IsValid = false;
results.AdditionalInfo["divisor"] = Value;
results.AdditionalInfo["actual"] = context.Instance.Number % Value;
results.ErrorMessage = ErrorTemplate.ResolveTokens(results.AdditionalInfo);
}
return(results);
}
/// <summary>
/// Provides the validation logic for this keyword.
/// </summary>
/// <param name="context">The context object.</param>
/// <returns>Results object containing a final result and any errors that may have been found.</returns>
public SchemaValidationResults Validate(SchemaValidationContext context)
{
var results = new SchemaValidationResults(Name, context);
if (context.Instance.Type != JsonValueType.String)
{
Log.Schema("Instance not a string; not applicable");
return(results);
}
if (!Value.IsMatch(context.Instance.String))
{
Log.Schema("Value does not match regular expression");
results.IsValid = false;
results.AdditionalInfo["actual"] = context.Instance;
results.AdditionalInfo["pattern"] = Value.ToString();
results.ErrorMessage = ErrorTemplate.ResolveTokens(results.AdditionalInfo);
}
return(results);
}
/// <summary>
/// Provides the validation logic for this keyword.
/// </summary>
/// <param name="context">The context object.</param>
/// <returns>Results object containing a final result and any errors that may have been found.</returns>
public SchemaValidationResults Validate(SchemaValidationContext context)
{
if (context.Instance == Value)
{
return(new SchemaValidationResults(Name, context));
}
var results = new SchemaValidationResults(Name, context)
{
IsValid = false,
Keyword = Name,
AdditionalInfo =
{
["expected"] = Value,
["actual"] = context.Instance
}
};
results.ErrorMessage = ErrorTemplate.ResolveTokens(results.AdditionalInfo);
return(results);
}
/// <summary>
/// Provides the validation logic for this dependency.
/// </summary>
/// <param name="context">The context object.</param>
/// <returns>Results object containing a final result and any errors that may have been found.</returns>
public SchemaValidationResults Validate(SchemaValidationContext context)
{
var results = new SchemaValidationResults(PropertyName, context);
if (context.Instance.Type != JsonValueType.Object)
{
return(results);
}
if (context.Instance.Object.ContainsKey(PropertyName))
{
var missingProperties = _dependencies.Except(context.Instance.Object.Keys).ToList();
if (missingProperties.Any())
{
results.IsValid = false;
results.Keyword = $"dependencies/{PropertyName}";
results.AdditionalInfo["required"] = missingProperties.ToJson();
results.AdditionalInfo["dependency"] = PropertyName;
results.ErrorMessage = ErrorTemplate.ResolveTokens(results.AdditionalInfo);
}
}
return(results);
}
/// <summary>
/// Provides the validation logic for this keyword.
/// </summary>
/// <param name="context">The context object.</param>
/// <returns>Results object containing a final result and any errors that may have been found.</returns>
public SchemaValidationResults Validate(SchemaValidationContext context)
{
var results = new SchemaValidationResults(Name, context);
if (context.Instance.Type != JsonValueType.String)
{
Log.Schema("Instance not a string; not applicable");
return(results);
}
var length = new StringInfo(context.Instance.String).LengthInTextElements;
if (length < Value)
{
Log.Schema($"Bounds check failed: {length} < {Value}");
results.IsValid = false;
results.AdditionalInfo["lowerBound"] = Value;
results.AdditionalInfo["actual"] = context.Instance.String.Length;
results.ErrorMessage = ErrorTemplate.ResolveTokens(results.AdditionalInfo);
}
return(results);
}
/// <summary>
/// Provides the validation logic for this keyword.
/// </summary>
/// <param name="context">The context object.</param>
/// <returns>Results object containing a final result and any errors that may have been found.</returns>
public SchemaValidationResults Validate(SchemaValidationContext context)
{
if (context.Instance.Type != JsonValueType.Array)
{
return(new SchemaValidationResults(Name, context));
}
var itemsKeyword = context.Local.Get <ItemsKeyword?>();
if (itemsKeyword == null || !itemsKeyword.IsArray)
{
return(new SchemaValidationResults(Name, context));
}
var nestedResults = new List <SchemaValidationResults>();
var array = context.Instance.Array;
var results = new SchemaValidationResults(Name, context);
var valid = true;
var reportChildErrors = context.Options.ShouldReportChildErrors(this, context);
var startIndex = context.LocalTierLastEvaluatedIndex + 1;
var failedIndices = new JsonArray();
Log.Schema(() => startIndex == 0
? "No indices have been evaluated; process all"
: $"Indices up to {context.LastEvaluatedIndex} have been evaluated; skipping these");
if (startIndex < array.Count)
{
if (Value == JsonSchema.False)
{
Log.Schema(() => $"Subschema is `false`; all instances after index {startIndex} are invalid");
results.IsValid = false;
results.Keyword = Name;
results.AdditionalInfo["indices"] = Enumerable.Range(startIndex, array.Count - startIndex).ToJson();
results.ErrorMessage = ErrorTemplate_False.ResolveTokens(results.AdditionalInfo);
return(results);
}
var eligibleItems = array.Skip(startIndex);
var index = startIndex;
foreach (var item in eligibleItems)
{
var baseRelativeLocation = context.BaseRelativeLocation?.CloneAndAppend(Name);
var relativeLocation = context.RelativeLocation.CloneAndAppend(Name);
var newContext = new SchemaValidationContext(context)
{
Instance = item,
BaseRelativeLocation = baseRelativeLocation,
RelativeLocation = relativeLocation,
InstanceLocation = context.InstanceLocation.CloneAndAppend(index.ToString()),
};
var localResults = Value.Validate(newContext);
if (!localResults.IsValid)
{
failedIndices.Add(index);
}
else if (context.ShouldTrackValidatedValues)
{
newContext.LocallyValidatedIndices.Add(index);
}
valid &= localResults.IsValid;
context.LastEvaluatedIndex = Math.Max(context.LastEvaluatedIndex, index);
context.LocalTierLastEvaluatedIndex = Math.Max(context.LastEvaluatedIndex, index);
context.UpdateEvaluatedPropertiesAndItemsFromSubschemaValidation(newContext);
index++;
if (context.Options.OutputFormat == SchemaValidationOutputFormat.Flag)
{
if (!valid)
{
Log.Schema(() => "Subschema failed; halting validation early");
break;
}
}
else if (reportChildErrors)
{
nestedResults.Add(localResults);
}
}
}
else
{
Log.Schema(() => "All items have been validated");
}
results.NestedResults = nestedResults;
results.IsValid = valid;
results.Keyword = Name;
if (!valid)
{
results.AdditionalInfo["indices"] = failedIndices;
results.ErrorMessage = ErrorTemplate.ResolveTokens(results.AdditionalInfo);
}
return(results);
}
/// <summary>
/// Provides the validation logic for this keyword.
/// </summary>
/// <param name="context">The context object.</param>
/// <returns>Results object containing a final result and any errors that may have been found.</returns>
public SchemaValidationResults Validate(SchemaValidationContext context)
{
var results = new SchemaValidationResults(Name, context);
bool valid = true;
switch (context.Instance.Type)
{
case JsonValueType.Number:
if (Value.HasFlag(JsonSchemaType.Number))
{
break;
}
if (context.Instance.Number.IsInt() && Value.HasFlag(JsonSchemaType.Integer))
{
break;
}
valid = false;
break;
case JsonValueType.String:
var expected = Value.ToJson();
if (expected.Type == JsonValueType.String && expected == context.Instance)
{
break;
}
if (expected.Type == JsonValueType.Array && expected.Array.Contains(context.Instance))
{
break;
}
if (Value.HasFlag(JsonSchemaType.String))
{
break;
}
valid = false;
break;
case JsonValueType.Boolean:
if (Value.HasFlag(JsonSchemaType.Boolean))
{
break;
}
valid = false;
break;
case JsonValueType.Object:
if (Value.HasFlag(JsonSchemaType.Object))
{
break;
}
valid = false;
break;
case JsonValueType.Array:
if (Value.HasFlag(JsonSchemaType.Array))
{
break;
}
valid = false;
break;
case JsonValueType.Null:
if (Value.HasFlag(JsonSchemaType.Null))
{
break;
}
valid = false;
break;
}
if (!valid)
{
results.IsValid = false;
results.AdditionalInfo["allowed"] = Value.ToJson();
results.AdditionalInfo["actual"] = context.Instance.Type.ToString().ToLower();
results.ErrorMessage = ErrorTemplate.ResolveTokens(results.AdditionalInfo);
}
return(results);
}
