private Uri ResolveSchemaReference(JSchema schema) { Uri resolvedReference = null; foreach (JSchema s in _schemaStack.Reverse()) { Uri part = s.Id; if (part != null) { if (resolvedReference == null) { resolvedReference = part; } else { resolvedReference = SchemaDiscovery.ResolveSchemaId(resolvedReference, part); } } } try { resolvedReference = SchemaDiscovery.ResolveSchemaId(resolvedReference, schema.Reference); } catch (Exception ex) { string message = "Error resolving schema reference '{0}' in the scope '{1}'. The resolved reference must be a valid URI.".FormatWith(CultureInfo.InvariantCulture, schema.Reference, resolvedReference); throw JSchemaReaderException.Create(schema, _baseUri, schema.Path, message, ex); } return(resolvedReference); }
/// <summary> /// Finds a subschema using the given schema reference. /// </summary> /// <param name="reference">The schema reference used to get the subschema.</param> /// <param name="rootSchema">The root schema to resolve the subschema from.</param> /// <returns>The matching subschema.</returns> public virtual JSchema GetSubschema(SchemaReference reference, JSchema rootSchema) { if (reference.SubschemaId == null) { return(rootSchema); } Uri rootSchemaId = reference.BaseUri; Uri subschemaId = reference.SubschemaId; JSchemaReader resolverSchemaReader = new JSchemaReader(new JSchemaReaderSettings { Resolver = this, BaseUri = rootSchema.BaseUri }); resolverSchemaReader.RootSchema = rootSchema; JSchema subSchema = null; SchemaDiscovery.FindSchema(s => subSchema = s, rootSchema, rootSchemaId, subschemaId, resolverSchemaReader); if (subSchema != null) { resolverSchemaReader.ResolveDeferedSchemas(); return(subSchema); } return(null); }
private void LoadAndSetSchema(JsonReader reader, Action <JSchema> setSchema, bool resolveDeferedImmediately = false) { JSchema schema = new JSchema(); _schemaStack.Push(schema); ReadSchema(reader, schema); //schema.Reference; if (schema.Reference != null) { Uri resolvedReference = null; foreach (JSchema s in _schemaStack.Reverse()) { Uri part = s.Id; if (part != null) { if (resolvedReference == null) { resolvedReference = part; } else { resolvedReference = SchemaDiscovery.ResolveSchemaId(resolvedReference, part); } } } resolvedReference = SchemaDiscovery.ResolveSchemaId(resolvedReference, schema.Reference); JSchema resolvedSchema = _resolver.GetSchema(resolvedReference); if (resolvedSchema != null) { schema = resolvedSchema; } else { DeferedSchema deferedSchema = new DeferedSchema(resolvedReference, schema, setSchema); _deferedSchemas.Add(deferedSchema); } } setSchema(schema); _schemaStack.Pop(); }
private void ResolveDeferedSchema(DeferedSchema deferedSchema) { Uri reference = deferedSchema.ResolvedReference; bool found = SchemaDiscovery.FindSchema(s => { // additional json copied to referenced schema // kind of hacky if (deferedSchema.ReferenceSchema._extensionData != null) { foreach (KeyValuePair <string, JToken> keyValuePair in deferedSchema.ReferenceSchema._extensionData.ToList()) { s.ExtensionData[keyValuePair.Key] = keyValuePair.Value; } } deferedSchema.SetResolvedSchema(s); }, RootSchema, RootSchema.Id, reference, this, ref _schemaDiscovery); if (found) { return; } JSchema resolvedSchema; try { resolvedSchema = ResolvedSchema(deferedSchema.ReferenceSchema.Reference, deferedSchema.ResolvedReference); } catch (Exception ex) { throw JSchemaReaderException.Create(deferedSchema.ReferenceSchema, _baseUri, deferedSchema.ReferenceSchema.Path, "Error when resolving schema reference '{0}'.".FormatWith(CultureInfo.InvariantCulture, deferedSchema.ReferenceSchema.Reference), ex); } if (resolvedSchema != null) { deferedSchema.SetResolvedSchema(resolvedSchema); return; } throw JSchemaReaderException.Create(deferedSchema.ReferenceSchema, _baseUri, deferedSchema.ReferenceSchema.Path, "Could not resolve schema reference '{0}'.".FormatWith(CultureInfo.InvariantCulture, deferedSchema.ResolvedReference)); }
/// <summary> /// Gets the schema for a given URI. /// </summary> /// <param name="uri">The schema URI to resolve.</param> /// <returns>The resolved schema.</returns> public override JSchema GetSchema(Uri uri) { foreach (KnownSchema knownSchema in _knownSchemas) { string uriText = uri.ToString(); string knownText = (knownSchema.Id != null) ? knownSchema.Id.ToString() : string.Empty; if (uriText == knownText) { return(knownSchema.Schema); } if (uriText.StartsWith(knownText, StringComparison.Ordinal)) { string relative = uriText.Substring(knownText.Length); Uri relativeUri = new Uri(relative, UriKind.RelativeOrAbsolute); JSchemaReader resolverSchemaReader = new JSchemaReader(this) { RootSchema = knownSchema.Schema }; JSchema subSchema = null; SchemaDiscovery.FindSchema(s => subSchema = s, knownSchema.Schema, knownSchema.Id, relativeUri, resolverSchemaReader); if (subSchema != null) { resolverSchemaReader.ResolveDeferedSchemas(); return(subSchema); } } } if (_resolver != null) { return(_resolver.GetSchema(uri)); } return(null); }
private Uri ResolveBaseUri(ResolveSchemaContext context, out string fragment) { Uri baseUri = context.ResolverBaseUri; Uri uri = context.ResolvedSchemaId; if (!uri.IsAbsoluteUri && uri.OriginalString.StartsWith("#", StringComparison.OrdinalIgnoreCase)) { fragment = uri.OriginalString; return(baseUri); } if (baseUri == null || (!baseUri.IsAbsoluteUri && baseUri.OriginalString.Length == 0)) { return(RemoveFragment(uri, out fragment)); } uri = RemoveFragment(uri, out fragment); uri = SchemaDiscovery.ResolveSchemaId(baseUri, uri); return(uri); }
/// <summary> /// Finds a subschema using the given schema reference. /// </summary> /// <param name="reference">The schema reference used to get the subschema.</param> /// <param name="rootSchema">The root schema to resolve the subschema from.</param> /// <returns>The matching subschema.</returns> public virtual JSchema?GetSubschema(SchemaReference reference, JSchema rootSchema) { if (reference.SubschemaId == null) { return(rootSchema); } Uri?rootSchemaId = reference.BaseUri; Uri subschemaId = reference.SubschemaId; JSchemaReader?resolverSchemaReader = rootSchema.InternalReader; if (resolverSchemaReader == null) { resolverSchemaReader = new JSchemaReader(new JSchemaReaderSettings { Resolver = this, BaseUri = rootSchema.BaseUri }); resolverSchemaReader.RootSchema = rootSchema; } JSchema?subSchema = null; Uri?dynamicScope = null; // Might be a problem. Should dynamic scope be passed in? SchemaDiscovery.FindSchema(s => subSchema = s, rootSchema, rootSchemaId, subschemaId, subschemaId, dynamicScope, resolverSchemaReader, ref resolverSchemaReader._schemaDiscovery); if (subSchema != null) { resolverSchemaReader.ResolveDeferedSchemas(); resolverSchemaReader.RaiseValidationErrors(); return(subSchema); } return(null); }
private Uri ResolveSchemaReference(JSchema schema) { Uri resolvedReference = null; foreach (JSchema s in _schemaStack.Reverse()) { Uri part = s.Id; if (part != null) { if (resolvedReference == null) { resolvedReference = part; } else { resolvedReference = SchemaDiscovery.ResolveSchemaId(resolvedReference, part); } } } resolvedReference = SchemaDiscovery.ResolveSchemaId(resolvedReference, schema.Reference); return(resolvedReference); }
private void ResolveDeferedSchema(DeferedSchema deferedSchema) { Uri reference = deferedSchema.ResolvedReference; bool found = SchemaDiscovery.FindSchema(s => { // additional json copied to referenced schema // kind of hacky if (deferedSchema.ReferenceSchema._extensionData != null) { foreach (KeyValuePair <string, JToken> keyValuePair in deferedSchema.ReferenceSchema._extensionData.ToList()) { s.ExtensionData[keyValuePair.Key] = keyValuePair.Value; } } deferedSchema.SetResolvedSchema(s); }, RootSchema, RootSchema.Id, reference, this); if (!found) { throw new JsonException("Could not resolve schema reference '{0}'.".FormatWith(CultureInfo.InvariantCulture, deferedSchema.ResolvedReference)); } }