private static void HandleValidationAttribute(RamlType ramlTypeProp, CustomAttributeData attribute)
{
switch (attribute.AttributeType.Name)
{
case "MaxLengthAttribute":
ramlTypeProp.Scalar.MaxLength = (int?)attribute.ConstructorArguments.First().Value;
break;
case "MinLengthAttribute":
ramlTypeProp.Scalar.MinLength = (int?)attribute.ConstructorArguments.First().Value;
break;
case "RangeAttribute":
if (!TypeBuilderHelper.IsMinValue(attribute.ConstructorArguments.First()))
{
ramlTypeProp.Scalar.Minimum = ConvertToNullableDecimal(attribute.ConstructorArguments.First().Value);
}
if (!TypeBuilderHelper.IsMaxValue(attribute.ConstructorArguments.Last()))
{
ramlTypeProp.Scalar.Maximum = ConvertToNullableDecimal(attribute.ConstructorArguments.Last().Value);
}
break;
case "EmailAddressAttribute":
ramlTypeProp.Scalar.Pattern = @"pattern: [^\\s@]+@[^\\s@]+\\.[^\\s@]";
break;
case "UrlAttribute":
ramlTypeProp.Scalar.Pattern = @"pattern: ^(ftp|http|https):\/\/[^ \""]+$";
break;
//case "RegularExpressionAttribute":
// ramlTypeProp.Scalar.Pattern = "pattern: " + attribute.ConstructorArguments.First().Value;
// break;
}
}
private string BuildPropertyCommon(PropertyInfo prop, IEnumerable <CustomAttributeData> customAttributes)
{
var name = TypeBuilderHelper.GetPropertyName(prop);
var res = "\"" + name + "\": { \"type\": " + SchemaTypeMapper.GetAttribute(prop.PropertyType);
res += HandleRequiredAttribute(prop, customAttributes);
res += HandleValidationAttributes(customAttributes);
return(res);
}
private static string HandleRequiredAttribute(PropertyInfo prop, IEnumerable <CustomAttributeData> customAttributes)
{
var res = string.Empty;
if (customAttributes.Any(a => a.AttributeType == typeof(RequiredAttribute)))
{
res += ", \"required\": true";
}
else if (TypeBuilderHelper.IsNullable(prop.PropertyType))
{
res += ", \"required\": false";
}
return(res);
}
private static string GetTypeName(Type type)
{
var typeName = type.Name;
if (IsDictionary(type))
{
typeName = type.GetGenericArguments()[1].Name + "Map";
}
if (TypeBuilderHelper.IsArrayOrEnumerable(type))
{
typeName = "ListOf" + GetTypeName(GetElementType(type));
}
return(typeName.Replace("`", string.Empty));
}
private IDictionary <string, RamlType> GetProperties(Type type)
{
var props = GetClassProperties(type).ToArray();
var dic = new Dictionary <string, RamlType>();
foreach (var prop in props)
{
var key = TypeBuilderHelper.GetPropertyName(prop);
var ramlType = GetProperty(prop);
if (ramlType != null)
{
ramlType.Required = !IsOptionalProperty(prop, prop.CustomAttributes);
dic.Add(key, ramlType);
}
}
return(dic);
}
protected string GetRecursively(Type type, int pad, IEnumerable <CustomAttributeData> customAttributes)
{
if (type.IsGenericType && TypeBuilderHelper.IsGenericWebResult(type))
{
type = type.GetGenericArguments()[0];
}
if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Dictionary <,>))
{
return(null);
}
if (TypeBuilderHelper.IsArrayOrEnumerable(type))
{
var elementType = type.GetElementType() ?? type.GetGenericArguments()[0];
if (SchemaTypeMapper.Map(elementType) != null)
{
return(GetNestedArraySchemaPrimitiveType(pad, elementType));
}
if (elementType.IsGenericType && elementType.GetGenericTypeDefinition() == typeof(KeyValuePair <,>))
{
return(GetNestedArraySchema(pad, elementType));
}
if (elementType.GetProperties().Count(p => p.CanRead || p.CanWrite) == 0)
{
return(string.Empty);
}
return(GetNestedArraySchema(pad, elementType));
}
if (type.GetProperties().Count(p => p.CanRead || p.CanWrite) == 0)
{
return(string.Empty);
}
return(GetNestedObjectSchema(type, pad, customAttributes));
}
private string GetOneOfProperty(PropertyInfo prop, IEnumerable <Type> subclasses, int pad)
{
var name = TypeBuilderHelper.GetPropertyName(prop);
var oneOf = ("\"" + name + "\": {").Indent(pad) + Environment.NewLine;
oneOf += "\"type\": \"object\",".Indent(pad + 2) + Environment.NewLine;
oneOf += "\"oneOf\": [".Indent(pad + 2) + Environment.NewLine;
foreach (var subclass in subclasses.Distinct())
{
var className = TypeBuilderHelper.GetClassName(subclass);
oneOf += ("{ \"$ref\": \"#/definitions/" + className + "\" },").Indent(pad + 4) + Environment.NewLine;
if (!definitions.ContainsKey(className))
{
definitions.Add(className, subclass);
}
}
oneOf = oneOf.Substring(0, oneOf.Length - Environment.NewLine.Length - 1) + Environment.NewLine;
oneOf += "]".Indent(pad + 2) + Environment.NewLine;
oneOf += "}".Indent(pad) + Environment.NewLine;
return(oneOf);
}
protected string HandleValidationAttribute(CustomAttributeData attribute)
{
string res = string.Empty;
switch (attribute.AttributeType.Name)
{
case "MaxLengthAttribute":
res += ", \"maxLength\": " + attribute.ConstructorArguments.First().Value;
break;
case "MinLengthAttribute":
res += ", \"minLength\": " + attribute.ConstructorArguments.First().Value;
break;
case "RangeAttribute":
if (!TypeBuilderHelper.IsMinValue(attribute.ConstructorArguments.First()))
{
res += ", \"minimum\": " + TypeBuilderHelper.Format(attribute.ConstructorArguments.First());
}
if (!TypeBuilderHelper.IsMaxValue(attribute.ConstructorArguments.Last()))
{
res += ", \"maximum\": " + TypeBuilderHelper.Format(attribute.ConstructorArguments.Last());
}
break;
case "EmailAddressAttribute":
res += @", ""pattern"": ""[^\\s@]+@[^\\s@]+\\.[^\\s@]""";
break;
case "UrlAttribute":
res += @", ""pattern"": ""^(ftp|http|https):\/\/[^ \""]+$""";
break;
//case "RegularExpressionAttribute":
// res += ", \"pattern\": " + "\"" + attribute.ConstructorArguments.First().Value + "\"";
// break;
}
return(res);
}
public string Get(Type type)
{
definitions.Clear();
Types.Clear();
string schema;
if (type.IsGenericType && TypeBuilderHelper.IsGenericWebResult(type))
{
type = type.GetGenericArguments()[0];
}
if (TypeBuilderHelper.IsArrayOrEnumerable(type))
{
var elementType = type.GetElementType() ?? type.GetGenericArguments()[0];
if (elementType.GetProperties().Count(p => p.CanRead || p.CanWrite) == 0)
{
return(null);
}
schema = GetArray(elementType);
}
else
{
if (type.GetProperties().Count(p => p.CanRead || p.CanWrite) == 0)
{
return(null);
}
schema = GetMainObjectSchema(type);
}
schema = AddDefinitionsIfAny(schema);
schema += "}" + Environment.NewLine;
return(schema);
}
protected string HandleNestedTypeProperty(int pad, PropertyInfo prop, string schema, IEnumerable <PropertyInfo> props, IEnumerable <CustomAttributeData> customAttributes)
{
var nestedType = GetRecursively(prop.PropertyType, pad + 2, customAttributes);
if (nestedType == null)
{
return(string.Empty);
}
if (!string.IsNullOrWhiteSpace(nestedType))
{
var name = TypeBuilderHelper.GetPropertyName(prop);
schema += ("\"" + name + "\":").Indent(pad) + Environment.NewLine;
schema += nestedType;
}
else
{
// is it one of ?
var subclasses = prop.PropertyType.Assembly.GetTypes()
.Where(type => type.IsSubclassOf(prop.PropertyType))
.ToArray();
if (!subclasses.Any())
{
return(string.Empty);
}
schema += GetOneOfProperty(prop, subclasses, pad);
}
if (prop != props.Last() && !String.IsNullOrWhiteSpace(schema) && schema.Length > "\r\n".Length)
{
schema = schema.Substring(0, schema.Length - "\r\n".Length) + ",\r\n";
}
return(schema);
}
private RamlType GetProperty(PropertyInfo prop)
{
if (prop.PropertyType.GetTypeInfo().IsEnum)
{
return(GetEnum(prop.PropertyType));
}
if (Raml1TypeMapper.Map(prop.PropertyType) != null)
{
return(HandlePrimitiveTypeProperty(prop));
}
if (TypeBuilderHelper.IsArrayOrEnumerable(prop.PropertyType))
{
return(GetArray(prop.PropertyType));
}
if (IsDictionary(prop.PropertyType))
{
return(GetMap(prop.PropertyType));
}
return(HandleNestedTypeProperty(prop));
}
private static bool IsOptionalProperty(PropertyInfo prop, IEnumerable <CustomAttributeData> customAttributes)
{
return(customAttributes.All(a => a.AttributeType != typeof(RequiredAttribute)) && TypeBuilderHelper.IsNullable(prop.PropertyType));
}
public string Add(Type type)
{
var typeName = GetTypeName(type);
if (types.Contains(type))
{
return(typeName);
}
RamlType raml1Type;
if (type.GetTypeInfo().IsGenericType&& TypeBuilderHelper.IsGenericWebResult(type))
{
type = type.GetGenericArguments()[0];
}
if (TypeBuilderHelper.IsArrayOrEnumerable(type))
{
var elementType = GetElementType(type);
if (TypeBuilderHelper.IsArrayOrEnumerable(elementType))
{
var subElementType = GetElementType(elementType);
if (Raml1TypeMapper.Map(subElementType) != null)
{
return(Raml1TypeMapper.Map(subElementType) + "[][]");
}
if (!HasPropertiesOrParentType(subElementType))
{
return(string.Empty);
}
types.Add(type);
raml1Type = GetArrayOfArray(subElementType);
}
else
{
if (Raml1TypeMapper.Map(elementType) != null)
{
return(Raml1TypeMapper.Map(elementType) + "[]");
}
if (!HasPropertiesOrParentType(elementType))
{
return(string.Empty);
}
types.Add(type);
raml1Type = GetArray(elementType);
}
}
else if (IsDictionary(type) || IsParentADictionary(type))
{
types.Add(type);
raml1Type = GetMap(type);
}
else if (type.GetTypeInfo().IsEnum)
{
types.Add(type);
raml1Type = GetEnum(type);
}
else if (Raml1TypeMapper.Map(type) != null)
{
//raml1Type = GetScalar(type);
raml1Type = null;
typeName = Raml1TypeMapper.Map(type);
}
else
{
if (!HasPropertiesOrParentType(type))
{
return(string.Empty);
}
types.Add(type);
raml1Type = GetObject(type);
}
if (raml1Type != null)
{
AddType(type, raml1Type);
}
return(typeName);
}
private static string GetEnumProperty(PropertyInfo prop, int pad)
{
return(("\"" + TypeBuilderHelper.GetPropertyName(prop) + "\": { ").Indent(pad) + Environment.NewLine
+ (" \"enum\": [" + string.Join(", ", Enum.GetNames(prop.PropertyType).Select(v => "\"" + v + "\"")) + "]").Indent(pad) + Environment.NewLine
+ "}".Indent(pad));
}
