public override JSchema GetSchema(JSchemaTypeGenerationContext context)
{
// customize the generated schema for these types to have a format
if (context.ObjectType == typeof(int))
{
return(CreateSchemaWithFormat(context.ObjectType, context.Required, "int32"));
}
if (context.ObjectType == typeof(long))
{
return(CreateSchemaWithFormat(context.ObjectType, context.Required, "int64"));
}
if (context.ObjectType == typeof(float))
{
return(CreateSchemaWithFormat(context.ObjectType, context.Required, "float"));
}
if (context.ObjectType == typeof(double))
{
return(CreateSchemaWithFormat(context.ObjectType, context.Required, "double"));
}
if (context.ObjectType == typeof(byte))
{
return(CreateSchemaWithFormat(context.ObjectType, context.Required, "byte"));
}
if (context.ObjectType == typeof(DateTime) || context.ObjectType == typeof(DateTimeOffset))
{
return(CreateSchemaWithFormat(context.ObjectType, context.Required, "date-time"));
}
// use default schema generation for all other types
return(null);
}
public override JSchema GetSchema(JSchemaTypeGenerationContext context)
{
var rangeAttribute = context.MemberProperty?.AttributeProvider.GetAttributes(typeof(RangeAttribute), true)
.Cast <RangeAttribute>()
.FirstOrDefault();
if (rangeAttribute == null)
{
return(null);
}
if (!(rangeAttribute.Minimum is double minumum) || !(rangeAttribute.Maximum is double maximum))
{
return(null);
}
var isMinInfinity = double.IsInfinity(minumum);
var isMaxInfinity = double.IsInfinity(maximum);
if (!isMinInfinity && !isMaxInfinity)
{
return(null);
}
var isFloatingPointNumber = context.ObjectType == typeof(float) || context.ObjectType == typeof(double);
return(new JSchema
{
Title = context.SchemaTitle,
Description = context.SchemaDescription,
Type = isFloatingPointNumber ? JSchemaType.Number : JSchemaType.Integer,
Minimum = isMinInfinity ? null : (double?)minumum,
Maximum = isMaxInfinity ? null : (double?)maximum,
});
}
public override JSchema GetSchema(JSchemaTypeGenerationContext context)
{
var type = context.ObjectType;
JSchema schema = null;
var generator = new JSchemaGenerator();
Console.WriteLine(type.Name);
var isObject = type.Namespace != "System";
if (isObject)
{
if (SkipType == type.Name)
{
return(null);
}
this.SkipType = type.Name;
generator.GenerationProviders.Add(this);
}
schema = generator.Generate(type);
return(ModifySchema(schema, context));
}
public override JSchema GetSchema(JSchemaTypeGenerationContext context)
{
JSchema schema = context.Generator.Generate(context.ObjectType);
schema.Title = "foo";
return(schema);
}
public override JSchema GetSchema(JSchemaTypeGenerationContext context)
{
if (context.ObjectType == typeof(TaskCollection))
{
return(CreateCollectionSchema());
}
return(null);
}
public override JSchema GetSchema(JSchemaTypeGenerationContext context)
{
var generator = new JSchemaGenerator();
var schema = generator.Generate(context.ObjectType);
schema.Properties["Path"].Pattern = @"(\b\.)+";
return(schema);
}
public override JSchema GetSchema(JSchemaTypeGenerationContext context)
{
if (context.ObjectType == typeof(Guid))
{
return(CreateSchemaWithFormat(context.ObjectType, context.Required, "guid"));
}
return(null);
}
protected override JSchema Customize(JSchemaTypeGenerationContext context, JsonObjectContract contract, Type type, JSchema schema)
{
foreach (var property in contract.Properties.Where(p => p.PropertyType == typeof(Uri) && p.AttributeProvider.GetAttributes(typeof(UriReferenceAttribute), true).Any()))
{
JSchema propertySchema;
if (!schema.Properties.TryGetValue(property.PropertyName, out propertySchema))
{
continue;
}
propertySchema.Format = UriReference;
}
return(schema);
}
public override JSchema GetSchema(JSchemaTypeGenerationContext context)
{
var definedType = context.ParentContract.CreatedType;
var schema = JsonSchemaUtility.GetSchema(context.ObjectType);
var propertyInfo = definedType.GetProperty(this.propertyName);
var items = propertyInfo.GetValue(null) as string[];
if (items != null)
{
schema.Enum.Clear();
foreach (var item in items)
{
schema.Enum.Add(JValue.CreateString(item));
}
}
//int qwr = 0;
//bool isNullable = ReflectionUtils.IsNullableType(context.ObjectType);
//Type t = context.ObjectType;
//var schema = new JSchema
//{
// Title = context.SchemaTitle,
// Description = context.SchemaDescription,
// Type = JSchemaType.String
//};
//context.g
//if (isNullable && context.Required != Required.Always && context.Required != Required.DisallowNull)
//{
// schema.Type |= JSchemaType.Null;
// schema.Enum.Add(JValue.CreateNull());
//}
//string[] names = Enum.GetNames(t);
//foreach (string name in names)
//{
// string finalName = EnumUtils.ToEnumName(t, name, CamelCaseText);
// schema.Enum.Add(JValue.CreateString(finalName));
//}
return(schema);
}
public override JSchema GetSchema(JSchemaTypeGenerationContext context)
{
var contract = GetContract(context);
var type = GetType(contract);
PushType(type);
try
{
return(Customize(context, contract, type, context.Generator.Generate(context.ObjectType)));
}
finally
{
PopType(type);
}
}
public sealed override bool CanGenerateSchema(JSchemaTypeGenerationContext context)
{
var contract = GetContract(context);
var type = GetType(contract);
if (CurrentlyGeneratingForType(type))
{
return(false);
}
if (!CanCustomize(context, contract, type))
{
return(false);
}
return(true);
}
public override JSchema GetSchema(JSchemaTypeGenerationContext context)
{
var definedType = context.ParentContract.CreatedType;
var schema = JsonSchemaUtility.GetSchema(context.ObjectType);
var propertyInfo = definedType.GetProperty(this.propertyName);
if (propertyInfo.GetValue(null) is string[] items)
{
schema.Enum.Clear();
foreach (var item in items)
{
schema.Enum.Add(JValue.CreateString(item));
}
}
return(schema);
}
public sealed override bool CanGenerateSchema(JSchemaTypeGenerationContext context)
{
JsonContract contract;
Type type;
if (!TryGetType(context, out contract, out type))
{
return(false);
}
if (CurrentlyGeneratingForType(type))
{
return(false);
}
if (!CanCustomize(context, contract, type))
{
return(false);
}
return(true);
}
public override JSchema GetSchema(JSchemaTypeGenerationContext context)
{
JsonContract contract;
Type type;
if (!TryGetType(context, out contract, out type))
{
throw new JSchemaException(string.Format("Unexpected type {0}", context.ObjectType));
}
PushType(type);
try
{
return(Customize(context, contract, type, context.Generator.Generate(context.ObjectType)));
}
finally
{
PopType(type);
}
}
public override JSchema GetSchema(JSchemaTypeGenerationContext context)
{
var generator = new JSchemaGenerator();
var schema = generator.Generate(context.ObjectType, context.Required != Required.Always);
schema.SchemaVersion = new Uri("http://json-schema.org/draft-04/schema#");
foreach (var schemaProperty in schema.Properties)
{
var key = schemaProperty.Key;
var item = schemaProperty.Value;
if (item?.Type == null)
{
continue;
}
if (item.Type.Value.HasFlag(JSchemaType.Object))
{
foreach (var valueProperty in item.Properties)
{
AddFormat(valueProperty, key);
}
}
else if (item.Type.Value.HasFlag(JSchemaType.Boolean) ||
item.Type.Value.HasFlag(JSchemaType.Integer) ||
item.Type.Value.HasFlag(JSchemaType.Number) ||
item.Type.Value.HasFlag(JSchemaType.Array) ||
item.Type.Value.HasFlag(JSchemaType.String)
)
{
AddFormat(schemaProperty, context.ObjectType.Name);
}
}
return(schema);
}
public override JSchema GetSchema(JSchemaTypeGenerationContext context)
{
// Handle Schema Definition Attribute
if (context.ObjectType.CustomAttributes.Any(a => a.AttributeType == typeof(ConiziSchemaAttribute)))
{
var generator = context.Generator;
var schema = generator.Generate(context.ObjectType);
HandleAdditionalProperties(context.ObjectType, schema);
HandleXProperties(context.ObjectType, schema);
var attr = context.ObjectType.GetCustomAttribute <ConiziSchemaAttribute>();
schema.Id = new Uri(attr.Id);
schema.SchemaVersion = new Uri("http://json-schema.org/draft-06/schema#");
var assembly = this.GetType().Assembly.GetName();
schema.Description = $"{context.SchemaDescription}";
return(schema);
}
var processedProps = new List <string>();
//Check if anyOf etc. is used
//if (context.ObjectType.CustomAttributes.Any(a => a.AttributeType == typeof(KnownTypeAttribute)))
//{
// var generator = context.Generator;
// var schema = generator.Generate(context.ObjectType);
// foreach (var attr in context.ObjectType.GetCustomAttributes().Where(a => a is KnownTypeAttribute)
// .Cast<KnownTypeAttribute>())
// {
// var schemaOf = generator.Generate(attr.Type);
// HandleAdditionalProperties(attr.Type, schemaOf);
// HandleXProperties(attr.Type, schemaOf);
// schemaOf.Title = context.SchemaTitle;
// schemaOf.Description = context.SchemaDescription;
// foreach (var custAttr in context.ObjectType.GetCustomAttributes())
// {
// switch (custAttr)
// {
// case ConiziOneOfAttribute oneOf:
// schema.OneOf.Add(schemaOf);
// processedProps.Add(attr.Type.Name);
// break;
// case ConiziAnyOfAttribute oneOf:
// schema.AnyOf.Add(schemaOf);
// processedProps.Add(attr.Type.Name);
// break;
// case ConiziAllOfAttribute allOf:
// schema.AllOf.Add(schemaOf);
// processedProps.Add(attr.Type.Name);
// break;
// }
// }
// }
// foreach (var prop in context.ObjectType.GetProperties())
// {
// if (!processedProps.Contains(prop.PropertyType.Name))
// continue;
// var ccProp = prop.Name.ToCamelCase();
// schema.Properties.Remove(ccProp);
// }
// return schema;
//}
if (context.ObjectType == typeof(DateTime))
{
if (context.MemberProperty.AttributeProvider.GetAttributes(typeof(ConiziDateOnlyAttribute), true).Any())
{
var generator = context.Generator;
var schema = generator.Generate(context.ObjectType);
schema.Format = "date";
schema.Title = context.SchemaTitle;
schema.Description = context.SchemaDescription;
return(schema);
}
}
//if (context.MemberProperty?.AttributeProvider != null && context.MemberProperty.AttributeProvider.GetAttributes(typeof(ConiziHandleExternal), true).Any())
//{
// var attr = context.MemberProperty.AttributeProvider.GetAttributes(typeof(ConiziHandleExternal), true).Cast<ConiziHandleExternal>()
// .FirstOrDefault();
// if (attr != null && !string.IsNullOrEmpty(attr.externalRef))
// {
// var generator = context.Generator;
// var schema = generator.Generate(context.ObjectType);
// schema.AllowAdditionalProperties = false;
// schema.Type = JSchemaType.Array;
// schema.Reference = new Uri(attr.externalRef);
// return schema;
// }
//}
if (context.ObjectType == typeof(string) && context.MemberProperty?.AttributeProvider != null)
{
if (context.MemberProperty.AttributeProvider.GetAttributes(typeof(ConiziTimeOnlyAttribute), true).Any())
{
var generator = context.Generator;
var schema = generator.Generate(context.ObjectType);
schema.Format = "time";
schema.Title = context.SchemaTitle;
schema.Description = context.SchemaDescription;
return(schema);
}
}
var defaultGenerator = context.Generator;
var defaultSchema = defaultGenerator.Generate(context.ObjectType);
HandleAdditionalProperties(context.ObjectType, defaultSchema);
HandleXProperties(context.ObjectType, defaultSchema);
defaultSchema.Title = context.SchemaTitle;
defaultSchema.Description = context.SchemaDescription;
return(defaultSchema);
}
protected override bool CanCustomize(JSchemaTypeGenerationContext context, JsonContract contract, Type type)
{
return(contract is JsonObjectContract);
}
private JSchema GenerateInternal(Type type, Required valueRequired, JsonProperty memberProperty, JsonContainerContract container)
{
ValidationUtils.ArgumentNotNull(type, "type");
Type nonNullableType = ReflectionUtils.IsNullableType(type) ? Nullable.GetUnderlyingType(type) : type;
Uri resolvedId = GetTypeId(nonNullableType, false);
Uri explicitId = GetTypeId(nonNullableType, true);
if (resolvedId != null)
{
JSchema resolvedSchema = _resolver.GetSchema(resolvedId);
if (resolvedSchema != null)
{
// resolved schema is not null but referencing member allows nulls
// change resolved schema to allow nulls. hacky but what are ya gonna do?
if (valueRequired != Required.Always && !HasFlag(resolvedSchema.Type, JSchemaType.Null))
{
resolvedSchema.Type |= JSchemaType.Null;
}
return(resolvedSchema);
}
}
JsonContract contract = ContractResolver.ResolveContract(type);
var key = CreateKey(valueRequired, memberProperty, contract);
switch (contract.ContractType)
{
case JsonContractType.Object:
case JsonContractType.Array:
case JsonContractType.Dictionary:
TypeSchema typeSchema = _typeSchemas.SingleOrDefault(s => s.Key.Equals(key));
if (typeSchema != null)
{
return(typeSchema.Schema);
}
break;
}
JSchema schema = null;
JSchemaGenerationProvider provider = ResolveTypeProvider(nonNullableType, memberProperty);
if (provider != null)
{
JSchemaTypeGenerationContext context = new JSchemaTypeGenerationContext(type, valueRequired, memberProperty, container, this);
schema = provider.GetSchema(context);
if (schema == null)
{
throw new JsonException("Could not get schema for type '{0}' from provider '{1}'.".FormatWith(CultureInfo.InvariantCulture, type.FullName, provider.GetType().FullName));
}
}
if (_generationProviders != null)
{
JSchemaTypeGenerationContext context = new JSchemaTypeGenerationContext(type, valueRequired, memberProperty, container, this);
foreach (JSchemaGenerationProvider generationProvider in _generationProviders)
{
schema = generationProvider.GetSchema(context);
}
}
if (schema != null)
{
_typeSchemas.Add(new TypeSchema(key, schema));
return(schema);
}
schema = new JSchema();
if (explicitId != null)
{
schema.Id = explicitId;
}
switch (contract.ContractType)
{
case JsonContractType.Object:
case JsonContractType.Array:
case JsonContractType.Dictionary:
_typeSchemas.Add(new TypeSchema(key, schema));
break;
}
return(PopulateSchema(schema, contract, memberProperty, valueRequired));
}
public override bool CanGenerateSchema(JSchemaTypeGenerationContext context)
{
return(base.CanGenerateSchema(context) &&
context.ObjectType == typeof(ProvidersWidgetConfig));
}
static bool TryGetType(JSchemaTypeGenerationContext context, out JsonContract contract, out Type type)
{
contract = context.Generator.ContractResolver.ResolveContract(context.ObjectType);
type = contract == null ? null : Nullable.GetUnderlyingType(contract.UnderlyingType) ?? contract.UnderlyingType;
return(contract != null && type != null);
}
public abstract JSchema ModifySchema(JSchema schema, JSchemaTypeGenerationContext context);
protected abstract JSchema Customize(JSchemaTypeGenerationContext context, JsonContract contract, Type type, JSchema schema);
protected virtual bool CanCustomize(JSchemaTypeGenerationContext context, JsonContract contract, Type type)
{
return(true);
}
public override JSchema GetSchema(JSchemaTypeGenerationContext context)
{
throw new NotImplementedException();
}
static JsonContract GetContract(JSchemaTypeGenerationContext context)
{
return(context.Generator.ContractResolver.ResolveContract(context.ObjectType));
}
public override JSchema ModifySchema(JSchema schema, JSchemaTypeGenerationContext context)
{
schema.Title = "My Title";
return(schema);
}
