private string GetParameterExpression(Parameter parameter, GenerateSingleRequestDefinitionContext context)
{
var parameterDefault = parameter.@default;
if (parameterDefault == null && string.Equals(parameter.name, "api-version", StringComparison.Ordinal))
{
parameterDefault = context?.SwaggerDocument?.info?.version;
}
if (parameterDefault != null)
{
return($"{{{{# if request.parameters.{parameter.name} }}}}{{{{ request.parameters.{parameter.name} }}}}{{{{ else }}}}{parameterDefault}{{{{/ if }}}}");
}
else
{
return($"{{{{ request.parameters.{parameter.name} }}}}");
}
}
private List <Models.Parameter> GetParameterList(GenerateSingleRequestDefinitionContext context)
{
Parameter LookupParameterRef(Parameter parameter)
{
return(context.SwaggarDocumentLoader.GetResolved(parameter));
}
var operationParamters = context.Operation.Value.parameters.Select(LookupParameterRef);
bool IsNotOperationParameter(Models.Parameter pathParameter)
{
return(!operationParamters.Any(operationParameter =>
{
return string.Equals(pathParameter.name, operationParameter.name, StringComparison.Ordinal) && string.Equals(pathParameter.name, operationParameter.name, StringComparison.Ordinal);
}));
}
var pathParameters = context.Path.Value.parameters.Select(LookupParameterRef).Where(IsNotOperationParameter);
return(operationParamters.Concat(pathParameters).ToList());
}
private IEnumerable <Schema> DereferenceAndFlattenAllOf(GenerateSingleRequestDefinitionContext context, Schema schema, Func <Schema, bool> shouldRecurse)
{
var dereferencedSchema = Dereference(schema, context);
if (shouldRecurse(dereferencedSchema))
{
if (dereferencedSchema.allOf != null)
{
bool NestedShouldRecurse(Schema nestedSchema) => nestedSchema != dereferencedSchema && shouldRecurse(nestedSchema);
var transitiveSchemas = dereferencedSchema.allOf.SelectMany(nestedSchema => DereferenceAndFlattenAllOf(context, nestedSchema, NestedShouldRecurse));
foreach (var transitiveSchema in transitiveSchemas)
{
yield return(transitiveSchema);
}
}
yield return(dereferencedSchema);
}
}
public void GenerateSingleRequestDefinition(GenerateSingleRequestDefinitionContext context)
{
var generatedPath = NormalizePath(context.SwaggerReference.target);
generatedPath += NormalizePath(context.SwaggerDocument.info.title);
var operationId = context.Operation.Value.operationId;
foreach (var tag in context.Operation.Value.tags ?? Enumerable.Empty <string>())
{
generatedPath += NormalizePath(tag);
if (operationId.StartsWith(tag + "_", StringComparison.Ordinal))
{
operationId = operationId.Substring(tag.Length + 1);
}
}
generatedPath += NormalizePath(operationId + ".yaml");
context.GeneratedPath = generatedPath.TrimStart('/');
var parameters = GetParameterList(context);
using (var writer = new StringWriter())
{
writer.WriteLine($"method: {context.Operation.Key.ToUpperInvariant()}");
var hasHttps = context.SwaggerDocument.schemes?.Contains("https", StringComparer.OrdinalIgnoreCase) ?? false;
var hasHttp = context.SwaggerDocument.schemes?.Contains("http", StringComparer.OrdinalIgnoreCase) ?? false;
var scheme = (hasHttp && !hasHttps) ? "http" : "https";
var host = context.SwaggerDocument.host ?? "{{ request.host }}";
var basePath = context.SwaggerDocument.basePath?.TrimEnd('/') ?? string.Empty;
var path = context.Path.Key;
foreach (var parameter in parameters.Where(parameter => parameter.@in == "path"))
{
path = path.Replace($"{{{parameter.name}}}", GetParameterExpression(parameter, context));
}
writer.WriteLine($"url: {scheme}://{host}{basePath}{path}");
if (parameters.Where(parameter => parameter.@in == "query").Any())
{
writer.WriteLine("query:");
foreach (var parameter in parameters.Where(parameter => parameter.@in == "query"))
{
if (parameter.required == false && parameter.@default == null)
{
writer.WriteLine($"{{{{# if request.parameters.{parameter.name} }}}}");
}
writer.WriteLine($" {parameter.name}: \"{GetParameterExpression(parameter, context)}\"");
if (parameter.required == false && parameter.@default == null)
{
writer.WriteLine($"{{{{/ if }}}}");
}
}
}
if (context.SwaggerReference.extra != null)
{
if (context.SwaggerReference.extra is string extraString)
{
writer.WriteLine(extraString);
}
else
{
writer.WriteLine(_yamlSerializers.YamlSerializer.Serialize(context.SwaggerReference.extra));
}
}
var bodyParameter = parameters.SingleOrDefault(parameter => parameter.@in == "body");
if (bodyParameter != null)
{
var bodySchema = Dereference(bodyParameter.schema, context);
if (string.IsNullOrEmpty(bodySchema.type) || bodySchema.type == "object")
{
writer.WriteLine("body:");
var allProperties = DereferenceAndFlattenAllOf(context, bodySchema, nestedSchema => true)
.Distinct()
.Where(schema => schema.properties != null)
.SelectMany(schema => schema.properties);
foreach (var property in allProperties)
{
var propertySchema = Dereference(property.Value, context);
writer.WriteLine($"{{{{# if request.body.{property.Key} }}}}");
writer.WriteLine($" {property.Key}: {{{{{{ json request.body.{property.Key} }}}}}}");
if (propertySchema.@default != null)
{
writer.WriteLine("{{ else }}");
writer.WriteLine($" {property.Key}: {_yamlSerializers.JsonSerializer.Serialize(propertySchema.@default)}");
}
writer.WriteLine($"{{{{/ if }}}}");
}
}
else
{
writer.WriteLine($"body: {{{{{{ json request.body }}}}}}");
}
}
context.GeneratedContent = writer.GetStringBuilder().ToString();
}
}
private Schema Dereference(Schema schema, GenerateSingleRequestDefinitionContext context)
{
return(context.SwaggarDocumentLoader.GetResolved(schema));
}
public async Task Initialize(SwaggerReference info)
{
var swaggerDocumentLoader = new SwaggarDocumentLoader(_yamlSerializers, _httpClientFactory);
var swaggerDocuments = new List <SwaggerDocument>();
var httpClient = _httpClientFactory.Create(null);
foreach (var input in info.inputs)
{
if (string.IsNullOrEmpty(info.source))
{
// TODO : re-abstract this case into docmgr
using (var yamlReader = InnerPackage.OpenText(input))
{
var swaggerDocument = _yamlSerializers.YamlDeserializer.Deserialize <SwaggerDocument>(yamlReader);
swaggerDocuments.Add(swaggerDocument);
}
}
else
{
var uriParts = UriParts.Parse(info.source);
uriParts.RewriteGitHubUris();
var swaggerDocument = await swaggerDocumentLoader.LoadDocument(uriParts.ToString(), input);
swaggerDocuments.Add(swaggerDocument);
}
}
foreach (var swaggerDocument in swaggerDocuments)
{
foreach (var pathEntry in swaggerDocument.paths)
{
foreach (var operationEntry in pathEntry.Value.operations)
{
var context = new GenerateSingleRequestDefinitionContext
{
SwaggerReference = info,
SwaggerDocument = swaggerDocument,
SwaggarDocumentLoader = swaggerDocumentLoader,
Path = pathEntry,
Operation = operationEntry,
};
_requestGenerator.GenerateSingleRequestDefinition(context);
if (GeneratedFiles.ContainsKey(context.GeneratedPath))
{
for (var index = 2; index != 200; ++index)
{
if (!GeneratedFiles.ContainsKey($"{context.GeneratedPath}.{index}"))
{
GeneratedFiles.Add(
$"{context.GeneratedPath}.{index}",
context.GeneratedContent);
break;
}
}
}
else
{
GeneratedFiles.Add(
context.GeneratedPath,
context.GeneratedContent);
}
}
}
}
}
