public void GenerateSingleRequestDefinition()

in src/Microsoft.Atlas.CommandLine/Swagger/RequestGenerator.cs [23:133]
89 lines of code
19 McCabe index (conditional complexity)

        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();
            }
        }