private string HandleJsonTypes(JsonSchema jSchema)
{
TypeKeyword type = jSchema.Get <TypeKeyword>();
if (type != null)
{
switch (type.Value)
{
case JsonSchemaType.String:
{
FormatKeyword format = jSchema.Get <FormatKeyword>();
if (format != null && format.Value != null && !string.IsNullOrEmpty(format.Value))
{
return(HandleFormatTypes(format.Value));
}
return("string");
}
case JsonSchemaType.Boolean:
return("boolean");
case JsonSchemaType.Number:
return("decimal");
case JsonSchemaType.Integer:
{
double?minimum = jSchema.Minimum();
if (minimum > 0.0)
{
return("positiveInteger");
}
else if (minimum == 0.0)
{
return("nonNegativeInteger");
}
else
{
return("integer");
}
}
}
}
return(null);
}
public override JsonSchema AsJsonSchema()
{
JsonSchema returnSchema = InitialJsonSchema()
.Type(JsonSchemaType.Integer);
if (MultipleOf.HasValue)
{
returnSchema.MultipleOf(MultipleOf.Value);
}
if (Minimum.HasValue)
{
returnSchema.Minimum(Minimum.Value);
}
if (Maximum.HasValue)
{
returnSchema.Maximum(Maximum.Value);
}
return(returnSchema);
}
private JsonObject ExtractRestrictions(string typeName, JsonSchema jSchema)
{
var restriction = new JsonObject();
if (typeName == null)
{
return(restriction);
}
string reference;
do
{
reference = jSchema.Ref();
if (reference != null)
{
jSchema = definitions.GetValueOrDefault(ExtractTypeNameFromDefinitionReference(reference));
}
}while (reference != null);
switch (typeName)
{
case "string":
{
double?minLength = jSchema.MinLength();
double?maxLength = jSchema.MaxLength();
if (minLength != null && minLength == maxLength)
{
AddRestrictionValue(restriction, "length", minLength);
}
else
{
AddRestrictionValue(restriction, "minLength", minLength);
AddRestrictionValue(restriction, "maxLength", maxLength);
}
Regex pattern = jSchema.Pattern();
if (pattern != null)
{
var pat = new JsonObject();
pat.Add("Value", pattern.ToString());
restriction.Add("pattern", pat);
}
// enum restriction?
List <JsonValue> enumerations = jSchema.Enum();
if (enumerations != null && enumerations.Count > 0)
{
string value = string.Empty;
foreach (JsonValue enumeration in enumerations)
{
if (value.Length > 0)
{
value += ";";
}
value += enumeration.String;
}
JsonObject enumerationObject = new JsonObject();
enumerationObject.Add("Value", value);
restriction.Add("enumeration", enumerationObject);
}
break;
}
case "integer":
case "decimal":
case "positiveInteger":
case "number":
{
int totalDigits = 0;
if (jSchema.Maximum() != null && jSchema.Minimum() == -jSchema.Maximum())
{
string maxAsString = jSchema.Maximum().ToString();
if (maxAsString.Length > 0 && maxAsString.Replace("9", string.Empty).Length == 0)
{
totalDigits = maxAsString.Length;
}
}
if (totalDigits != 0)
{
AddRestrictionValue(restriction, "totalDigits", totalDigits);
}
else
{
AddRestrictionValue(restriction, "minimum", jSchema.Minimum());
AddRestrictionValue(restriction, "maximum", jSchema.Maximum());
}
AddRestrictionValue(restriction, "exclusiveMinimum", jSchema.ExclusiveMinimum());
AddRestrictionValue(restriction, "exclusiveMaximum", jSchema.ExclusiveMaximum());
break;
}
default:
{
break;
}
}
return(restriction);
}