public static void PopulateFrom(this PartialSchema partialSchema, Schema schema)
{
if (schema == null) return;
partialSchema.type = schema.type;
partialSchema.format = schema.format;
if (schema.items != null)
{
// TODO: Handle jagged primitive array and error on jagged object array
partialSchema.items = new PartialSchema();
partialSchema.items.PopulateFrom(schema.items);
}
partialSchema.@default = schema.@default;
partialSchema.maximum = schema.maximum;
partialSchema.exclusiveMaximum = schema.exclusiveMaximum;
partialSchema.minimum = schema.minimum;
partialSchema.exclusiveMinimum = schema.exclusiveMinimum;
partialSchema.maxLength = schema.maxLength;
partialSchema.minLength = schema.minLength;
partialSchema.pattern = schema.pattern;
partialSchema.maxItems = schema.maxItems;
partialSchema.minItems = schema.minItems;
partialSchema.uniqueItems = schema.uniqueItems;
partialSchema.@enum = schema.@enum;
partialSchema.multipleOf = schema.multipleOf;
}
private void ApplyPropertyComments(Schema propertySchema, PropertyInfo propertyInfo)
{
if (propertyInfo == null) return;
var propertyNode = _navigator.SelectSingleNode(
String.Format(PropertyExpression, propertyInfo.DeclaringType.XmlLookupName(), propertyInfo.Name));
if (propertyNode == null) return;
var propSummaryNode = propertyNode.SelectSingleNode(SummaryExpression);
if (propSummaryNode != null)
{
propertySchema.description = propSummaryNode.ExtractContent();
}
}
public void Apply(Schema model, ModelFilterContext context)
{
var typeNode = _navigator.SelectSingleNode(
String.Format(TypeExpression, context.SystemType.XmlLookupName()));
if (typeNode != null)
{
var summaryNode = typeNode.SelectSingleNode(SummaryExpression);
if (summaryNode != null)
model.description = summaryNode.ExtractContent();
}
foreach (var entry in model.properties)
{
var jsonProperty = context.JsonObjectContract.Properties[entry.Key];
if (jsonProperty == null) continue;
ApplyPropertyComments(entry.Value, jsonProperty.PropertyInfo());
}
}
private Schema CreateObjectSchema(JsonObjectContract jsonContract)
{
var properties = jsonContract.Properties
.Where(p => !p.Ignored)
.Where(p => !(_ignoreObsoleteProperties && p.IsObsolete()))
.ToDictionary(
prop => prop.PropertyName,
prop => CreateInlineSchema(prop.PropertyType).WithValidationProperties(prop)
);
var required = jsonContract.Properties.Where(prop => prop.IsRequired())
.Select(propInfo => propInfo.PropertyName)
.ToList();
var schema = new Schema
{
required = required.Any() ? required : null, // required can be null but not empty
properties = properties,
type = "object"
};
foreach (var filter in _schemaFilters)
{
filter.Apply(schema, this, jsonContract.UnderlyingType);
}
// NOTE: In next major version, _modelFilters will completely replace _schemaFilters
var modelFilterContext = new ModelFilterContext(jsonContract.UnderlyingType, jsonContract, this);
foreach (var filter in _modelFilters)
{
filter.Apply(schema, modelFilterContext);
}
return schema;
}