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()) { } } } }