public EnumSchema(Type t, Model sModel)
{
Type = "string";
Ref = DefinitionsRefLocation + SwaggerBuilderConfig.ModelIdConvention(t);
Description = sModel.Description;
Enum = t.GetEnumNames();
}
public static Item ToItem(this Type type)
{
var item = new Item();
if (type.IsContainer())
{
item.Type = "array";
var itemsType = type.GetElementType() ?? type.GetGenericArguments().FirstOrDefault();
item.Items = itemsType.ToItem();
}
else
{
if (Primitive.IsPrimitive(type))
{
var primitive = Primitive.FromType(type);
item.Format = primitive.Format;
item.Type = primitive.Type;
}
else
{
item.Ref = "#/definitions/" + SwaggerBuilderConfig.ModelIdConvention(type);
}
}
return(item);
}
public SwaggerRoot GetSwaggerJson()
{
var builder = new SwaggerRootBuilder();
foreach (var pathItem in this.RetrieveSwaggerPaths())
{
builder.Path(pathItem.Key, pathItem.Value.PathItem);
}
builder.Info(_info);
foreach (var model in RetrieveSwaggerModels())
{
var name = SwaggerBuilderConfig.ModelIdConvention(model.ModelType);
builder.Definition(name, model.GetSchema());
}
foreach (var tag in RetrieveSwaggerTags())
{
builder.Tag(tag);
}
foreach (var securityScheme in _securitySchemes)
{
builder.SecurityDefinition(securityScheme.Key, securityScheme.Value.Build());
}
return(builder.Build());
}
public void ToModelProperty_NonPrimitive_ShouldHaveRefSet()
{
new SwaggerModelPropertyData
{
Type = typeof(TestModel)
}.ToModelProperty().ShouldEqual(
new ModelProperty
{
Ref = SwaggerBuilderConfig.ModelIdConvention(typeof(TestModel))
}
);
}
public ObjectSchema(Type t, Model sModel)
{
Type = "object";
Ref = DefinitionsRefLocation + SwaggerBuilderConfig.ModelIdConvention(t);
Required = (sModel.Required as IList <string>)?.Select(x => x.ToCamelCase()).ToList();
Description = sModel.Description;
Properties = new Dictionary <string, Schema>();
foreach (var member in sModel.Properties)
{
Properties.Add(member.Key.ToCamelCase(), GenerateSchemaForProperty(member.Value));
}
}
public EnumerableSchema(Type t, Model sModel)
{
Type = "array";
Items = new Item();
Type subType = t.GetGenericArguments().FirstOrDefault();
Items.Type = "object";
Items.Ref = DefinitionsRefLocation + SwaggerBuilderConfig.ModelIdConvention(subType);
Ref = DefinitionsRefLocation + SwaggerBuilderConfig.ModelIdConvention(t);
}
public void ToModelPropertyNonPrimitiveCollection_ShouldHaveTypeArrayAndItemsRefSet()
{
new SwaggerModelPropertyData
{
Type = typeof(TestModel[])
}.ToModelProperty().ShouldEqual(
new ModelProperty
{
Type = "array",
Items = new Item {
Ref = SwaggerBuilderConfig.ModelIdConvention(typeof(TestModel))
}
},
"String return type"
);
}
public static T ToDataType <T>(this Type type, bool isTopLevel = false)
where T : DataType, new()
{
var dataType = new T();
if (SwaggerTypeMapping.IsMappedType(type))
{
type = SwaggerTypeMapping.GetMappedType(type);
}
if (type == null)
{
dataType.Type = "void";
return(dataType);
}
if (Primitive.IsPrimitive(type))
{
var primitive = Primitive.FromType(type);
dataType.Format = primitive.Format;
dataType.Type = primitive.Type;
return(dataType);
}
if (type.IsContainer())
{
dataType.Type = "array";
var itemsType = type.GetElementType() ?? type.GetGenericArguments().FirstOrDefault();
if (Primitive.IsPrimitive(itemsType))
{
var primitive = Primitive.FromType(itemsType);
dataType.Items = new Item
{
Type = primitive.Type,
Format = primitive.Format
};
return(dataType);
}
dataType.Items = itemsType.ToItem();
return(dataType);
}
if (isTopLevel)
{
dataType.Ref = "#/definitions/" + SwaggerBuilderConfig.ModelIdConvention(type);
return(dataType);
}
dataType.Type = SwaggerBuilderConfig.ModelIdConvention(type);
return(dataType);
}
public static IEnumerable <Model> ToModel(this SwaggerModelData model, IEnumerable <SwaggerModelData> knownModels = null, bool getSubModels = true)
{
var classProperties = model.Properties.Where(x => !Primitive.IsPrimitive(x.Type) && !x.Type.IsEnum && !x.Type.IsGenericType);
var modelsData = knownModels ?? Enumerable.Empty <SwaggerModelData>();
if (getSubModels)
{
foreach (var swaggerModelPropertyData in classProperties)
{
var properties = GetPropertiesFromType(swaggerModelPropertyData.Type);
var modelDataForClassProperty =
modelsData.FirstOrDefault(x => x.ModelType == swaggerModelPropertyData.Type);
var id = modelDataForClassProperty == null
? swaggerModelPropertyData.Type.Name
: SwaggerBuilderConfig.ModelIdConvention(modelDataForClassProperty.ModelType);
var description = modelDataForClassProperty == null
? swaggerModelPropertyData.Description
: modelDataForClassProperty.Description;
var required = modelDataForClassProperty == null
? properties.Where(p => p.Required || p.Type.IsImplicitlyRequired())
.Select(p => p.Name)
.OrderBy(name => name)
.ToList()
: modelDataForClassProperty.Properties
.Where(p => p.Required || p.Type.IsImplicitlyRequired())
.Select(p => p.Name)
.OrderBy(name => name)
.ToList();
if (!required.Any())
{
required = null;
}
var modelproperties = modelDataForClassProperty == null
? properties.OrderBy(x => x.Name).ToDictionary(p => p.Name, ToModelProperty)
: modelDataForClassProperty.Properties.OrderBy(x => x.Name)
.ToDictionary(p => p.Name, ToModelProperty);
yield return(new Model
{
Id = id,
Description = description,
Required = required,
Properties = modelproperties
});
}
}
var topLevelModel = new Model
{
Id = SwaggerBuilderConfig.ModelIdConvention(model.ModelType),
Description = model.Description,
Required = model.Properties
.Where(p => p.Required || p.Type.IsImplicitlyRequired())
.Select(p => p.Name)
.OrderBy(name => name)
.ToList(),
Properties = model.Properties
.OrderBy(p => p.Name)
.ToDictionary(p => p.Name, ToModelProperty)
// TODO: SubTypes and Discriminator
};
if (!topLevelModel.Required.Any())
{
topLevelModel.Required = null;
}
yield return(topLevelModel);
}
