public void CreateProject(string json)
{
JsonTextReader reader = new JsonTextReader(new StringReader(json));
JSchemaValidatingReader jSchemaReader = new JSchemaValidatingReader(reader);
jSchemaReader.Schema = JSchema.Parse(RequestSchema.Json);
IList <string> errorMessages = new List <string>();
jSchemaReader.ValidationEventHandler += (o, a) => errorMessages.Add(a.Message);
JsonSerializer serializer = new JsonSerializer();
ProjectDefinition projectDefinition = serializer.Deserialize <ProjectDefinition>(jSchemaReader);
if (errorMessages.Count > 0)
{
foreach (var eventMessage in errorMessages)
{
Console.WriteLine(eventMessage);
}
Console.ReadKey();
return;
}
SignalRScraperActorSystem
.ActorReferences
.SignalRBridge
.Tell(new CreateProjectMessage(projectDefinition));
}
public void UnevaluatedItems_SchemaEvaluatedOnInvalidItem_ErrorDisplayed()
{
string schemaJson = @"{
""type"": ""array"",
""unevaluatedItems"": {
""type"": ""string"",
""minLength"": 3
}
}";
string json = @"[ ""foo"", ""fo"" ]";
SchemaValidationEventArgs validationEventArgs = null;
JSchemaValidatingReader reader = new JSchemaValidatingReader(new JsonTextReader(new StringReader(json)));
reader.ValidationEventHandler += (sender, args) => { validationEventArgs = args; };
reader.Schema = JSchema.Parse(schemaJson);
while (reader.Read())
{
}
Assert.IsNotNull(validationEventArgs);
Assert.AreEqual("Item at index 1 has not been successfully evaluated and the schema does not allow unevaluated items.", validationEventArgs.ValidationError.Message);
Assert.AreEqual(ErrorType.UnevaluatedItems, validationEventArgs.ValidationError.ErrorType);
Assert.AreEqual("String 'fo' is less than minimum length of 3.", validationEventArgs.ValidationError.ChildErrors[0].Message);
}
PingResponse parsePing(string pingResponse)
{
string trimmed = pingResponse.Replace("\n", "").Trim();
if (trimmed.Length == 0)
{
return(null);
}
JsonTextReader reader = new JsonTextReader(new StringReader(trimmed));
// { "time":385000, "command":"p"}
JSchemaValidatingReader validatingReader = new JSchemaValidatingReader(reader);
validatingReader.Schema = JSchema.Parse(@"{
'type': 'object',
'properties': {
'command': {'type':'string'},
'time': {'type':'integer'}
}
}");
JsonSerializer serializer = new JsonSerializer();
return(serializer.Deserialize <PingResponse>(validatingReader));
}
public void UnevaluatedItems_Schema_NoMatch()
{
string schemaJson = @"{
""type"": ""array"",
""unevaluatedItems"": {
""type"": ""string"",
""minLength"": 3
}
}";
string json = @"[ ""fo"" ]";
SchemaValidationEventArgs validationEventArgs = null;
JSchemaValidatingReader reader = new JSchemaValidatingReader(new JsonTextReader(new StringReader(json)));
reader.ValidationEventHandler += (sender, args) => { validationEventArgs = args; };
reader.Schema = JSchema.Parse(schemaJson);
while (reader.Read())
{
}
Assert.IsNotNull(validationEventArgs);
Assert.AreEqual("Item at index 0 has not been successfully evaluated and the schema does not allow unevaluated items. Path '', line 1, position 8.", validationEventArgs.Message);
Assert.AreEqual(ErrorType.UnevaluatedItems, validationEventArgs.ValidationError.ErrorType);
}
public void Test_Complex()
{
var schema = JSchema.Parse(@"{
allOf: [
{type:'object',properties: { a: {type: 'integer'}, b: {type:'integer'}}},
{type:'object',properties: { a: {type: 'integer'}, b: {type:'integer'}}}
]
}");
var content = @"{a: 1, b: 1} {'a': true, b: 1}";
using (var reader = new JsonTextReader(new StringReader(content))
{
SupportMultipleContent = true
})
using (var vreader = new JSchemaValidatingReader(reader)
{
Schema = schema, SupportMultipleContent = true
})
{
var count = 0;
vreader.ValidationEventHandler += (o, a) => { count++; System.Console.WriteLine(a.Message); };
while (vreader.Read())
{
System.Console.WriteLine(vreader.TokenType);
}
System.Console.WriteLine("Done, {0} error(s)", count);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="JsonStoreReader"/> class.
/// </summary>
/// <param name="name">The name of the application that generated the persisted files, or the root name of the files</param>
/// <param name="path">The directory in which the main persisted file resides or will reside, or null to create a volatile data store</param>
/// <param name="dataSchemaString">JSON schema used to validate data stream.</param>
/// <param name="extension">The extension for the underlying file.</param>
/// <param name="preloadSchemas">Dictionary of URis to JSON schemas to preload before validating any JSON. Would likely include schemas references by the catalog and data schemas.</param>
public JsonStoreReader(string name, string path, string dataSchemaString, string extension = DefaultExtension, IDictionary <Uri, string> preloadSchemas = null)
: base(dataSchemaString, extension, preloadSchemas)
{
this.Name = name;
this.Path = StoreCommon.GetPathToLatestVersion(name, path);
// load catalog
string metadataPath = System.IO.Path.Combine(this.Path, StoreCommon.GetCatalogFileName(this.Name) + this.Extension);
using (var file = File.OpenText(metadataPath))
using (var reader = new JsonTextReader(file))
using (var validatingReader = new JSchemaValidatingReader(reader))
{
validatingReader.Schema = this.CatalogSchema;
validatingReader.ValidationEventHandler += (s, e) => throw new InvalidDataException(e.Message);
this.catalog = this.Serializer.Deserialize <List <JsonStreamMetadata> >(validatingReader);
}
// compute originating time interval
this.originatingTimeInterval = TimeInterval.Empty;
foreach (var metadata in this.catalog)
{
var metadataTimeInterval = new TimeInterval(metadata.FirstMessageOriginatingTime, metadata.LastMessageOriginatingTime);
this.originatingTimeInterval = TimeInterval.Coverage(new TimeInterval[] { this.originatingTimeInterval, metadataTimeInterval });
}
}
/// <summary>
/// Deserializes object from json
/// </summary>
/// <param name="path"></param>
/// <param name="jschem">Schema object to check if deserialized object corresponds to it</param>
private void deserializeFromJSON(string path, JSchema jschem)
{
using (StreamReader file = File.OpenText(path))
{
using (JsonTextReader reader = new JsonTextReader(file))
{
//Validates if JSON File is correct!
JSchemaValidatingReader validatingReader = new JSchemaValidatingReader(reader);
validatingReader.Schema = jschem;
JsonSerializer serializer = new JsonSerializer();
try
{
settings = serializer.Deserialize <RecordingSettings>(validatingReader);
updateGUIValues();
System.Windows.MessageBox.Show($"Settings file succesfully loaded!", _progname);
}
catch (Exception ex) when(ex is JSchemaValidationException || ex is JsonReaderException)
{
System.Windows.MessageBox.Show($"ERROR: File does not correspond to {_progname} settings format!", _progname);
}
finally
{
validatingReader.Close();
}
}
}
}
public static List <String> jsonSchema(string inputPath, string schemaPath)
{
using (StreamReader schemaFile = File.OpenText(schemaPath))
{
using (StreamReader inputFile = File.OpenText(inputPath))
{
using (JsonTextReader schemaReader = new JsonTextReader(schemaFile))
{
using (JsonTextReader inputReader = new JsonTextReader(inputFile))
{
JSchema schema = JSchema.Load(schemaReader);
using (JSchemaValidatingReader validatingReader = new JSchemaValidatingReader(inputReader))
{
validatingReader.Schema = schema;
List <string> errorList = new List <string>();
validatingReader.ValidationEventHandler += (o, a) =>
{
errorList.Add(a.Message);
};
JsonSerializer serializer = new JsonSerializer();
// json will be validated without loading the entire document into memory
while (validatingReader.Read())
{
}
return(errorList);
}
}
}
}
}
}
/// <inheritdoc />
public override void Dispose()
{
this.streamReader?.Dispose();
this.streamReader = null;
this.jsonReader = null;
this.validatingReader = null;
}
public static T LoadObject <T>(string filename, bool validate)
{
var data = GenericIOManager.LoadFileAsString(filename);
T loadedObject;
if (validate)
{
var schema = GenericIOManager.LoadFileAsString(filename);
var dataReader = new JsonTextReader(new StringReader(data));
var validatingReader = new JSchemaValidatingReader(dataReader);
validatingReader.Schema = JSchema.Parse(schema);
IList <string> messages = new List <string>();
validatingReader.ValidationEventHandler += (o, a) => messages.Add(a.Message);
foreach (var message in messages)
{
Console.WriteLine("ERROR VALIDATING JSON " + filename + ": " + message);
}
var serializer = new JsonSerializer();
loadedObject = serializer.Deserialize <T>(validatingReader);
}
else
{
loadedObject = JsonConvert.DeserializeObject <T>(data);
}
return(loadedObject);
}
public async Task RegisterProjectMessage(string json)
{
JSchemaValidatingReader jSchemaReader = new JSchemaValidatingReader(new JsonTextReader(new StringReader(json)))
{
Schema = JSchema.Parse(File.ReadAllText("requestSchema.json"))
};
IList <string> errorMessages = new List <string>();
jSchemaReader.ValidationEventHandler += (o, a) => errorMessages.Add(a.Message);
JsonSerializer serializer = new JsonSerializer();
PortiaRequest request = serializer.Deserialize <PortiaRequest>(jSchemaReader);
if (errorMessages.Count > 0)
{
throw new HubException("The json provided was invalid");
}
if (ProjectCrawlerById.ContainsKey(request.Id))
{
throw new HubException("Project already registered");
}
ProjectCrawler newProjectCrawler = new ProjectCrawler(request);
if (ProjectCrawlerById.TryAdd(newProjectCrawler.portiaRequest.Id, newProjectCrawler) == false)
{
throw new HubException("Project registration failed");
}
await Clients.All.SendAsync("RegisterProjectReply", newProjectCrawler.portiaRequest);
}
public bool TryLoad(string path, out DBConfig dBConfig, out string error)
{
error = null;
dBConfig = null;
try
{
if (!File.Exists(path))
{
throw new Exception($"file not found : {path}");
}
// Read File
JsonTextReader reader = new JsonTextReader(new StringReader(File.ReadAllText(path)));
// JSON Schema
JSchemaValidatingReader validatingReader = new JSchemaValidatingReader(reader);
JSchemaGenerator generator = new JSchemaGenerator();
validatingReader.Schema = generator.Generate(typeof(DBConfig));
// Deserialize
JsonSerializer serializer = new JsonSerializer();
dBConfig = serializer.Deserialize <DBConfig>(validatingReader);
return(dBConfig != null);
}
catch (Exception ex)
{
error = $"error occured when load the configuration of the database with the reason {ex.Message}";
return(false);
}
}
public void UnevaluatedItems_ConditionalSchema_NoMatch()
{
string schemaJson = @"{
""type"": ""array"",
""items"": [
{ ""type"": ""string"" }
],
""allOf"": [
{
""items"": [
true,
{ ""allOf"": [ false ] }
]
}
],
""unevaluatedItems"": false
}";
string json = @"[""foo"", 42]";
SchemaValidationEventArgs validationEventArgs = null;
JSchemaValidatingReader reader = new JSchemaValidatingReader(new JsonTextReader(new StringReader(json)));
reader.ValidationEventHandler += (sender, args) => { validationEventArgs = args; };
reader.Schema = JSchema.Parse(schemaJson);
while (reader.Read())
{
}
Assert.IsNotNull(validationEventArgs);
Assert.AreEqual("Item at index 1 has not been successfully evaluated and the schema does not allow unevaluated items. Path '', line 1, position 11.", validationEventArgs.Message);
}
public void UnevaluatedProperties_SchemaEvaluatedOnInvalidProperty_ErrorDisplayed()
{
string schemaJson = @"{
""type"": ""object"",
""properties"": {
""foo"": { ""type"": ""string"" }
},
""unevaluatedProperties"": {
""type"": ""string"",
""maxLength"": 2
}
}";
string json = @"{
""foo"": ""foo"",
""bar"": ""bar""
}";
SchemaValidationEventArgs validationEventArgs = null;
JSchemaValidatingReader reader = new JSchemaValidatingReader(new JsonTextReader(new StringReader(json)));
reader.ValidationEventHandler += (sender, args) => { validationEventArgs = args; };
reader.Schema = JSchema.Parse(schemaJson);
while (reader.Read())
{
}
Assert.IsNotNull(validationEventArgs);
Assert.AreEqual("Property 'bar' has not been successfully evaluated and the schema does not allow unevaluated properties.", validationEventArgs.ValidationError.Message);
Assert.AreEqual(ErrorType.UnevaluatedProperties, validationEventArgs.ValidationError.ErrorType);
Assert.AreEqual("String 'bar' exceeds maximum length of 2.", validationEventArgs.ValidationError.ChildErrors[0].Message);
}
/// <summary>
/// Validate the received JSON string against the our object structure. If it's valid
/// then create and populate the <see cref="Movie"/> and <see cref="Role"/> objects.
/// </summary>
/// <param name="jsonString">Received JSON string.</param>
/// <exception cref="System.Exception">Thrown if the response is invalid JSON or mandatory data is missing.</exception>
/// <returns>List of <see cref="Movie"/> objects.</returns>
private List <Movie> ValidateAndParseResponse(string jsonString)
{
var generator = new JSchemaGenerator();
var parsedSchema = generator.Generate(typeof(List <Movie>));
var reader = new JsonTextReader(new StringReader(jsonString));
var validatingReader = new JSchemaValidatingReader(reader)
{
Schema = parsedSchema
};
var messages = new List <string>();
validatingReader.ValidationEventHandler += (o, a) => messages.Add(a.Message);
try
{
var serializer = new JsonSerializer();
var movies = serializer.Deserialize <List <Movie> >(validatingReader);
if (messages.Count > 0)
{
var exception = new Exception("Invalid Response : Missing Mandatory Data");
exception.Data.Add("ValidationErrors", messages);
throw exception;
}
return(movies);
}
catch (JsonReaderException ex)
{
throw new Exception("Invalid Response : Invalid Json", ex);
}
}
ResponseRoot parseResponse(string stateResponse)
{
string trimmed = stateResponse.Replace("\n", "").Trim();
if (trimmed.Length == 0)
{
return(null);
}
JsonTextReader reader = new JsonTextReader(new StringReader(trimmed));
// { "c":0, "t":385000, "s":[{ "p":0, "v":1, "tc":42498, "tp":37195},{ "p":1, "v":1, "tc":25053, "tp":17403},{ "p":2, "v":1, "tc":21906, "tp":19430},{ "p":3, "v":1, "tc":1, "tp":0}]}
JSchemaValidatingReader validatingReader = new JSchemaValidatingReader(reader);
validatingReader.Schema = JSchema.Parse(@"{
'type': 'object',
'properties': {
'c': {'type':'integer'},
't': {'type':'integer'},
's': {
'type': 'array',
'items': {'type':'object'},
'properties': {
'p': {'type':'integer'},
'v': {'type':'integer'},
'tc': {'type':'integer'},
'tp': {'type':'integer'}
}
}
}
}");
JsonSerializer serializer = new JsonSerializer();
return(serializer.Deserialize <ResponseRoot>(validatingReader));
}
public void UnevaluatedItems_ConditionalSchema_Match()
{
string schemaJson = @"{
""type"": ""array"",
""items"": [
{ ""type"": ""string"" }
],
""allOf"": [
{
""items"": [
true,
{ ""allOf"": [ true ] }
]
}
],
""unevaluatedItems"": false
}";
string json = @"[""foo"", 42]";
SchemaValidationEventArgs validationEventArgs = null;
JSchemaValidatingReader reader = new JSchemaValidatingReader(new JsonTextReader(new StringReader(json)));
reader.ValidationEventHandler += (sender, args) => { validationEventArgs = args; };
reader.Schema = JSchema.Parse(schemaJson);
while (reader.Read())
{
}
Assert.IsNull(validationEventArgs);
}
private static void ValidateModelSchema()
{
Console.WriteLine("Validating the generated schema file");
JkumSchemaValidator validator = new JkumSchemaValidator();
string path = Path.Combine(debugFolder, generatedSchema);
string jsonString = File.ReadAllText(simpleTestFile);
JsonTextReader reader = new JsonTextReader(new StringReader(jsonString));
string readContent = reader.ToString();
JSchemaValidatingReader validatingReader = new JSchemaValidatingReader(reader);
string currentFolder = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
string schemaFile = Path.Combine(currentFolder, "Schema", "jkum-schema-1.0.json");
string jsonSchema = File.ReadAllText(schemaFile);
validatingReader.Schema = JSchema.Parse(jsonSchema, new JSchemaReaderSettings());
JsonSerializer serializer = new JsonSerializer();
Jkum jkum = serializer.Deserialize <Jkum>(validatingReader);
bool success = validator.IsValid(jsonString);
if (success)
{
Console.WriteLine("Validation succeeded!");
}
else
{
Console.WriteLine("Validation failed...");
}
}
public void UnevaluatedItems_Schema_Match()
{
string schemaJson = @"{
""type"": ""array"",
""unevaluatedItems"": {
""type"": ""string"",
""minLength"": 3
}
}";
string json = @"[ ""foo"" ]";
SchemaValidationEventArgs validationEventArgs = null;
JSchemaValidatingReader reader = new JSchemaValidatingReader(new JsonTextReader(new StringReader(json)));
reader.ValidationEventHandler += (sender, args) => { validationEventArgs = args; };
reader.Schema = JSchema.Parse(schemaJson);
while (reader.Read())
{
}
Assert.IsNull(validationEventArgs);
}
public void UnevaluatedProperties_NestedAdditionalProperties_Match()
{
string schemaJson = @"{
""type"": ""object"",
""properties"": {
""foo"": { ""type"": ""string"" }
},
""allOf"": [
{
""additionalProperties"": true
}
],
""unevaluatedProperties"": false
}";
string json = @"{
""foo"": ""foo"",
""bar"": ""bar""
}";
SchemaValidationEventArgs validationEventArgs = null;
JSchemaValidatingReader reader = new JSchemaValidatingReader(new JsonTextReader(new StringReader(json)));
reader.ValidationEventHandler += (sender, args) => { validationEventArgs = args; };
reader.Schema = JSchema.Parse(schemaJson);
while (reader.Read())
{
}
Assert.IsNull(validationEventArgs);
}
public static List <CLRCIDefinition> StripLogsFromFile(string inputPath)
{
Debug.Assert(File.Exists(inputPath));
var fullDefs = new List <HelixTestDefinition>();
var strippedDefs = new List <CLRCIDefinition>();
JSchemaGenerator jsonGenerator = new JSchemaGenerator();
JSchema testDefinitionSchema = jsonGenerator.Generate(typeof(IList <HelixTestDefinition>));
var validationMessages = new List <string>();
using (var sr = new StreamReader(inputPath))
using (var jsonReader = new JsonTextReader(sr))
using (var jsonValidationReader = new JSchemaValidatingReader(jsonReader))
{
// Create schema validator
jsonValidationReader.Schema = testDefinitionSchema;
jsonValidationReader.ValidationEventHandler += (o, a) => validationMessages.Add(a.Message);
JsonSerializer serializer = new JsonSerializer();
fullDefs = serializer.Deserialize <List <HelixTestDefinition> >(jsonValidationReader);
}
return(MinifyDefList(fullDefs));
}
public void ReadSpecTest(SchemaSpecTest schemaSpecTest)
{
Console.WriteLine("Running reader JSON Schema {0} test {1}: {2}", schemaSpecTest.Version, schemaSpecTest.TestNumber, schemaSpecTest);
IList <string> errorMessages = new List <string>();
JSchemaPreloadedResolver resolver = GetResolver();
JSchema s = JSchema.Load(schemaSpecTest.Schema.CreateReader(), resolver);
JsonReader jsonReader = schemaSpecTest.Data.CreateReader();
using (JSchemaValidatingReader reader = new JSchemaValidatingReader(jsonReader))
{
reader.Schema = s;
reader.ValidationEventHandler += (sender, args) => errorMessages.Add(args.Message);
while (reader.Read())
{
}
}
bool isValid = (errorMessages.Count == 0);
Assert.AreEqual(schemaSpecTest.IsValid, isValid, schemaSpecTest.TestCaseDescription + " - " + schemaSpecTest.TestDescription + " - errors: " + StringHelpers.Join(", ", errorMessages));
}
public void UnevaluatedProperties_NotAllowed_NoMatch()
{
string schemaJson = @"{
""type"": ""object"",
""properties"": {
""foo"": { ""type"": ""string"" }
},
""unevaluatedProperties"": false
}";
string json = "{'bar':true}";
SchemaValidationEventArgs validationEventArgs = null;
JSchemaValidatingReader reader = new JSchemaValidatingReader(new JsonTextReader(new StringReader(json)));
reader.ValidationEventHandler += (sender, args) => { validationEventArgs = args; };
reader.Schema = JSchema.Parse(schemaJson);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.StartObject, reader.TokenType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.Boolean, reader.TokenType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.EndObject, reader.TokenType);
Assert.IsNotNull(validationEventArgs);
Assert.AreEqual("Property 'bar' has not been successfully evaluated and the schema does not allow unevaluated properties. Path '', line 1, position 12.", validationEventArgs.Message);
Assert.AreEqual(ErrorType.UnevaluatedProperties, validationEventArgs.ValidationError.ErrorType);
}
public static MappedDataSet LoadValidatedFromFile(string filePath)
{
// setup schema source
Assembly assembly = typeof(DPMLib.ValidationResult).GetTypeInfo().Assembly;
string[] names = assembly.GetManifestResourceNames();
Stream resource = assembly.GetManifestResourceStream("dp-metalib.net.schemas.dp-metadata.json");
// setup readers
using (TextReader schemaFile = new StreamReader(resource, Encoding.UTF8))
using (JsonTextReader schemaReader = new JsonTextReader(schemaFile))
using (StreamReader mappingFile = File.OpenText(filePath))
using (JsonTextReader jsonReader = new JsonTextReader(mappingFile))
{
// load schema
JSchema jsonSchema = JSchema.Load(schemaReader);
// configure validator
JSchemaValidatingReader validatingReader = new JSchemaValidatingReader(jsonReader);
validatingReader.Schema = jsonSchema;
// IList<string> messages = new List<string>();
// validatingReader.ValidationEventHandler += (o, a) => messages.Add(a.Message);
// load and validate metadata file
JsonSerializer serializer = new JsonSerializer();
List <MappedDataSet> loaded = serializer.Deserialize <List <MappedDataSet> >(validatingReader);
return(loaded[0]);
}
}
public Task StartAsync(CancellationToken cancellationToken)
{
using Stream schemaContents = GetType().Assembly.GetManifestResourceStream(GetType(), "roles.schema.json");
using Stream rolesContents = _fileProvider.GetFileInfo("roles.json").CreateReadStream();
var jsonSerializer = JsonSerializer.Create(new JsonSerializerSettings {
Converters = { new StringEnumConverter(new CamelCaseNamingStrategy()) }
});
using var schemaReader = new JsonTextReader(new StreamReader(schemaContents));
using var validatingReader = new JSchemaValidatingReader(new JsonTextReader(new StreamReader(rolesContents)))
{
Schema = JSchema.Load(schemaReader),
};
validatingReader.ValidationEventHandler += (sender, args) =>
throw new InvalidDefinitionException(string.Format(Resources.ErrorValidatingRoles, args.Message));
RolesContract roleContract = jsonSerializer.Deserialize <RolesContract>(validatingReader);
_authorizationConfiguration.Roles = roleContract.Roles.Select(RoleContractToRole).ToArray();
// validate that names are all unique
foreach (IGrouping <string, Role> grouping in _authorizationConfiguration.Roles.GroupBy(r => r.Name))
{
if (grouping.Count() > 1)
{
throw new InvalidDefinitionException(
string.Format(CultureInfo.CurrentCulture, Resources.DuplicateRoleNames, grouping.Count(), grouping.Key));
}
}
return(Task.CompletedTask);
}
public void ValidateStream()
{
#region ValidateStream
string schemaJson = @"{
'description': 'A person',
'type': 'object',
'properties': {
'name': {'type': 'string'},
'hobbies': {
'type': 'array',
'items': {'type': 'string'}
}
}
}";
JSchema schema = JSchema.Parse(schemaJson);
using (StreamReader s = File.OpenText(@"c:\bigdata.json"))
using (JSchemaValidatingReader reader = new JSchemaValidatingReader(new JsonTextReader(s)))
{
// assign schema and setup event handler
reader.Schema = schema;
reader.ValidationEventHandler += (sender, args) => { Console.WriteLine(args.Message); };
// bigdata.json will be validated without loading the entire document into memory
while (reader.Read())
{
}
}
#endregion
}
public void Run()
{
JSchema schema = generator.Generate(typeof(TestClass));
JsonTextReader reader = new JsonTextReader(new System.IO.StringReader("{field: 2}"));
JSchemaValidatingReader validatingReader = new JSchemaValidatingReader(reader);
validatingReader.Schema = schema;
TestClass res = serializer.Deserialize <TestClass>(validatingReader);
}
internal object ReadRequest(HttpContext context, CrpcVersionRegistration version)
{
if (version.RequestType == null)
{
return(null);
}
if ((context.Request.ContentLength ?? 0) == 0)
{
throw new CrpcException("invalid_body");
}
using (var sr = new HttpRequestStreamReader(context.Request.Body, Encoding.UTF8))
using (var jtr = new JsonTextReader(sr))
using (var jsv = new JSchemaValidatingReader(jtr))
{
var validationErrors = new List <CrpcException>();
jsv.Schema = version.Schema;
jsv.ValidationEventHandler += (o, a) =>
{
validationErrors.Add(new CrpcException("validation_error", new Dictionary <string, object>
{
{ "message", a.ValidationError.Message },
{ "value", a.ValidationError.Value },
{ "path", a.ValidationError.Path },
{ "location", $"line {a.ValidationError.LineNumber}, position {a.ValidationError.LinePosition}" },
}));
};
object deserialized = null;
try
{
deserialized = _jsonDeserializeMethod
.MakeGenericMethod(version.RequestType)
.Invoke(_jsonSerializer, new object[] { jsv });
}
catch (TargetInvocationException ex)
{
var innerEx = ex.InnerException;
// If the exception isn't a serialization exception, throw
if (!(innerEx is JsonSerializationException))
{
throw innerEx;
}
}
// Handle errors
if (validationErrors.Count() > 0)
{
throw new CrpcException(CrpcCodes.ValidationFailed, null, validationErrors.AsEnumerable());
}
return(deserialized);
}
}
private static void ValidateAgainstSchema()
{
JsonTextReader jsonReader = new JsonTextReader(File.OpenText("/Users/simonnattress/git/tichu/src/score_converter/test_data/allgames.converted.json"));
JSchemaValidatingReader validatingReader = new JSchemaValidatingReader(jsonReader);
validatingReader.Schema = JSchema.Load(new JsonTextReader(File.OpenText("/Users/simonnattress/git/tichu/src/score_converter/tichu_schema.json")));
JsonSerializer serializer = new JsonSerializer();
Scores scores = serializer.Deserialize <Scores>(validatingReader);
}
private IList <string> SubscribeValidators(JSchemaValidatingReader validatingReader)
{
JSchemaGenerator generator = new JSchemaGenerator();
JSchema schema = generator.Generate(typeof(ApartmentItem[]));
IList <string> messages = new List <string>();
validatingReader.Schema = schema;
validatingReader.ValidationEventHandler += (o, a) => messages.Add(a.Message);
return(messages);
}
private void ReaderValidation()
{
JsonTextReader reader = new JsonTextReader(new StringReader(Json));
JSchemaValidatingReader validatingReader = new JSchemaValidatingReader(reader);
validatingReader.Schema = Schema;
while (validatingReader.Read())
{
}
}
public void Example()
{
#region Usage
string schemaJson = @"{
'description': 'A person',
'type': 'object',
'properties': {
'name': {'type':'string'},
'hobbies': {
'type': 'array',
'items': {'type':'string'}
}
}
}";
string json = @"{
'name': 'James',
'hobbies': ['.NET', 'Blogging', 'Reading', 'Xbox', 'LOLCATS']
}";
JsonTextReader reader = new JsonTextReader(new StringReader(json));
JSchemaValidatingReader validatingReader = new JSchemaValidatingReader(reader);
validatingReader.Schema = JSchema.Parse(schemaJson);
IList<string> messages = new List<string>();
validatingReader.ValidationEventHandler += (o, a) => messages.Add(a.Message);
JsonSerializer serializer = new JsonSerializer();
Person p = serializer.Deserialize<Person>(validatingReader);
Console.WriteLine(p.Name);
// James
bool isValid = (messages.Count == 0);
Console.WriteLine(isValid);
// true
#endregion
Assert.IsTrue(isValid);
}
public void ReaderPerformance()
{
string json = @"[
{
""id"": 2,
""name"": ""An ice sculpture"",
""price"": 12.50,
""tags"": [""cold"", ""ice""],
""dimensions"": {
""length"": 7.0,
""width"": 12.0,
""height"": 9.5
},
""warehouseLocation"": {
""latitude"": -78.75,
""longitude"": 20.4
}
},
{
""id"": 3,
""name"": ""A blue mouse"",
""price"": 25.50,
""dimensions"": {
""length"": 3.1,
""width"": 1.0,
""height"": 1.0
},
""warehouseLocation"": {
""latitude"": 54.4,
""longitude"": -32.7
}
}
]";
JSchema schema = JSchema.Parse(@"{
""$schema"": ""http://json-schema.org/draft-04/schema#"",
""title"": ""Product set"",
""type"": ""array"",
""items"": {
""title"": ""Product"",
""type"": ""object"",
""properties"": {
""id"": {
""description"": ""The unique identifier for a product"",
""type"": ""number""
},
""name"": {
""type"": ""string""
},
""price"": {
""type"": ""number"",
""minimum"": 0,
""exclusiveMinimum"": true
},
""tags"": {
""type"": ""array"",
""items"": {
""type"": ""string""
},
""minItems"": 1,
""uniqueItems"": true
},
""dimensions"": {
""type"": ""object"",
""properties"": {
""length"": {""type"": ""number""},
""width"": {""type"": ""number""},
""height"": {""type"": ""number""}
},
""required"": [""length"", ""width"", ""height""]
},
""warehouseLocation"": {
""description"": ""A geographical coordinate"",
""type"": ""object"",
""properties"": {
""latitude"": { ""type"": ""number"" },
""longitude"": { ""type"": ""number"" }
}
}
},
""required"": [""id"", ""name"", ""price""]
}
}");
using (var tester = new PerformanceTester("Reader"))
{
for (int i = 0; i < 1000; i++)
{
JsonTextReader reader = new JsonTextReader(new StringReader(json));
JSchemaValidatingReader validatingReader = new JSchemaValidatingReader(reader);
validatingReader.Schema = schema;
while (validatingReader.Read())
{
}
}
}
}
