[Fork] [Fork] https://stackoverflow.com/questions/79225896/custom-schema-validation-rules-with-jsonvalidator-executing-only-if-the-value | C# Online Compiler

[Fork] [Fork] https://stackoverflow.com/questions/79225896/custom-schema-validation-rules-with-jsonvalidator-executing-only-if-the-value by dbc_MinLength

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
using System.ComponentModel.DataAnnotations;
using System.Globalization;
using System.ComponentModel;


using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Newtonsoft.Json.Converters;
using Newtonsoft.Json.Serialization;	
using Newtonsoft.Json.Schema; //https://www.newtonsoft.com/jsonschema/help/html/Introduction.htm
using Newtonsoft.Json.Schema.Generation;

//using NUnit.Framework; // Throws NUnit.Framework.AssertionException

//https://stackoverflow.com/questions/79225896/custom-schema-validation-rules-with-jsonvalidator-executing-only-if-the-value

// A synthetic example:
// A rule that checks to see whether a given value is a string with a prefix specified by the value of the `"customNameRule"` property in the schema.

internal class CustomNameRuleValidator : JsonValidator
{
	const string CustomRulePropertyName = "customNameRule";

    public override bool CanValidate(JSchema schema) =>
		schema.ExtensionData.ContainsKey(CustomRulePropertyName);

    public override void Validate(JToken value, JsonValidatorContext context)
    {
		var customRuleValue = (string)context.Schema.ExtensionData[CustomRulePropertyName];
		if (value.Type != JTokenType.String || !((string)value).StartsWith(customRuleValue))
			context.RaiseError($"Property value {value.ToString(Formatting.None)} does not begin with {customRuleValue}");
    }
}

    class TestClass
    {
        public static void Test()
        {
			var customNameRuleSchemaJson = 
				"""
				{
					"description":"A configuration setting value",
					"type":"object",
					"properties":{
						"name":{
							"allOf":[
								// The standard validation rules
								{
									"type":"string",
								},
								// Your custom rule
								{
									"customNameRule" : "Setting",
								}
							]
						},
						"value":true
					},
					"required": ["name", "value"],
				}
				""";

			Test(customNameRuleSchemaJson);
		}
		
        public static void Test(string schemaJson)
        {

			var settingJson = @"{ 'name': 123 /* Was 'AA' */, 'value': 'XYZ' }";
			var setting = JToken.Parse(settingJson);

			var readerSettings = new JSchemaReaderSettings
			{
				Validators = [new CustomNameRuleValidator()]
			};

			var schema = JSchema.Parse(schemaJson, readerSettings);
			
			var isValid = setting.IsValid(schema, out IList<string> errors);

			Console.WriteLine(setting.ToString(Formatting.None));
			Console.WriteLine(schema);
			Console.WriteLine();

			Console.WriteLine(
				"IsValid={0}, Errors:\r\n{1}",
				isValid,
				errors != null ? string.Join("\r\n", errors) : string.Empty);

		}
	}

	public class Program
	{
		public static void Main()
		{
			Console.WriteLine("Environment version: {0} ({1}), {2}", System.Runtime.InteropServices.RuntimeInformation.FrameworkDescription , Environment.Version, Environment.OSVersion);
			Console.WriteLine("Json.NET version: " + typeof(JsonSerializer).Assembly.FullName);
			Console.WriteLine("Json.NET Schema version: " + typeof(Newtonsoft.Json.Schema.JSchema).Assembly.FullName);
			Console.WriteLine();

			try
			{
				TestClass.Test();
			}
			catch (Exception ex)
			{
				Console.WriteLine("Failed with unhandled exception: ");
				Console.WriteLine(ex);
				throw;
			}
		}
	}

#if false
Rather than using C# inheritance to combine a custom validation rule with built-in rules, you could use the [composition](https://json-schema.org/understanding-json-schema/reference/combining) operator [allOf](https://json-schema.org/understanding-json-schema/reference/combining#allOf) to append a Newtonsoft [custom validation rule](https://www.newtonsoft.com/jsonschema/help/html/CustomJsonValidator.htm) to some standard rules.  However, Json.NET's implementation **does not short-circuit** so the custom rule will be checked even if the preceding standard rules fail.

