private OpenApiSchema GenerateObjectSchema(DataContract dataContract, ParameterInfo parameterInfo, SchemaRepository schemaRepository)
{
var schema = new OpenApiSchema
{
Type = "object",
Properties = new Dictionary <string, OpenApiSchema>(),
Required = new SortedSet <string>(),
AdditionalPropertiesAllowed = false
};
// If it's a baseType with known subTypes, add the discriminator property
if (_generatorOptions.GeneratePolymorphicSchemas && _generatorOptions.SubTypesResolver(dataContract.UnderlyingType).Any())
{
var discriminatorName = _generatorOptions.DiscriminatorSelector(dataContract.UnderlyingType);
if (!schema.Properties.ContainsKey(discriminatorName))
{
schema.Properties.Add(discriminatorName, new OpenApiSchema {
Type = "string"
});
}
schema.Required.Add(discriminatorName);
schema.Discriminator = new OpenApiDiscriminator {
PropertyName = discriminatorName
};
}
foreach (var dataProperty in dataContract.Properties ?? Enumerable.Empty <DataProperty>())
{
var customAttributes = dataProperty.MemberInfo?.GetInlineOrMetadataTypeAttributes() ?? Enumerable.Empty <object>();
if (_generatorOptions.IgnoreObsoleteProperties && customAttributes.OfType <ObsoleteAttribute>().Any())
{
continue;
}
schema.Properties[dataProperty.Name] = GeneratePropertySchema(dataProperty, parameterInfo, schemaRepository);
if (dataProperty.IsRequired)
{
schema.Required.Add(dataProperty.Name);
}
}
if (dataContract.AdditionalPropertiesType != null)
{
schema.AdditionalPropertiesAllowed = true;
schema.AdditionalProperties = GenerateSchema(dataContract.AdditionalPropertiesType, schemaRepository);
}
// If it's a known subType, reference the baseType for inheritied properties
if (
_generatorOptions.GeneratePolymorphicSchemas &&
(dataContract.UnderlyingType.BaseType != null) &&
_generatorOptions.SubTypesResolver(dataContract.UnderlyingType.BaseType).Contains(dataContract.UnderlyingType))
{
var basedataContract = _dataContractResolver.GetDataContractForType(dataContract.UnderlyingType.BaseType);
var baseSchemaReference = GenerateReferencedSchema(basedataContract, parameterInfo, schemaRepository);
var baseSchema = schemaRepository.Schemas[baseSchemaReference.Reference.Id];
foreach (var basePropertyName in baseSchema.Properties.Keys)
{
schema.Properties.Remove(basePropertyName);
}
return(new OpenApiSchema
{
AllOf = new List <OpenApiSchema> {
baseSchemaReference, schema
}
});
}
return(schema);
}
private OpenApiSchema CreateObjectSchema(Type type, SchemaRepository schemaRepository)
{
if (!(_contractResolver.ResolveContract(type) is JsonObjectContract jsonObjectContract))
{
throw new InvalidOperationException($"Type {type} does not resolve to a JsonObjectContract");
}
var schema = new OpenApiSchema
{
Type = "object",
Properties = new Dictionary <string, OpenApiSchema>(),
Required = new SortedSet <string>(),
AdditionalPropertiesAllowed = false
};
// If it's a baseType with known subTypes, add the discriminator property
if (_generatorOptions.GeneratePolymorphicSchemas && _generatorOptions.SubTypesResolver(type).Any())
{
var discriminatorName = _generatorOptions.DiscriminatorSelector(type);
schema.Properties.Add(discriminatorName, new OpenApiSchema {
Type = "string"
});
schema.Required.Add(discriminatorName);
schema.Discriminator = new OpenApiDiscriminator {
PropertyName = discriminatorName
};
}
foreach (var jsonProperty in jsonObjectContract.Properties)
{
if (jsonProperty.Ignored)
{
continue;
}
var customAttributes = jsonProperty.TryGetMemberInfo(out MemberInfo memberInfo)
? memberInfo.GetInlineOrMetadataTypeAttributes()
: Enumerable.Empty <object>();
if (_generatorOptions.IgnoreObsoleteProperties && customAttributes.OfType <ObsoleteAttribute>().Any())
{
continue;
}
var required = jsonProperty.IsRequiredSpecified()
? jsonProperty.Required
: jsonObjectContract.ItemRequired ?? Required.Default;
schema.Properties[jsonProperty.PropertyName] = CreatePropertySchema(jsonProperty, customAttributes, required, schemaRepository);
if (required == Required.Always || required == Required.AllowNull || customAttributes.OfType <RequiredAttribute>().Any())
{
schema.Required.Add(jsonProperty.PropertyName);
}
}
if (jsonObjectContract.ExtensionDataValueType != null)
{
schema.AdditionalProperties = _schemaGenerator.GenerateSchema(jsonObjectContract.ExtensionDataValueType, schemaRepository);
schema.AdditionalPropertiesAllowed = true;
}
// If it's a known subType, reference the baseType for inheritied properties
if (_generatorOptions.GeneratePolymorphicSchemas && type.BaseType != null && _generatorOptions.SubTypesResolver(type.BaseType).Contains(type))
{
var baseType = type.BaseType;
var baseSchemaReference = schemaRepository.GetOrAdd(
type: baseType,
schemaId: _generatorOptions.SchemaIdSelector(baseType),
factoryMethod: () => CreateObjectSchema(baseType, schemaRepository));
var baseSchema = schemaRepository.Schemas[baseSchemaReference.Reference.Id];
schema.AllOf = new[] { baseSchemaReference };
foreach (var basePropertyName in baseSchema.Properties.Keys)
{
schema.Properties.Remove(basePropertyName);
}
}
return(schema);
}