/// <summary> /// Verifies Json literal content /// </summary> /// <param name="content">the Json literal to be verified</param> /// <param name="result">output paramter of test result</param> /// <returns>true if verification passes; false otherwiser</returns> public bool Verify(string content, out TestResult result) { using (var stringReader = new StringReader(content)) { using (JsonTextReader rdr = new JsonTextReader(stringReader)) { using (JsonValidatingReader vr = new JsonValidatingReader(rdr)) { vr.Schema = this.schema; try { while (vr.Read()) { // Ignore } result = new TestResult(); return true; } catch (JsonSchemaException jex) { result = new TestResult() { LineNumberInError = jex.LineNumber, ErrorDetail = jex.Message }; return false; } } } } }
private void ValidateFloat(JsonSchemaModel schema) { if (schema == null) { return; } if (!this.TestType(schema, JsonSchemaType.Float)) { return; } this.ValidateInEnumAndNotDisallowed(schema); double num = Convert.ToDouble(this._reader.Value, CultureInfo.InvariantCulture); if (schema.Maximum.HasValue) { double?maximum = schema.Maximum; if ((!maximum.HasValue ? false : num > maximum.GetValueOrDefault())) { this.RaiseError("Float {0} exceeds maximum value of {1}.".FormatWith(CultureInfo.InvariantCulture, new object[] { JsonConvert.ToString(num), schema.Maximum }), schema); } if (schema.ExclusiveMaximum) { double?nullable = schema.Maximum; if ((num != nullable.GetValueOrDefault() ? false : nullable.HasValue)) { this.RaiseError("Float {0} equals maximum value of {1} and exclusive maximum is true.".FormatWith(CultureInfo.InvariantCulture, new object[] { JsonConvert.ToString(num), schema.Maximum }), schema); } } } if (schema.Minimum.HasValue) { double?minimum = schema.Minimum; if ((!minimum.HasValue ? false : num < minimum.GetValueOrDefault())) { this.RaiseError("Float {0} is less than minimum value of {1}.".FormatWith(CultureInfo.InvariantCulture, new object[] { JsonConvert.ToString(num), schema.Minimum }), schema); } if (schema.ExclusiveMinimum) { double?minimum1 = schema.Minimum; if ((num != minimum1.GetValueOrDefault() ? false : minimum1.HasValue)) { this.RaiseError("Float {0} equals minimum value of {1} and exclusive minimum is true.".FormatWith(CultureInfo.InvariantCulture, new object[] { JsonConvert.ToString(num), schema.Minimum }), schema); } } } if (schema.DivisibleBy.HasValue && !JsonValidatingReader.IsZero(num % schema.DivisibleBy.Value)) { this.RaiseError("Float {0} is not evenly divisible by {1}.".FormatWith(CultureInfo.InvariantCulture, new object[] { JsonConvert.ToString(num), schema.DivisibleBy }), schema); } }
public static void Validate(this JToken source, JsonSchema schema, ValidationEventHandler validationEventHandler) { ValidationUtils.ArgumentNotNull((object) source, "source"); ValidationUtils.ArgumentNotNull((object) schema, "schema"); using (JsonValidatingReader validatingReader = new JsonValidatingReader(source.CreateReader())) { validatingReader.Schema = schema; if (validationEventHandler != null) validatingReader.ValidationEventHandler += validationEventHandler; do ; while (validatingReader.Read()); } }
public async Task<HttpResponseMessage> PostData(HttpRequestMessage request) { try { var jsonString = await request.Content.ReadAsStringAsync(); //Validate JSON with JsonValidatingReader JsonTextReader reader = new JsonTextReader(new StringReader(jsonString)); JsonValidatingReader validatingReader = new JsonValidatingReader(reader); validatingReader.Schema = JsonSchema.Parse(Helper.Instance().jsonRequest); IList<string> messages = new List<string>(); validatingReader.ValidationEventHandler += (o, a) => messages.Add(a.Message); JsonSerializer serializer = new JsonSerializer(); //DeserializeObject RequestData requestData = serializer.Deserialize<RequestData>(validatingReader); //Compute responseData var responseDatas = Helper.Instance().GetResponseData(requestData); // HttpResponseMessage response = new HttpResponseMessage(); response.StatusCode = HttpStatusCode.OK; string jsonResponse = JsonConvert.SerializeObject(responseDatas); response.Content = new StringContent(jsonResponse, Encoding.UTF8, "application/json"); response.Headers.CacheControl = new CacheControlHeaderValue() { MaxAge = TimeSpan.FromMinutes(20) }; return response; } catch { var myError = new { //error = ex.Message error = "Could not decode request: JSON parsing failed" }; return Request.CreateResponse(HttpStatusCode.BadRequest, myError); } }
private void ValidateInteger(JsonSchemaModel schema) { double?divisibleBy; bool bigInteger; if (schema == null) { return; } if (!this.TestType(schema, JsonSchemaType.Integer)) { return; } this.ValidateNotDisallowed(schema); object value = this._reader.Value; if (schema.Maximum.HasValue) { if (JValue.Compare(JTokenType.Integer, value, schema.Maximum) > 0) { this.RaiseError("Integer {0} exceeds maximum value of {1}.".FormatWith(CultureInfo.InvariantCulture, value, schema.Maximum), schema); } if (schema.ExclusiveMaximum && JValue.Compare(JTokenType.Integer, value, schema.Maximum) == 0) { this.RaiseError("Integer {0} equals maximum value of {1} and exclusive maximum is true.".FormatWith(CultureInfo.InvariantCulture, value, schema.Maximum), schema); } } if (schema.Minimum.HasValue) { if (JValue.Compare(JTokenType.Integer, value, schema.Minimum) < 0) { this.RaiseError("Integer {0} is less than minimum value of {1}.".FormatWith(CultureInfo.InvariantCulture, value, schema.Minimum), schema); } if (schema.ExclusiveMinimum && JValue.Compare(JTokenType.Integer, value, schema.Minimum) == 0) { this.RaiseError("Integer {0} equals minimum value of {1} and exclusive minimum is true.".FormatWith(CultureInfo.InvariantCulture, value, schema.Minimum), schema); } } if (schema.DivisibleBy.HasValue) { object obj = value; object obj1 = obj; if (!(obj is BigInteger)) { double num = (double)Convert.ToInt64(value, CultureInfo.InvariantCulture); divisibleBy = schema.DivisibleBy; bigInteger = !JsonValidatingReader.IsZero(num % divisibleBy.GetValueOrDefault()); } else { BigInteger bigInteger1 = (BigInteger)obj1; if (Math.Abs(schema.DivisibleBy.Value - Math.Truncate(schema.DivisibleBy.Value)).Equals(0)) { divisibleBy = schema.DivisibleBy; bigInteger = (bigInteger1 % new BigInteger(divisibleBy.Value)) != 0L; } else { bigInteger = bigInteger1 != 0L; } } if (bigInteger) { this.RaiseError("Integer {0} is not evenly divisible by {1}.".FormatWith(CultureInfo.InvariantCulture, JsonConvert.ToString(value), schema.DivisibleBy), schema); } } }
private void Push(JsonValidatingReader.SchemaScope scope) { this._stack.Push(scope); this._currentScope = scope; }
public Manifest GetManifestFromRemote() { FileVersionInfo fvi = FileVersionInfo.GetVersionInfo(Assembly.GetExecutingAssembly().Location); string jsonStr = wc.DownloadString("catflap.json?catflap=" + fvi.FileVersion); JsonTextReader reader = new JsonTextReader(new StringReader(jsonStr)); JsonValidatingReader validatingReader = new JsonValidatingReader(reader); validatingReader.Schema = Manifest.Schema; // validatingReader.Schema.AllowAdditionalItems = false; // validatingReader.Schema.AllowAdditionalProperties = false; IList<string> messages = new List<string>(); validatingReader.ValidationEventHandler += (o, a) => messages.Add(a.Message); JsonSerializer serializer = new JsonSerializer(); Manifest mf = serializer.Deserialize<Manifest>(validatingReader); if (messages.Count > 0) throw new ValidationException("manifesto não é válido: " + string.Join("\n", messages)); mf.Validate(RootPath); return mf; }
private void ValidateFloat(JsonSchemaModel schema) { if (schema == null) { return; } if (!this.TestType(schema, JsonSchemaType.Float)) { return; } this.ValidateInEnumAndNotDisallowed(schema); double num = Convert.ToDouble(this._reader.Value, CultureInfo.get_InvariantCulture()); if (schema.Maximum.get_HasValue()) { double?maximum = schema.Maximum; if (maximum.get_HasValue() && num > maximum.get_Value()) { this.RaiseError("Float {0} exceeds maximum value of {1}.".FormatWith(CultureInfo.get_InvariantCulture(), new object[] { JsonConvert.ToString(num), schema.Maximum }), schema); } if (schema.ExclusiveMaximum) { double arg_B7_0 = num; double?maximum2 = schema.Maximum; if (arg_B7_0 == maximum2.GetValueOrDefault() && maximum2.get_HasValue()) { this.RaiseError("Float {0} equals maximum value of {1} and exclusive maximum is true.".FormatWith(CultureInfo.get_InvariantCulture(), new object[] { JsonConvert.ToString(num), schema.Maximum }), schema); } } } if (schema.Minimum.get_HasValue()) { double?minimum = schema.Minimum; if (minimum.get_HasValue() && num < minimum.get_Value()) { this.RaiseError("Float {0} is less than minimum value of {1}.".FormatWith(CultureInfo.get_InvariantCulture(), new object[] { JsonConvert.ToString(num), schema.Minimum }), schema); } if (schema.ExclusiveMinimum) { double arg_183_0 = num; double?minimum2 = schema.Minimum; if (arg_183_0 == minimum2.GetValueOrDefault() && minimum2.get_HasValue()) { this.RaiseError("Float {0} equals minimum value of {1} and exclusive minimum is true.".FormatWith(CultureInfo.get_InvariantCulture(), new object[] { JsonConvert.ToString(num), schema.Minimum }), schema); } } } if (schema.DivisibleBy.get_HasValue() && !JsonValidatingReader.IsZero(num % schema.DivisibleBy.get_Value())) { this.RaiseError("Float {0} is not evenly divisible by {1}.".FormatWith(CultureInfo.get_InvariantCulture(), new object[] { JsonConvert.ToString(num), schema.DivisibleBy }), schema); } }
private void ValidateInteger(JsonSchemaModel schema) { if (schema == null) { return; } if (!this.TestType(schema, JsonSchemaType.Integer)) { return; } this.ValidateInEnumAndNotDisallowed(schema); long num = Convert.ToInt64(this._reader.Value, CultureInfo.InvariantCulture); if (schema.Maximum != null) { double?maximum = schema.Maximum; if ((double)num > maximum) { this.RaiseError("Integer {0} exceeds maximum value of {1}.".FormatWith(CultureInfo.InvariantCulture, new object[] { num, schema.Maximum }), schema); } if (schema.ExclusiveMaximum && (double)num == schema.Maximum) { this.RaiseError("Integer {0} equals maximum value of {1} and exclusive maximum is true.".FormatWith(CultureInfo.InvariantCulture, new object[] { num, schema.Maximum }), schema); } } if (schema.Minimum != null) { double?minimum = schema.Minimum; if ((double)num < minimum) { this.RaiseError("Integer {0} is less than minimum value of {1}.".FormatWith(CultureInfo.InvariantCulture, new object[] { num, schema.Minimum }), schema); } if (schema.ExclusiveMinimum && (double)num == schema.Minimum) { this.RaiseError("Integer {0} equals minimum value of {1} and exclusive minimum is true.".FormatWith(CultureInfo.InvariantCulture, new object[] { num, schema.Minimum }), schema); } } if (schema.DivisibleBy != null && !JsonValidatingReader.IsZero((double)num % schema.DivisibleBy.Value)) { this.RaiseError("Integer {0} is not evenly divisible by {1}.".FormatWith(CultureInfo.InvariantCulture, new object[] { JsonConvert.ToString(num), schema.DivisibleBy }), schema); } }
private void ValidateInteger(JsonSchemaModel schema) { if (schema == null) { return; } if (!this.TestType(schema, JsonSchemaType.Integer)) { return; } this.ValidateNotDisallowed(schema); object value = this._reader.Value; if (schema.Maximum.HasValue) { if (JValue.Compare(JTokenType.Integer, value, schema.Maximum) > 0) { this.RaiseError("Integer {0} exceeds maximum value of {1}.".FormatWith(CultureInfo.InvariantCulture, value, schema.Maximum), schema); } if (schema.ExclusiveMaximum && JValue.Compare(JTokenType.Integer, value, schema.Maximum) == 0) { this.RaiseError("Integer {0} equals maximum value of {1} and exclusive maximum is true.".FormatWith(CultureInfo.InvariantCulture, value, schema.Maximum), schema); } } if (schema.Minimum.HasValue) { if (JValue.Compare(JTokenType.Integer, value, schema.Minimum) < 0) { this.RaiseError("Integer {0} is less than minimum value of {1}.".FormatWith(CultureInfo.InvariantCulture, value, schema.Minimum), schema); } if (schema.ExclusiveMinimum && JValue.Compare(JTokenType.Integer, value, schema.Minimum) == 0) { this.RaiseError("Integer {0} equals minimum value of {1} and exclusive minimum is true.".FormatWith(CultureInfo.InvariantCulture, value, schema.Minimum), schema); } } if (schema.DivisibleBy.HasValue) { bool flag2; if (value is BigInteger) { BigInteger bigInteger = (BigInteger)value; bool flag = !Math.Abs(schema.DivisibleBy.Value - Math.Truncate(schema.DivisibleBy.Value)).Equals(0.0); if (flag) { flag2 = (bigInteger != 0L); } else { flag2 = (bigInteger % new BigInteger(schema.DivisibleBy.Value) != 0L); } } else { flag2 = !JsonValidatingReader.IsZero((double)Convert.ToInt64(value, CultureInfo.InvariantCulture) % schema.DivisibleBy.Value); } if (flag2) { this.RaiseError("Integer {0} is not evenly divisible by {1}.".FormatWith(CultureInfo.InvariantCulture, JsonConvert.ToString(value), schema.DivisibleBy), schema); } } }