For instance, adapting an example from your [other question](https://stackoverflow.com/q/79226674/3744182), say you would like to validate a settings object that looks like:

```json
{"name":"AA","value":"XYZ"}
```

Against a schema like:

```json
{
  "description": "A configuration setting value",
  "type": "object",
  "properties": {
    "name": {
      "type": "string"
    },
    "value": true
  },
  "required": [ "name", "value" ]
}
```

And you would like to insert some custom rules for the value of the `"name"` property such as ensuring that the value of `"name"` starts with some prefix specified in the schema such as `"Setting"`<sup>[1]</sup>.  To do this, introduce the following `JsonValidator` which will validate that a value whose schema object includes a `"customNameRule"` property has the required prefix:

```
internal class CustomNameRuleValidator : JsonValidator
{
	const string CustomRulePropertyName = "customNameRule";

    public override bool CanValidate(JSchema schema) =>
		schema.ExtensionData.ContainsKey(CustomRulePropertyName);

    public override void Validate(JToken value, JsonValidatorContext context)
    {
		var customRuleValue = (string)context.Schema.ExtensionData[CustomRulePropertyName];
		if (value.Type != JTokenType.String || !((string)value).StartsWith(customRuleValue))
			context.RaiseError($"Property value {value.ToString(Formatting.None)} does not begin with {customRuleValue}");
    }
}
```

Then modify the schema by wrapping the existing schema for `"name"` in an `allOf` and appending a schema with the `"customNameRule"` property:

```json
{
   "description":"A configuration setting value",
   "type":"object",
   "properties":{
      "name":{
         "allOf":[
            // The standard validation rules
            {
               "type":"string"
            },
            // Your custom rule
            {
               "customNameRule":"Z"
            }
         ]
      },
      "value":true
   },
   "required":[ "name", "value" ]
}
```

And now you can validate against both the standard and custom rules by adding your `JsonValidator` to [`JSchemaReaderSettings.Validators`](https://www.newtonsoft.com/jsonschema/help/html/P_Newtonsoft_Json_Schema_JSchemaReaderSettings_Validators.htm):

	var readerSettings = new JSchemaReaderSettings
	{
		Validators = [new CustomNameRuleValidator()]
	};

	var schema = JSchema.Parse(schemaJson, readerSettings);
	var isValid = setting.IsValid(schema, out IList<string> errors);

Key points:

 1. You can use the [`JSchema.ExtensionData`](https://www.newtonsoft.com/jsonschema/help/html/P_Newtonsoft_Json_Schema_JSchema_ExtensionData.htm) dictionary to check for the presence and value of your custom properties.

 2. In [`CanValidate(JSchema schema)`](https://www.newtonsoft.com/jsonschema/help/html/M_Newtonsoft_Json_Schema_JsonValidator_CanValidate.htm) should return true only if the schema extension data contains your custom property. 

Demo fiddle [here](https://dotnetfiddle.net/5acq4i).

---
<sup>[1]</sup> I know this could be done using builtin functionality, it's a synthetic example since your question does not include a [minimal reproducible example](https://stackoverflow.com/help/minimal-reproducible-example)
#endif

​x
 
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
using System.ComponentModel.DataAnnotations;
using System.Globalization;
using System.ComponentModel;
​
​
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Newtonsoft.Json.Converters;
using Newtonsoft.Json.Serialization;    
using Newtonsoft.Json.Schema; //https://www.newtonsoft.com/jsonschema/help/html/Introduction.htm
using Newtonsoft.Json.Schema.Generation;
​
//using NUnit.Framework; // Throws NUnit.Framework.AssertionException
​
//https://stackoverflow.com/questions/79225896/custom-schema-validation-rules-with-jsonvalidator-executing-only-if-the-value
​
// A synthetic example:
// A rule that checks to see whether a given value is a string with a prefix specified by the value of the `"customNameRule"` property in the schema.
​
internal class CustomNameRuleValidator : JsonValidator
{
    const string CustomRulePropertyName = "customNameRule";
​
    public override bool CanValidate(JSchema schema) =>
        schema.ExtensionData.ContainsKey(CustomRulePropertyName);
​
    public override void Validate(JToken value, JsonValidatorContext context)
    {
        var customRuleValue = (string)context.Schema.ExtensionData[CustomRulePropertyName];
        if (value.Type != JTokenType.String || !((string)value).StartsWith(customRuleValue))
            context.RaiseError($"Property value {value.ToString(Formatting.None)} does not begin with {customRuleValue}");
    }
}
​
    class TestClass
    {
        public static void Test()
        {
            var customNameRuleSchemaJson = 
                """
                {
                    "description":"A configuration setting value",
                    "type":"object",
                    "properties":{
                        "name":{
                            "allOf":[
                                // The standard validation rules
                                {
                                    "type":"string",
                                },
                                // Your custom rule
                                {
                                    "customNameRule" : "Setting",
                                }
                            ]
                        },
                        "value":true
                    },
                    "required": ["name", "value"],
                }
                """;
​
            Test(customNameRuleSchemaJson);
        }
        
        public static void Test(string schemaJson)
        {
​
            var settingJson = @"{ 'name': 123 /* Was 'AA' */, 'value': 'XYZ' }";
            var setting = JToken.Parse(settingJson);
​
            var readerSettings = new JSchemaReaderSettings
            {
                Validators = [new CustomNameRuleValidator()]
            };
​
            var schema = JSchema.Parse(schemaJson, readerSettings);
            
            var isValid = setting.IsValid(schema, out IList<string> errors);
​
            Console.WriteLine(setting.ToString(Formatting.None));
            Console.WriteLine(schema);
            Console.WriteLine();
​
            Console.WriteLine(
                "IsValid={0}, Errors:\r\n{1}",
                isValid,
                errors != null ? string.Join("\r\n", errors) : string.Empty);
​
        }
    }
​
    public class Program
    {
        public static void Main()
        {
            Console.WriteLine("Environment version: {0} ({1}), {2}", System.Runtime.InteropServices.RuntimeInformation.FrameworkDescription , Environment.Version, Environment.OSVersion);
            Console.WriteLine("Json.NET version: " + typeof(JsonSerializer).Assembly.FullName);
            Console.WriteLine("Json.NET Schema version: " + typeof(Newtonsoft.Json.Schema.JSchema).Assembly.FullName);
            Console.WriteLine();
​
            try
            {
                TestClass.Test();
            }
            catch (Exception ex)
            {
                Console.WriteLine("Failed with unhandled exception: ");
                Console.WriteLine(ex);
                throw;
            }
        }
    }
​
#if false
Rather than using C# inheritance to combine a custom validation rule with built-in rules, you could use the [composition](https://json-schema.org/understanding-json-schema/reference/combining) operator [allOf](https://json-schema.org/understanding-json-schema/reference/combining#allOf) to append a Newtonsoft [custom validation rule](https://www.newtonsoft.com/jsonschema/help/html/CustomJsonValidator.htm) to some standard rules.  However, Json.NET's implementation **does not short-circuit** so the custom rule will be checked even if the preceding standard rules fail.
​
For instance, adapting an example from your [other question](https://stackoverflow.com/q/79226674/3744182), say you would like to validate a settings object that looks like:
​
```json
{"name":"AA","value":"XYZ"}
```
​
Against a schema like:
​
```json
{
  "description": "A configuration setting value",
  "type": "object",
  "properties": {
    "name": {
      "type": "string"
    },
    "value": true
  },
  "required": [ "name", "value" ]
}
```
​
And you would like to insert some custom rules for the value of the `"name"` property such as ensuring that the value of `"name"` starts with some prefix specified in the schema such as `"Setting"`<sup>[1]</sup>.  To do this, introduce the following `JsonValidator` which will validate that a value whose schema object includes a `"customNameRule"` property has the required prefix:
​
```
internal class CustomNameRuleValidator : JsonValidator
{
    const string CustomRulePropertyName = "customNameRule";
​
    public override bool CanValidate(JSchema schema) =>
        schema.ExtensionData.ContainsKey(CustomRulePropertyName);
​
    public override void Validate(JToken value, JsonValidatorContext context)
    {
        var customRuleValue = (string)context.Schema.ExtensionData[CustomRulePropertyName];
        if (value.Type != JTokenType.String || !((string)value).StartsWith(customRuleValue))
            context.RaiseError($"Property value {value.ToString(Formatting.None)} does not begin with {customRuleValue}");
    }
}
```
​
Then modify the schema by wrapping the existing schema for `"name"` in an `allOf` and appending a schema with the `"customNameRule"` property:
​
```json
{
   "description":"A configuration setting value",
   "type":"object",
   "properties":{
      "name":{
         "allOf":[
            // The standard validation rules
            {
               "type":"string"
            },
            // Your custom rule
            {
               "customNameRule":"Z"
            }
         ]
      },
      "value":true
   },
   "required":[ "name", "value" ]
}
```
​
And now you can validate against both the standard and custom rules by adding your `JsonValidator` to [`JSchemaReaderSettings.Validators`](https://www.newtonsoft.com/jsonschema/help/html/P_Newtonsoft_Json_Schema_JSchemaReaderSettings_Validators.htm):
​
    var readerSettings = new JSchemaReaderSettings
    {
        Validators = [new CustomNameRuleValidator()]
    };
​
    var schema = JSchema.Parse(schemaJson, readerSettings);
    var isValid = setting.IsValid(schema, out IList<string> errors);
​
Key points:
​
 1. You can use the [`JSchema.ExtensionData`](https://www.newtonsoft.com/jsonschema/help/html/P_Newtonsoft_Json_Schema_JSchema_ExtensionData.htm) dictionary to check for the presence and value of your custom properties.
​
 2. In [`CanValidate(JSchema schema)`](https://www.newtonsoft.com/jsonschema/help/html/M_Newtonsoft_Json_Schema_JsonValidator_CanValidate.htm) should return true only if the schema extension data contains your custom property. 
​
Demo fiddle [here](https://dotnetfiddle.net/5acq4i).
​
---
<sup>[1]</sup> I know this could be done using builtin functionality, it's a synthetic example since your question does not include a [minimal reproducible example](https://stackoverflow.com/help/minimal-reproducible-example)
#endif
​
​
​

View IL Code