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));
}
}
