public void AddFields(IOpenApiObjectToTypeService openApiObjectToTypeService,
IObjectsProcessingKeyStore keyStore,
TypeBuilder typeBuilder,
IEnumerable <IOpenApiType> extendedTypes,
IDictionary <string, IOpenApiType> definitions)
{
foreach (var openApiType in extendedTypes)
{
Type donorType = typeof(object);
donorType = _typeResolver.GetType(openApiObjectToTypeService,
keyStore,
openApiType,
definitions,
$"PropertyHolder_{Guid.NewGuid()}");
if (donorType == typeof(object))
{
throw new NotSupportedException($"Type in All Of property for {typeBuilder.Name} not recognised");
}
foreach (var field in donorType.GetFields(BindingFlags.Public | BindingFlags.Instance))
{
typeBuilder.DefineField(field.Name,
field.FieldType,
FieldAttributes.Public);
}
}
}
public Endpoint GenerateEndpoint(OpenApiEndpointModel inputModel,
IObjectsProcessingKeyStore keyStore)
{
var output = new Endpoint()
{
Path = inputModel.Path,
ShortName = inputModel.ShortName,
Method = inputModel.Method,
PathParameters = SelectParameterByLocation(inputModel, ParameterIn.path),
QueryParameters = SelectParameterByLocation(inputModel, ParameterIn.query),
HeaderParameters = SelectParameterByLocation(inputModel, ParameterIn.header),
RequestBody = inputModel.RequestBody == null ?
null :
ConvertContent(inputModel.RequestBody,
$"{inputModel.ShortName}Request",
keyStore),
SuccessResponseBody = inputModel.SuccessStatusResponse == null ?
null :
ConvertContent(inputModel.SuccessStatusResponse,
$"{inputModel.ShortName}Result",
keyStore)
};
output.SuccessContentExpected = output.SuccessResponseBody != null;
return(output);
}
public Type GetType(IOpenApiObjectToTypeService objectService,
IOpenApiUmbrellaTypeResolver typeResolver,
IObjectsProcessingKeyStore objectKeyStore,
OpenApiReferencedType referencedType,
IDictionary <string, IOpenApiType> definitions)
{
var typeName = _lastTokenService.GetLastToken(referencedType.Type);
if (!CurrentTypeHolder.Types.TryGetValue(typeName, out var existingType))
{
if (!definitions.TryGetValue(typeName, out var definedNotCreated))
{
throw new NotSupportedException($"Referenced type {typeName} is not defined in OpenApi document");
}
//handle circular reference
objectKeyStore.ThrowIfPresent(typeName);
var createdType = typeResolver.GetType(objectService,
objectKeyStore,
definedNotCreated,
definitions,
typeName);
CurrentTypeHolder.Types[typeName] = createdType;
return(createdType);
}
return(existingType);
}
private Content ConvertContent(OpenApiRequestOrResponseModel input,
string name,
IObjectsProcessingKeyStore keyStore)
{
return(new Content()
{
ContentType = input.Type,
Type = input.Content == null ?
null :
_typeResolver.GetType(_objectToTypeService,
keyStore,
input.Content,
null,
name)
});
}
public Type GetType(IOpenApiObjectToTypeService objectService,
IObjectsProcessingKeyStore objectKeyStore,
IOpenApiType openApiType,
IDictionary <string, IOpenApiType> definitions,
string suggestedObjectName = null)
{
if (openApiType is OpenApiPrimitiveType)
{
return(_primitiveService.GetType((OpenApiPrimitiveType)openApiType,
nameIfEnum: suggestedObjectName));
}
if (openApiType.Matches <OpenApiReferencedType>())
{
return(_referenceService.GetType(objectService,
typeResolver: this,
objectKeyStore,
(OpenApiReferencedType)openApiType,
definitions));
}
if (openApiType.Matches <OpenApiObjectType>())
{
return(objectService.GetType((OpenApiObjectType)openApiType,
definitions,
suggestedObjectName,
objectKeyStore));
}
if (openApiType.Matches <OpenApiArrayType>())
{
var memberType = ((OpenApiArrayType)openApiType).Items;
var arrayMemberType = GetType(objectService,
objectKeyStore,
memberType,
definitions,
suggestedObjectName + "Member");
return(typeof(IEnumerable <>).MakeGenericType(arrayMemberType));
}
throw new NotSupportedException($"Unable to convert unsupported " +
$"OpenApi Type {openApiType.GetType()}");
}
public Type GetType(OpenApiObjectType inputObject,
IDictionary <string, IOpenApiType> definitions,
string name,
IObjectsProcessingKeyStore objectsKeyStore)
{
objectsKeyStore.ThrowIfPresent(name);
var typeBuilder = _module.Builder.DefineType(name,
TypeAttributes.Public);
objectsKeyStore.AddPresent(name);
foreach (var property in inputObject.Properties)
{
var propName = property.Key;
var propType = _typeResolver.GetType(this,
objectsKeyStore,
property.Value,
definitions,
$"{name}_{propName}");
DefinePublicField(typeBuilder,
propType,
propName);
}
if (inputObject.AllOf != null && inputObject.AllOf.Any())
{
_fieldStealer.AddFields(this,
objectsKeyStore,
typeBuilder,
inputObject.AllOf,
definitions);
}
objectsKeyStore.RemovePresent(name);
return(typeBuilder.CreateTypeInfo());
}
