private void Push(JsonSchema value) { _currentSchema = value; _stack.Add(value); _resolver.LoadedSchemas.Add(value); _documentSchemas.Add(value.Location, value); }
public TypeSchema(Type type, JsonSchema schema) { ValidationUtils.ArgumentNotNull(type, "type"); ValidationUtils.ArgumentNotNull(schema, "schema"); Type = type; Schema = schema; }
private JsonSchema Pop() { JsonSchema poppedSchema = _currentSchema; _stack.RemoveAt(_stack.Count - 1); _currentSchema = _stack.LastOrDefault(); return poppedSchema; }
/// <summary> /// Determines whether the <see cref="JToken"/> is valid. /// </summary> /// <param name="source">The source <see cref="JToken"/> to test.</param> /// <param name="schema">The schema to test with.</param> /// <param name="errorMessages">When this method returns, contains any error messages generated while validating. </param> /// <returns> /// <c>true</c> if the specified <see cref="JToken"/> is valid; otherwise, <c>false</c>. /// </returns> public static bool IsValid(this JToken source, JsonSchema schema, out IList<string> errorMessages) { IList<string> errors = new List<string>(); source.Validate(schema, (sender, args) => errors.Add(args.Message)); errorMessages = errors; return (errorMessages.Count == 0); }
private void ReferenceOrWriteSchema(JsonSchema schema) { if (schema.Id != null && _resolver.GetSchema(schema.Id) != null) { _writer.WriteStartObject(); _writer.WritePropertyName(JsonTypeReflector.RefPropertyName); _writer.WriteValue(schema.Id); _writer.WriteEndObject(); } else { WriteSchema(schema, false); } }
/// <summary> /// Determines whether the <see cref="JToken"/> is valid. /// </summary> /// <param name="source">The source <see cref="JToken"/> to test.</param> /// <param name="schema">The schema to test with.</param> /// <returns> /// <c>true</c> if the specified <see cref="JToken"/> is valid; otherwise, <c>false</c>. /// </returns> public static bool IsValid(this JToken source, JsonSchema schema) { bool valid = true; source.Validate(schema, (sender, args) => { valid = false; }); return valid; }
private void Push(TypeSchema typeSchema) { _currentSchema = typeSchema.Schema; _stack.Add(typeSchema); _resolver.LoadedSchemas.Add(typeSchema.Schema); }
private void WriteItems(JsonSchema schema) { if (schema.Items == null && !schema.PositionalItemsValidation) return; _writer.WritePropertyName(JsonSchemaConstants.ItemsPropertyName); if (!schema.PositionalItemsValidation) { if (schema.Items != null && schema.Items.Count > 0) { ReferenceOrWriteSchema(schema.Items[0]); } else { _writer.WriteStartObject(); _writer.WriteEndObject(); } return; } _writer.WriteStartArray(); if (schema.Items != null) { foreach (JsonSchema itemSchema in schema.Items) { ReferenceOrWriteSchema(itemSchema); } } _writer.WriteEndArray(); }
private TypeSchema Pop() { TypeSchema popped = _stack[_stack.Count - 1]; _stack.RemoveAt(_stack.Count - 1); TypeSchema newValue = _stack.LastOrDefault(); if (newValue != null) { _currentSchema = newValue.Schema; } else { _currentSchema = null; } return popped; }
private IDictionary<string, JsonSchema> ProcessDependencies(JToken token) { IDictionary<string, JsonSchema> dependencies = new Dictionary<string, JsonSchema>(); foreach (JProperty dependencyToken in token) { if (dependencies.ContainsKey(dependencyToken.Name)) throw new JsonException("Dependency {0} has already been defined in schema.".FormatWith(CultureInfo.InvariantCulture, dependencyToken.Name)); switch (dependencyToken.Value.Type) { case JTokenType.String: JsonSchema singleProperty = new JsonSchema { Type = JsonSchemaType.Object }; singleProperty.Required = new List<string> { (string)dependencyToken.Value }; singleProperty.Properties = new Dictionary<string, JsonSchema>(); singleProperty.Properties.Add((string)dependencyToken.Value, new JsonSchema() { Type = JsonSchemaType.Any }); dependencies.Add(dependencyToken.Name, singleProperty); break; case JTokenType.Array: JsonSchema multipleProperty = new JsonSchema { Type = JsonSchemaType.Object }; multipleProperty.Required = new List<string>(); multipleProperty.Properties = new Dictionary<string, JsonSchema>(); foreach (JToken schemaToken in dependencyToken.Value) { multipleProperty.Required.Add((string)schemaToken); multipleProperty.Properties.Add((string)schemaToken, new JsonSchema() { Type = JsonSchemaType.Any }); } dependencies.Add(dependencyToken.Name, multipleProperty); break; case JTokenType.Object: dependencies.Add(dependencyToken.Name, BuildSchema(dependencyToken.Value)); break; default: throw JsonException.Create(token, token.Path, "Expected string, array or JSON schema object, got {0}.".FormatWith(CultureInfo.InvariantCulture, token.Type)); } } return dependencies; }
/// <summary> /// Validates the specified <see cref="JToken"/>. /// </summary> /// <param name="source">The source <see cref="JToken"/> to test.</param> /// <param name="schema">The schema to test with.</param> public static void Validate(this JToken source, JsonSchema schema) { source.Validate(schema, null); }
/// <summary> /// Validates the specified <see cref="JToken"/>. /// </summary> /// <param name="source">The source <see cref="JToken"/> to test.</param> /// <param name="schema">The schema to test with.</param> /// <param name="validationEventHandler">The validation event handler.</param> public static void Validate(this JToken source, JsonSchema schema, ValidationEventHandler validationEventHandler) { ValidationUtils.ArgumentNotNull(source, "source"); ValidationUtils.ArgumentNotNull(schema, "schema"); using (JsonValidatingReader reader = new JsonValidatingReader(source.CreateReader())) { reader.Schema = schema; if (validationEventHandler != null) reader.ValidationEventHandler += validationEventHandler; while (reader.Read()) { } } }
private JsonSchema BuildSchema(JToken token) { JObject schemaObject = token as JObject; if (schemaObject == null) throw JsonException.Create(token, token.Path, "Expected object while parsing schema object, got {0}.".FormatWith(CultureInfo.InvariantCulture, token.Type)); // Check for change of scope before processing JToken idToken; bool hasPushedScope = false; if (schemaObject.TryGetValue(JsonSchemaConstants.IdPropertyName, out idToken)) { string subScope = (string)idToken; Uri scopeUri; hasPushedScope = true; if (string.IsNullOrEmpty(_currentResolutionScope)) { PushScope(subScope); } else { scopeUri = new Uri(_currentResolutionScope, UriKind.RelativeOrAbsolute); Uri subScopeUri = new Uri(subScope, UriKind.RelativeOrAbsolute); if (subScopeUri.IsAbsoluteUri) { PushScope(subScopeUri.ToString()); } else { Uri combinedUri = new Uri(scopeUri, subScope); PushScope(combinedUri.ToString()); } } } JToken referenceToken; if (schemaObject.TryGetValue(JsonTypeReflector.RefPropertyName, out referenceToken)) { JsonSchema deferredSchema = new JsonSchema(); deferredSchema.DeferredReference = (string)referenceToken; deferredSchema.ResolutionScope = _currentResolutionScope; return deferredSchema; } string location = token.Path.Replace(".", "/").Replace("[", "/").Replace("]", string.Empty); if (!string.IsNullOrEmpty(location)) location = "/" + location; location = _currentResolutionScope + "#" + location; JsonSchema existingSchema; if (_documentSchemas.TryGetValue(location, out existingSchema)) return existingSchema; Push(new JsonSchema { Location = location }); ProcessSchemaProperties(schemaObject); if (hasPushedScope) PopScope(); return Pop(); }
public void WriteSchema(JsonSchema schema) { ValidationUtils.ArgumentNotNull(schema, "schema"); WriteSchema(schema, true); }
private bool IsPropertyDefinied(JsonSchema schema, string propertyName) { if (schema.Properties != null && schema.Properties.ContainsKey(propertyName)) return true; if (schema.PatternProperties != null) { foreach (string pattern in schema.PatternProperties.Keys) { if (Regex.IsMatch(propertyName, pattern)) return true; } } return false; }
private void AddConditionalSchemas(IList<SchemaReport> currentSchemas, JsonSchema schema, SchemaReport parentResultSet) { AddConditionalSchemas(currentSchemas, schema.AllOf, SchemaConditionType.AllOf, parentResultSet); AddConditionalSchemas(currentSchemas, schema.OneOf, SchemaConditionType.OneOf, parentResultSet); AddConditionalSchemas(currentSchemas, schema.AnyOf, SchemaConditionType.AnyOf, parentResultSet); if (schema.NotOf != null) { AddConditionalSchemas(currentSchemas, new List<JsonSchema> { schema.NotOf }, SchemaConditionType.NotOf, parentResultSet); } if (schema.Dependencies != null) { foreach (KeyValuePair<string, JsonSchema> dep in schema.Dependencies) { SchemaReport childResultSet = new SchemaReport(dep.Value, new List<JsonSchemaException>(), SchemaConditionType.Dependency, parentResultSet, dep.Key); currentSchemas.Add(childResultSet); parentResultSet.SubResults.Add(childResultSet); AddConditionalSchemas(currentSchemas, dep.Value, childResultSet); } } }
public SchemaReport(JsonSchema schema, IList<JsonSchemaException> messages, SchemaConditionType type, SchemaReport parent, string conditionalPropertyName) { Schema = schema; Messages = messages; ConditionType = type; ConditionalPropertyName = conditionalPropertyName; SubResults = new List<SchemaReport>(); if (parent != null && parent.Messages != null) Parent = parent; }
public void WriteSchema(JsonSchema schema, bool isRoot) { if (!_resolver.LoadedSchemas.Contains(schema)) _resolver.LoadedSchemas.Add(schema); _writer.WriteStartObject(); WritePropertyIfNotNull(_writer, JsonSchemaConstants.IdPropertyName, schema.Id); if (isRoot) WritePropertyIfNotNull(_writer, JsonSchemaConstants.SchemaTypePropertyName, JsonSchemaConstants.SchemaTypePropertyValue); WritePropertyIfNotNull(_writer, JsonSchemaConstants.TitlePropertyName, schema.Title); WritePropertyIfNotNull(_writer, JsonSchemaConstants.DescriptionPropertyName, schema.Description); WritePropertyIfNotNull(_writer, JsonSchemaConstants.ReadOnlyPropertyName, schema.ReadOnly); WritePropertyIfNotNull(_writer, JsonSchemaConstants.HiddenPropertyName, schema.Hidden); WritePropertyIfNotNull(_writer, JsonSchemaConstants.TransientPropertyName, schema.Transient); if (schema.Type != null) WriteType(JsonSchemaConstants.TypePropertyName, _writer, schema.Type.Value); if (!schema.AllowAdditionalProperties) { _writer.WritePropertyName(JsonSchemaConstants.AdditionalPropertiesPropertyName); _writer.WriteValue(schema.AllowAdditionalProperties); } else { if (schema.AdditionalProperties != null) { _writer.WritePropertyName(JsonSchemaConstants.AdditionalPropertiesPropertyName); ReferenceOrWriteSchema(schema.AdditionalProperties); } } if (!schema.AllowAdditionalItems) { _writer.WritePropertyName(JsonSchemaConstants.AdditionalItemsPropertyName); _writer.WriteValue(schema.AllowAdditionalItems); } else { if (schema.AdditionalItems != null) { _writer.WritePropertyName(JsonSchemaConstants.AdditionalItemsPropertyName); ReferenceOrWriteSchema(schema.AdditionalItems); } } WriteSchemaDictionaryIfNotNull(_writer, JsonSchemaConstants.PropertiesPropertyName, schema.Properties); if (schema.Required != null && schema.Required.Count > 0) { _writer.WritePropertyName(JsonSchemaConstants.RequiredPropertyName); _writer.WriteStartArray(); foreach (string propertyName in schema.Required) { _writer.WriteValue(propertyName); } _writer.WriteEndArray(); } WriteSchemaDictionaryIfNotNull(_writer, JsonSchemaConstants.PatternPropertiesPropertyName, schema.PatternProperties); WriteItems(schema); WritePropertyIfNotNull(_writer, JsonSchemaConstants.MinimumPropertyName, schema.Minimum); WritePropertyIfNotNull(_writer, JsonSchemaConstants.MaximumPropertyName, schema.Maximum); WritePropertyIfNotNull(_writer, JsonSchemaConstants.MinimumPropertiesPropertyName, schema.MinimumProperties); WritePropertyIfNotNull(_writer, JsonSchemaConstants.MaximumPropertiesPropertyName, schema.MaximumProperties); WritePropertyIfNotNull(_writer, JsonSchemaConstants.ExclusiveMinimumPropertyName, schema.ExclusiveMinimum); WritePropertyIfNotNull(_writer, JsonSchemaConstants.ExclusiveMaximumPropertyName, schema.ExclusiveMaximum); WritePropertyIfNotNull(_writer, JsonSchemaConstants.MinimumLengthPropertyName, schema.MinimumLength); WritePropertyIfNotNull(_writer, JsonSchemaConstants.MaximumLengthPropertyName, schema.MaximumLength); WritePropertyIfNotNull(_writer, JsonSchemaConstants.MinimumItemsPropertyName, schema.MinimumItems); WritePropertyIfNotNull(_writer, JsonSchemaConstants.MaximumItemsPropertyName, schema.MaximumItems); WritePropertyIfNotNull(_writer, JsonSchemaConstants.MultipleOfPropertyName, schema.MultipleOf); WritePropertyIfNotNull(_writer, JsonSchemaConstants.FormatPropertyName, schema.Format); WritePropertyIfNotNull(_writer, JsonSchemaConstants.PatternPropertyName, schema.Pattern); if (schema.Enum != null) { _writer.WritePropertyName(JsonSchemaConstants.EnumPropertyName); _writer.WriteStartArray(); foreach (JToken token in schema.Enum) { token.WriteTo(_writer); } _writer.WriteEndArray(); } if (schema.Default != null) { _writer.WritePropertyName(JsonSchemaConstants.DefaultPropertyName); schema.Default.WriteTo(_writer); } WriteSchemaDictionaryIfNotNull(_writer, JsonSchemaConstants.DependenciesPropertyName, schema.Dependencies); if (schema.AnyOf != null && schema.AnyOf.Count > 0) { _writer.WritePropertyName(JsonSchemaConstants.AnyOfPropertyName); _writer.WriteStartArray(); foreach (JsonSchema jsonSchema in schema.AnyOf) { ReferenceOrWriteSchema(jsonSchema); } _writer.WriteEndArray(); } if (schema.AllOf != null && schema.AllOf.Count > 0) { _writer.WritePropertyName(JsonSchemaConstants.AllOfPropertyName); _writer.WriteStartArray(); foreach (JsonSchema jsonSchema in schema.AllOf) { ReferenceOrWriteSchema(jsonSchema); } _writer.WriteEndArray(); } if (schema.OneOf != null && schema.OneOf.Count > 0) { _writer.WritePropertyName(JsonSchemaConstants.OneOfPropertyName); _writer.WriteStartArray(); foreach (JsonSchema jsonSchema in schema.OneOf) { ReferenceOrWriteSchema(jsonSchema); } _writer.WriteEndArray(); } if (schema.NotOf != null) { _writer.WritePropertyName(JsonSchemaConstants.NotOfPropertyName); ReferenceOrWriteSchema(schema.NotOf); } if (schema.Links != null && schema.Links.Count > 0) { _writer.WritePropertyName(JsonSchemaConstants.LinksPropertyName); _writer.WriteStartArray(); foreach (JsonSchemaLink link in schema.Links) { _writer.WriteStartObject(); WritePropertyIfNotNull(_writer, JsonSchemaConstants.TitlePropertyName, link.Title); WritePropertyIfNotNull(_writer, JsonSchemaConstants.RelationPropertyName, link.Relation); WritePropertyIfNotNull(_writer, JsonSchemaConstants.HrefPropertyName, link.Href); if (link.TargetSchema != null) { _writer.WritePropertyName(JsonSchemaConstants.TargetSchemaPropertyName); ReferenceOrWriteSchema(link.TargetSchema); } WritePropertyIfNotNull(_writer, JsonSchemaConstants.MediaTypePropertyName, link.MediaType); if (!JsonSchemaConstants.DefaultRequestMethod.Equals(link.Method, System.StringComparison.OrdinalIgnoreCase)) WritePropertyIfNotNull(_writer, JsonSchemaConstants.MethodPropertyName, link.Method); if (!JsonSchemaConstants.JsonContentType.Equals(link.EncodingType, System.StringComparison.OrdinalIgnoreCase)) WritePropertyIfNotNull(_writer, JsonSchemaConstants.EncodingTypePropertyName, link.EncodingType); if (link.Schema != null) { _writer.WritePropertyName(JsonSchemaConstants.SchemaPropertyName); ReferenceOrWriteSchema(link.Schema); } _writer.WriteEndObject(); } _writer.WriteEndArray(); } if (!JsonSchemaConstants.JsonPointerProtocol.Equals(schema.FragmentResolution, System.StringComparison.OrdinalIgnoreCase)) WritePropertyIfNotNull(_writer, JsonSchemaConstants.FragmentResolutionPropertyName, schema.FragmentResolution); if (schema.Media != null) { _writer.WritePropertyName(JsonSchemaConstants.MediaPropertyName); _writer.WriteStartObject(); WritePropertyIfNotNull(_writer, JsonSchemaConstants.BinaryEncodingPropertyName, schema.Media.BinaryEncoding); WritePropertyIfNotNull(_writer, JsonSchemaConstants.TypePropertyName, schema.Media.Type); _writer.WriteEndObject(); } WritePropertyIfNotNull(_writer, JsonSchemaConstants.PathStartPropertyName, schema.PathStart); _writer.WriteEndObject(); }
private JsonSchema ResolveReferences(JsonSchema schema) { while (schema.DeferredReference != null) { string schemaUri; string idPath; bool isJsonPointer; PrepareLocationReference(schema.ResolutionScope, schema.DeferredReference, out schemaUri, out idPath, out isJsonPointer); JsonSchema resolvedSchema; if (isJsonPointer) { string reference = schemaUri + UnescapeReference(idPath); resolvedSchema = _resolver.GetSchema(reference); if (resolvedSchema == null) { resolvedSchema = FindLocationReference(schemaUri, idPath); } } else { resolvedSchema = _resolver.GetSchema(idPath); } if (resolvedSchema == null) throw new JsonException("Could not resolve schema reference '{0}'.".FormatWith(CultureInfo.InvariantCulture, schema.DeferredReference)); schema = resolvedSchema; } if (schema.ReferencesResolved) return schema; schema.ReferencesResolved = true; if (schema.AnyOf != null) { for (int i = 0; i < schema.AnyOf.Count; i++) { schema.AnyOf[i] = ResolveReferences(schema.AnyOf[i]); } } if (schema.AllOf != null) { for (int i = 0; i < schema.AllOf.Count; i++) { schema.AllOf[i] = ResolveReferences(schema.AllOf[i]); } } if (schema.OneOf != null) { for (int i = 0; i < schema.OneOf.Count; i++) { schema.OneOf[i] = ResolveReferences(schema.OneOf[i]); } } if (schema.NotOf != null) schema.NotOf = ResolveReferences(schema.NotOf); if (schema.Items != null) { for (int i = 0; i < schema.Items.Count; i++) { schema.Items[i] = ResolveReferences(schema.Items[i]); } } if (schema.AdditionalItems != null) schema.AdditionalItems = ResolveReferences(schema.AdditionalItems); if (schema.PatternProperties != null) { foreach (KeyValuePair<string, JsonSchema> patternProperty in schema.PatternProperties.ToList()) { schema.PatternProperties[patternProperty.Key] = ResolveReferences(patternProperty.Value); } } if (schema.Properties != null) { foreach (KeyValuePair<string, JsonSchema> property in schema.Properties.ToList()) { schema.Properties[property.Key] = ResolveReferences(property.Value); } } if (schema.AdditionalProperties != null) schema.AdditionalProperties = ResolveReferences(schema.AdditionalProperties); return schema; }