private void MapResponses(OpenApiModel.OpenApiModelBuilder openApiModelBuilder,
Dictionary <string, Response> versionedResponses)
{
foreach (var(path, response) in versionedResponses)
{
var schemas = new Dictionary <string, ISchema>();
if (response.Content != null)
{
foreach (var(type, mediaType) in response.Content)
{
var schemaPath = mediaType.Schema.GetRef() ?? $"{path}/content/{type}/schema";
var schema = openApiModelBuilder.GetSchemaForPath(schemaPath);
if (schema == null)
{
throw new ArgumentException(
$"Couldn't create response - missing schema {schemaPath}. Pleas validate them earlier.");
}
schemas.Add(type, schema);
}
}
openApiModelBuilder.AttachResponse(path, new Models.Responses.Response(schemas));
}
}
private void MapRequestBodies(OpenApiModel.OpenApiModelBuilder openApiModelBuilder,
Dictionary <string, Request> versionedBodies)
{
foreach (var(path, requestBody) in versionedBodies)
{
var isRequired = requestBody.Required ?? false;
var schemas = new Dictionary <string, ISchema>();
if (requestBody.Content != null)
{
foreach (var(type, mediaType) in requestBody.Content)
{
var schemaPath = mediaType.Schema.GetRef() ?? $"{path}/content/{type}/schema";
var schema = openApiModelBuilder.GetSchemaForPath(schemaPath);
if (schema == null)
{
throw new ArgumentException(
$"Couldn't create request body - missing schema {schemaPath}. Pleas validate them earlier.");
}
schemas.Add(type, schema);
}
}
openApiModelBuilder.AttachRequestBody(path, new RequestBody(schemas, isRequired));
}
}
private void MapSchemes(OpenApiModel.OpenApiModelBuilder openApiBuilder,
Dictionary <string, Schema> versionedSchemes)
{
var buildManager =
new SuspendBuildsManager <Schema, ISchema>(versionedSchemes, BuilderInitializers.SchemaMap);
if (!buildManager.Build())
{
throw new ArgumentException("Couldn't create schemes. Pleas validate them earlier.");
}
openApiBuilder.AttachScheme(buildManager.GetResult());
}
private void MapSecuritySchema(OpenApiModel.OpenApiModelBuilder openApiBuilder,
Dictionary <string, SecurityScheme> securitySchemes)
{
foreach (var(key, scheme) in securitySchemes)
{
var name = key.Split("/").Last();
if (scheme.In != "header" || scheme.Type != "apiKey")
{
continue;
}
var parameter = new Models.Parameters.Parameter(scheme.Name, ParameterType.Header,
new SimpleSchema(SchemaType.String), true, false, false);
openApiBuilder.AttachSecuritySchema(name, parameter);
}
}
private void MapHeaders(OpenApiModel.OpenApiModelBuilder openApiModelBuilder,
Dictionary <string, Header> versionedHeaders)
{
foreach (var(key, header) in versionedHeaders)
{
var schemaPath = header.Schema.GetRef() ?? $"{key}/schema";
var schema = openApiModelBuilder.GetSchemaForPath(schemaPath);
if (schema == null)
{
throw new ArgumentException(
$"Couldn't create headers - missing schema {schemaPath}. Pleas validate them earlier.");
}
var name = key.Split("/").Last();
var isRequired = header.Required ?? false;
var isDeprecated = header.Deprecated ?? false;
var allowEmptyValue = header.AllowEmptyValue ?? false;
openApiModelBuilder.AttachHeader(key,
new Models.Headers.Header(name, schema, isRequired, isDeprecated, allowEmptyValue));
}
}
private void MapParameters(OpenApiModel.OpenApiModelBuilder openApiModelBuilder,
Dictionary <string, Parameter> versionedParameters)
{
foreach (var(key, parameter) in versionedParameters)
{
var schemaPath = parameter.Schema.GetRef() ?? $"{key}/schema";
var schema = openApiModelBuilder.GetSchemaForPath(schemaPath);
if (schema == null)
{
throw new ArgumentException(
$"Couldn't create parameter - missing schema {schemaPath}. Pleas validate them earlier.");
}
var name = parameter.Name ?? throw new ArgumentException("Parameter has to have the name.");
var isRequired = parameter.Required ?? false;
var isDeprecated = parameter.Deprecated ?? false;
var allowEmptyValue = parameter.AllowEmptyValue ?? false;
var parameterTypeString = parameter.In ?? "";
var map = new Dictionary <string, ParameterType>
{
{ "query", ParameterType.Query },
{ "header", ParameterType.Header },
{ "path", ParameterType.Path }
};
if (!map.ContainsKey(parameterTypeString))
{
throw new ArgumentException($"Invalid `in` value - {parameterTypeString}");
}
openApiModelBuilder.AttachParameter(key,
new Models.Parameters.Parameter(name, map[parameterTypeString], schema, isRequired, isDeprecated,
allowEmptyValue));
}
}
protected override OpenApiModel Convert(OpenApiFile versionedModel)
{
var openApiBuilder = new OpenApiModel.OpenApiModelBuilder();
var collector = new ReferableCollector(new ReferencesRegister());
versionedModel.Accept("#", collector);
collector.Validate();
if (!collector.Validate())
{
throw new JsonException("Not all references was satisfied.");
}
MapSchemes(openApiBuilder, collector.GetObjectOfType <Schema>());
MapSecuritySchema(openApiBuilder, collector.GetObjectOfType <SecurityScheme>());
MapHeaders(openApiBuilder, collector.GetObjectOfType <Header>());
MapRequestBodies(openApiBuilder, collector.GetObjectOfType <Request>());
MapParameters(openApiBuilder, collector.GetObjectOfType <Parameter>());
MapResponses(openApiBuilder, collector.GetObjectOfType <Response>());
MapEndpoints(openApiBuilder, versionedModel.Paths);
return(openApiBuilder.Create());
}
private void MapEndpoints(OpenApiModel.OpenApiModelBuilder openApiModelBuilder,
Dictionary <string, PathItem> pathItems)
{
foreach (var(url, pathItem) in pathItems)
{
var path = $"#/paths/{url}";
var parameters = new HashSet <IParameter>();
if (pathItem.Parameters != null)
{
foreach (var versionedParameter in pathItem.Parameters)
{
var parameterPath = versionedParameter.GetRef() ??
$"{path}/parameters/{versionedParameter.GetObject().Name}";
var parameter = openApiModelBuilder.GetParameterForPath(parameterPath);
if (parameter == null)
{
throw new ArgumentException($"Missing parameter object - {parameterPath}");
}
parameters.Add(parameter);
}
}
var operationMap = GetOperationMap(pathItem);
foreach (var(type, operation) in operationMap)
{
var endpointParameters = new HashSet <IParameter>(parameters);
if (operation.Security != null)
{
foreach (var securityDictionary in operation.Security)
{
foreach (var key in securityDictionary.Keys)
{
var securityParameter = openApiModelBuilder.GetSecurityParameterForName(key);
endpointParameters.Add(securityParameter);
}
}
}
if (operation.Parameters != null)
{
foreach (var operationParameter in operation.Parameters)
{
var parameterPath = operationParameter.GetRef() ??
$"{path}/{type.ToString().ToLower()}/parameters/{operationParameter.GetObject().Name}";
var parameter = openApiModelBuilder.GetParameterForPath(parameterPath);
if (parameter == null)
{
throw new ArgumentException($"Missing parameter object - {parameterPath}");
}
endpointParameters.Add(parameter);
}
}
var endpointResponses = new List <IHttpResponse>();
foreach (var(status, @ref) in operation.Responses)
{
var responsePath =
@ref.GetRef() ?? $"{path}/{type.ToString().ToLower()}/responses/{status}";
var response = openApiModelBuilder.GetResponseForPath(responsePath);
endpointResponses.Add(new HttpResponse(int.Parse(status),
response)); // todo: check if parse was successful
}
IRequestBody requestBody = null;
if (operation.RequestBody != null)
{
var requestBodyPath = operation.RequestBody?.GetRef() ??
$"{path}/{type.ToString().ToLower()}/requestBody";
requestBody = openApiModelBuilder.GetRequestBodyForPath(requestBodyPath);
}
var operationId = operation.OperationId ??
throw new ArgumentException($"Missing operationId - {path}/{type}");
openApiModelBuilder.AttachEndpoint(new Endpoint(operationId, url,
type,
endpointParameters, requestBody, endpointResponses));
}
}
}
