private OpenApiSchema CreateReferenceSchema(Type type, SchemaRepository schemaRepository, Func <OpenApiSchema> factoryMethod)
{
return(schemaRepository.GetOrAdd(
type: type,
schemaId: _generatorOptions.SchemaIdSelector(type),
factoryMethod: factoryMethod));
}
private OpenApiSchema GenerateReferencedSchema(SerializerMetadata serializerMetadata, SchemaRepository schemaRepository)
{
return(schemaRepository.GetOrAdd(
serializerMetadata.Type,
_generatorOptions.SchemaIdSelector(serializerMetadata.Type),
() =>
{
var schema = GenerateInlineSchema(serializerMetadata, schemaRepository);
ApplyFilters(schema, serializerMetadata.Type, schemaRepository);
return schema;
}));
}
private OpenApiSchema GenerateReferencedSchema(DataContract dataContract, SchemaRepository schemaRepository)
{
return(schemaRepository.GetOrAdd(
dataContract.UnderlyingType,
_generatorOptions.SchemaIdSelector(dataContract.UnderlyingType),
() =>
{
var schema = GenerateInlineSchema(dataContract, schemaRepository);
ApplyFilters(schema, dataContract.UnderlyingType, schemaRepository);
return schema;
}));
}
protected override OpenApiSchema GenerateSchemaFor(ModelMetadata modelMetadata, SchemaRepository schemaRepository, JsonContract jsonContract)
{
if (!schemaRepository.TryGetIdFor(modelMetadata.ModelType, out string schemaId))
{
schemaId = SchemaGeneratorOptions.SchemaIdSelector(modelMetadata.ModelType);
schemaRepository.ReserveIdFor(modelMetadata.ModelType, schemaId);
schemaRepository.AddSchemaFor(modelMetadata.ModelType, Next.GenerateSchema(modelMetadata, schemaRepository, jsonContract));
}
return(new OpenApiSchema
{
Reference = new OpenApiReference {
Id = schemaId, Type = ReferenceType.Schema
}
});
}
private OpenApiSchema GenerateReferenceSchemaFor(Type type, SchemaRepository schemaRepository, JsonContract jsonContract)
{
if (!schemaRepository.TryGetIdFor(type, out string schemaId))
{
schemaId = _options.SchemaIdSelector(type);
schemaRepository.ReserveIdFor(type, schemaId);
schemaRepository.AddSchemaFor(type, GenerateDefinitionSchemaFor(type, schemaRepository, jsonContract));
}
return(new OpenApiSchema
{
Reference = new OpenApiReference {
Id = schemaId, Type = ReferenceType.Schema
}
});
}
private OpenApiSchema GenerateReferencedSchema(
Type type,
SchemaRepository schemaRepository,
Func <OpenApiSchema> definitionFactory)
{
if (schemaRepository.TryLookupByType(type, out OpenApiSchema referenceSchema))
{
return(referenceSchema);
}
var schemaId = _generatorOptions.SchemaIdSelector(type);
schemaRepository.RegisterType(type, schemaId);
var schema = definitionFactory();
ApplyFilters(schema, type, schemaRepository);
return(schemaRepository.AddDefinition(schemaId, schema));
}
private OpenApiSchema CreateObjectSchema(Type type, 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(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
};
}
var serializableProperties = type.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
.Where(property =>
{
return
((property.IsPubliclyReadable() || property.IsPubliclyWritable()) &&
!(property.GetIndexParameters().Any()) &&
!(property.HasAttribute <JsonIgnoreAttribute>()) &&
!(_serializerOptions.IgnoreReadOnlyProperties && !property.IsPubliclyWritable()));
});
foreach (var property in serializableProperties)
{
var customAttributes = property.GetInlineOrMetadataTypeAttributes();
if (_generatorOptions.IgnoreObsoleteProperties && customAttributes.OfType <ObsoleteAttribute>().Any())
{
continue;
}
var name = property.GetCustomAttribute <JsonPropertyNameAttribute>()?.Name
?? _serializerOptions.PropertyNamingPolicy?.ConvertName(property.Name) ?? property.Name;
schema.Properties[name] = CreatePropertySchema(property, customAttributes, schemaRepository);
if (customAttributes.OfType <RequiredAttribute>().Any())
{
schema.Required.Add(name);
}
if (property.HasAttribute <JsonExtensionDataAttribute>() && property.PropertyType.IsDictionary(out Type keyType, out Type valueType))
{
schema.AdditionalPropertiesAllowed = true;
schema.AdditionalProperties = _schemaGenerator.GenerateSchema(valueType, schemaRepository);
}
}
// 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);
}
