/// <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 missingProperties = new List <string>();
var obj = context.Instance.Object;
foreach (var propertyName in this)
{
if (!obj.ContainsKey(propertyName))
{
missingProperties.Add(propertyName);
}
}
if (missingProperties.Any())
{
results.IsValid = false;
results.Keyword = Name;
results.AdditionalInfo["missing"] = missingProperties.ToJson();
}
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)
{
return(new SchemaValidationResults(Name, context)
{
AnnotationValue = this.ToJson()
});
}
/// <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 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
{
BaseUri = context.BaseUri,
Instance = context.Instance,
Root = context.Root,
BaseRelativeLocation = context.BaseRelativeLocation.CloneAndAppend(Name, i.ToString()),
RelativeLocation = context.RelativeLocation.CloneAndAppend(Name, i.ToString()),
InstanceLocation = context.InstanceLocation
};
var result = s.Validate(newContext);
context.EvaluatedPropertyNames.AddRange(newContext.EvaluatedPropertyNames);
return(result);
}).ToList();
var results = new SchemaValidationResults(Name, context)
{
NestedResults = nestedResults
};
var validCount = nestedResults.Count(r => r.IsValid);
if (validCount != 1)
{
results.IsValid = false;
results.Keyword = Name;
}
results.NestedResults.AddRange(nestedResults);
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)
{
return(new SchemaValidationResults(context)
{
AnnotationValue = Value
});
}
/// <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.String)
{
Log.Schema(() => "Instance not a string; not applicable");
return(new SchemaValidationResults(Name, context));
}
var baseRelativeLocation = context.BaseRelativeLocation?.CloneAndAppend(Name);
var relativeLocation = context.RelativeLocation.CloneAndAppend(Name);
var nestedResult = Value.Validate(new SchemaValidationContext(context)
{
BaseRelativeLocation = baseRelativeLocation,
RelativeLocation = relativeLocation,
InstanceLocation = context.InstanceLocation.CloneAndAppend(Name),
});
var results = new SchemaValidationResults(Name, context)
{
IsValid = nestedResult.IsValid
};
if (context.Options.OutputFormat != SchemaValidationOutputFormat.Flag)
{
results.NestedResults = new List <SchemaValidationResults> {
nestedResult
}
}
;
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);
var baseRelativeLocation = context.BaseRelativeLocation.CloneAndAppend(Name);
var relativeLocation = context.RelativeLocation.CloneAndAppend(Name);
var nestedResults = this.Select(d =>
{
var newContext = new SchemaValidationContext
{
BaseUri = context.BaseUri,
Instance = context.Instance,
Root = context.Root,
BaseRelativeLocation = baseRelativeLocation,
RelativeLocation = relativeLocation,
InstanceLocation = context.InstanceLocation
};
return(d.Validate(newContext));
}).ToList();
if (nestedResults.Any(r => !r.IsValid))
{
results.IsValid = false;
results.Keyword = Name;
results.NestedResults = nestedResults;
}
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 (Resolved == null)
{
_ResolveReference(context);
if (Resolved == null)
{
throw new SchemaReferenceNotFoundException(context.RelativeLocation);
}
Log.Schema(() => "Reference found");
}
var results = new SchemaValidationResults(Name, context);
var newContext = new SchemaValidationContext(context)
{
BaseUri = _resolvedRoot?.DocumentPath,
Instance = context.Instance,
Root = _resolvedRoot ?? context.Root,
BaseRelativeLocation = _resolvedFragment?.WithHash(),
RelativeLocation = context.RelativeLocation.CloneAndAppend(Name),
};
var nestedResults = Resolved.Validate(newContext);
results.IsValid = nestedResults.IsValid;
results.NestedResults.Add(nestedResults);
context.UpdateEvaluatedPropertiesAndItemsFromSubschemaValidation(newContext);
return(results);
}
/// <summary>
/// Used register any subschemas during validation. Enables look-forward compatibility with `$ref` keywords.
/// </summary>
/// <param name="context">The context object.</param>
public void RegisterSubschemas(SchemaValidationContext context)
{
foreach (var schema in this)
{
schema.RegisterSubschemas(context);
}
}
/// <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);
}
var keyword = context.Local.Get <MinimumKeyword>();
if (keyword == null)
{
return(results);
}
if (!Value)
{
return(results);
}
if (context.Instance.Number <= keyword.Value)
{
results.IsValid = false;
results.AdditionalInfo["lowerBound"] = keyword.Value;
results.AdditionalInfo["actual"] = context.Instance;
}
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);
var newContext = new SchemaValidationContext(context)
{
BaseRelativeLocation = context.BaseRelativeLocation?.CloneAndAppend(Name),
RelativeLocation = context.RelativeLocation.CloneAndAppend(Name),
};
var nestedResults = Value.Validate(newContext);
results.IsValid = !nestedResults.IsValid;
if (nestedResults.IsValid)
{
context.UpdateEvaluatedPropertiesAndItemsFromSubschemaValidation(newContext);
}
if (!results.IsValid)
{
Log.Schema(() => "Subschema succeeded; inverting result");
results.ErrorMessage = ErrorTemplate;
}
if (context.Options.OutputFormat != SchemaValidationOutputFormat.Flag &&
context.Options.ShouldReportChildErrors(this, context))
{
results.NestedResults = new List <SchemaValidationResults> {
nestedResults
}
}
;
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 missingProperties = new List <string>();
var obj = context.Instance.Object;
foreach (var propertyName in this)
{
if (!obj.ContainsKey(propertyName))
{
if (JsonSchemaOptions.OutputFormat == SchemaValidationOutputFormat.Flag)
{
results.IsValid = false;
return(results);
}
missingProperties.Add(propertyName);
}
}
if (missingProperties.Any())
{
results.IsValid = false;
results.AdditionalInfo["properties"] = missingProperties.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 then = context.Local.Get <ThenKeyword>();
var @else = context.Local.Get <ElseKeyword>();
if (then != null || @else != null || context.ShouldTrackValidatedValues)
{
var newContext = new SchemaValidationContext(context)
{
BaseRelativeLocation = context.BaseRelativeLocation?.CloneAndAppend(Name),
RelativeLocation = context.RelativeLocation.CloneAndAppend(Name),
};
var ifResults = Value.Validate(newContext);
context.Misc["ifKeywordValid"] = ifResults.IsValid;
if (ifResults.IsValid)
{
context.UpdateEvaluatedPropertiesAndItemsFromSubschemaValidation(newContext);
}
}
else
{
Log.Schema(() => "`then` and `else` keywords not present; skipping `if` validation");
}
return(new SchemaValidationResults(Name, context));
}
/// <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 at least {Value} matching items, but only {containsCount} found");
results.IsValid = false;
results.AdditionalInfo["actual"] = containsCount;
results.AdditionalInfo["lowerBound"] = 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.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 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)
{
return(new SchemaValidationResults(Name, context)
{
AnnotationValue = Value.ToString()
});
}
/// <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 <MinimumKeyword>();
if (keyword == null)
{
Log.Schema(() => "`minimum` keyword not defined; not applicable");
return(results);
}
if (!Value)
{
Log.Schema(() => "Not exclusive; see `minimum` results");
return(results);
}
if (context.Instance.Number <= keyword.Value)
{
Log.Schema(() => $"Bounds check failed: {context.Instance.Number} <= {keyword.Value}");
results.IsValid = false;
results.AdditionalInfo["lowerBound"] = keyword.Value;
results.AdditionalInfo["actual"] = context.Instance;
results.ErrorMessage = ErrorTemplate.ResolveTokens(results.AdditionalInfo);
}
return(results);
}
/// <summary>
/// Creates a new instance of the <see cref="SchemaValidationContext"/> class by copying values from another instance.
/// </summary>
public SchemaValidationContext(SchemaValidationContext source)
: this(source.Root,
source.Instance,
source.BaseRelativeLocation,
source.RelativeLocation,
source.InstanceLocation,
source.Options)
{
Local = source.Local;
Root = source.Root;
RecursiveAnchor = source.RecursiveAnchor;
Instance = source.Instance;
ShouldTrackValidatedValues = source.ShouldTrackValidatedValues;
_InitializeHashSet(ref _evaluatedPropertyNames, source._evaluatedPropertyNames);
_InitializeHashSet(ref _locallyEvaluatedPropertyNames, source._locallyEvaluatedPropertyNames);
_InitializeHashSet(ref _validatedIndices, source._validatedIndices);
_InitializeHashSet(ref _locallyValidatedIndices, source._locallyValidatedIndices);
LastEvaluatedIndex = source.LastEvaluatedIndex;
LocalTierLastEvaluatedIndex = source.LocalTierLastEvaluatedIndex;
BaseUri = source.BaseUri;
InstanceLocation = source.InstanceLocation;
RelativeLocation = source.RelativeLocation;
BaseRelativeLocation = source.BaseRelativeLocation;
IsMetaSchemaValidation = source.IsMetaSchemaValidation;
LocalRegistry = source.LocalRegistry;
Options = source.Options;
RecursiveRefValidatedLocations = source.RecursiveRefValidatedLocations;
}
/// <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 baseRelativeLocation = context.BaseRelativeLocation.CloneAndAppend(Name);
var relativeLocation = context.RelativeLocation.CloneAndAppend(Name);
var nestedResults = context.Instance.Array.Select((jv, i) =>
{
var newContext = new SchemaValidationContext(context)
{
Instance = jv,
BaseRelativeLocation = baseRelativeLocation,
RelativeLocation = relativeLocation,
InstanceLocation = context.InstanceLocation.CloneAndAppend(i.ToString()),
};
var result = Value.Validate(newContext);
return(result);
});
SchemaValidationResults results;
if (JsonSchemaOptions.OutputFormat == SchemaValidationOutputFormat.Flag &&
context.Local.Get <MinContainsKeyword>() == null &&
context.Local.Get <MaxContainsKeyword>() == null)
{
results = new SchemaValidationResults(Name, context)
{
IsValid = nestedResults.Any(r => r.IsValid)
}
}
;
else
{
var resultsList = nestedResults.ToList();
results = new SchemaValidationResults(Name, context)
{
NestedResults = resultsList
};
var matchedIndices = resultsList.IndexesWhere(r => r.IsValid).Select(i => (JsonValue)i).ToJson();
context.Misc["containsCount"] = matchedIndices.Count;
if (!matchedIndices.Any())
{
results.IsValid = false;
results.Keyword = Name;
results.ErrorMessage = ErrorTemplate;
}
else
{
results.AdditionalInfo["matchedIndices"] = matchedIndices;
}
}
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 nestedResults = new List <SchemaValidationResults>();
var array = context.Instance.Array;
if (context.LastEvaluatedIndex < array.Count)
{
nestedResults.AddRange(array.Skip(context.LastEvaluatedIndex).Select((jv, i) =>
{
var baseRelativeLocation = context.BaseRelativeLocation.CloneAndAppend(Name);
var relativeLocation = context.RelativeLocation.CloneAndAppend(Name);
var newContext = new SchemaValidationContext(context)
{
Instance = jv,
BaseRelativeLocation = baseRelativeLocation,
RelativeLocation = relativeLocation,
InstanceLocation = context.InstanceLocation.CloneAndAppend(i.ToString()),
};
var localResults = Value.Validate(newContext);
context.LastEvaluatedIndex = Math.Max(context.LastEvaluatedIndex, i);
context.LocalTierLastEvaluatedIndex = Math.Max(context.LastEvaluatedIndex, i);
return(localResults);
}));
}
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 (nestedResults.Any(r => !r.IsValid))
{
results.IsValid = false;
results.Keyword = Name;
results.ErrorMessage = ErrorTemplate;
}
return(results);
}
private void _ResolveReference(SchemaValidationContext context)
{
if (context.RecursiveAnchor != null)
{
var baseDocument = JsonSchemaRegistry.Get(context.BaseUri.OriginalString);
if (baseDocument?.Get <RecursiveAnchorKeyword>() != null)
{
_resolvedRoot = context.RecursiveAnchor;
}
}
if (Reference.IsLocalSchemaId())
{
Resolved = context.LocalRegistry.GetLocal(Reference);
if (Resolved != null)
{
return;
}
}
var documentPath = _resolvedRoot?.DocumentPath ?? context.BaseUri;
var referenceParts = Reference.Split(new[] { '#' }, StringSplitOptions.None);
var address = string.IsNullOrWhiteSpace(referenceParts[0]) ? documentPath?.OriginalString : referenceParts[0];
_resolvedFragment = referenceParts.Length > 1 ? JsonPointer.Parse(referenceParts[1]) : new JsonPointer();
if (_resolvedRoot == null)
{
if (!string.IsNullOrWhiteSpace(address))
{
if (!Uri.TryCreate(address, UriKind.Absolute, out var absolute))
{
address = context.Local.Id + address;
}
if (documentPath != null && !Uri.TryCreate(address, UriKind.Absolute, out absolute))
{
var uriFolder = documentPath.OriginalString.EndsWith("/") ? documentPath : documentPath.GetParentUri();
absolute = new Uri(uriFolder, address);
address = absolute.OriginalString;
}
_resolvedRoot = JsonSchemaRegistry.Get(address);
}
else
{
_resolvedRoot = context.Root;
}
}
var wellKnown = JsonSchemaRegistry.GetWellKnown(Reference);
if (wellKnown != null)
{
Resolved = wellKnown;
return;
}
_ResolveLocalReference(_resolvedRoot?.DocumentPath ?? context.BaseUri);
}
/// <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)
{
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);
if (context.LocalTierLastEvaluatedIndex < array.Count)
{
if (Value == JsonSchema.False)
{
results.IsValid = false;
results.Keyword = Name;
results.ErrorMessage = ErrorTemplate_False;
return(results);
}
nestedResults.AddRange(array.Skip(context.LocalTierLastEvaluatedIndex).Select((jv, i) =>
{
var baseRelativeLocation = context.BaseRelativeLocation.CloneAndAppend(Name);
var relativeLocation = context.RelativeLocation.CloneAndAppend(Name);
var newContext = new SchemaValidationContext(context)
{
Instance = jv,
BaseRelativeLocation = baseRelativeLocation,
RelativeLocation = relativeLocation,
InstanceLocation = context.InstanceLocation.CloneAndAppend(i.ToString()),
};
var localResults = Value.Validate(newContext);
context.LastEvaluatedIndex = Math.Max(context.LastEvaluatedIndex, i);
context.LocalTierLastEvaluatedIndex = Math.Max(context.LastEvaluatedIndex, i);
return(localResults);
}));
}
results.NestedResults = nestedResults;
if (nestedResults.Any(r => !r.IsValid))
{
results.IsValid = false;
results.Keyword = Name;
results.ErrorMessage = ErrorTemplate;
}
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)
{
if (context.RecursiveAnchor == null)
{
context.RecursiveAnchor = context.Local;
}
return(SchemaValidationResults.Null);
}
/// <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 = context.Options.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 (context.Options.OutputFormat == SchemaValidationOutputFormat.Flag)
{
if (!valid)
{
Log.Schema(() => "Subschema failed; halting validation early");
break;
}
}
else if (reportChildErrors)
{
nestedResults.Add(localResults);
}
}
var results = new SchemaValidationResults(Name, context)
{
IsValid = valid
};
if (context.Options.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);
}
internal SchemaValidationResults(SchemaValidationContext context)
{
InstanceLocation = context.InstanceLocation.Clone();
if (context.BaseUri != null)
{
AbsoluteLocation = new Uri(context.BaseUri + context.BaseRelativeLocation.ToString(), UriKind.RelativeOrAbsolute);
}
RelativeLocation = context.RelativeLocation;
}
