private static void BuildApplicationFormUrlEncodedExtensionMethodBody(GeneratorSettings settings, StringBuilder builder, RestEaseInterfaceMethodDetails method)
{
builder.AppendLine(" var form = new Dictionary<string, object>");
builder.AppendLine(" {");
foreach (var parameter in method.ExtensionMethodParameters)
{
string comma = parameter != method.ExtensionMethodParameters.Last() ? "," : string.Empty;
builder.AppendLine($" {{ \"{parameter.Identifier}\", {parameter.Identifier} }}{comma}");
}
builder.AppendLine(" };");
builder.AppendLine();
}
private RestEaseInterfaceMethodDetails MapOperationToMappingModel(RestEaseInterface @interface, string path, string httpMethod, OpenApiOperation operation)
{
string methodRestEaseForAnnotation = httpMethod.ToPascalCase();
string methodRestEaseMethodName = GeneratedRestEaseMethodName(path, operation, methodRestEaseForAnnotation);
var headerParameterList = operation.Parameters
.Where(p => p.In == ParameterLocation.Header && p.Schema.GetSchemaType() != SchemaType.Object)
.Select(p => BuildValidParameter(p.Name, p.Schema, p.Required, p.Description, p.In))
.ToList();
var pathParameterList = operation.Parameters
.Where(p => p.In == ParameterLocation.Path && p.Schema.GetSchemaType() != SchemaType.Object)
.Select(p => BuildValidParameter(p.Name, p.Schema, p.Required, p.Description, p.In))
.ToList();
var queryParameterList = operation.Parameters
.Where(p => p.In == ParameterLocation.Query && p.Schema.GetSchemaType() != SchemaType.Object)
.Select(p => BuildValidParameter(p.Name, p.Schema, p.Required, p.Description, p.In))
.ToList();
var extensionMethodParameterList = new List<RestEaseParameter>();
var bodyParameterList = new List<RestEaseParameter>();
var requestDetails = operation.RequestBody != null
? MapRequest(operation, bodyParameterList, extensionMethodParameterList)
: null;
var headers = new List<string>();
if (requestDetails != null)
{
if (requestDetails.DetectedContentType != null)
{
headers.Add($"[Header(\"{HttpKnownHeaderNames.ContentType}\", \"{requestDetails.DetectedContentType.GetDescription()}\")]");
}
else if (requestDetails.ContentTypes.Count > 1)
{
headerParameterList.Add(new RestEaseParameter
{
Required = true,
Summary = "The Content-Type",
Identifier = "contentType",
IdentifierWithRestEase = $"[Header(\"{HttpKnownHeaderNames.ContentType}\")] string contentType",
IdentifierWithType = "string contentType",
IsSpecial = false,
SchemaFormat = SchemaFormat.Undefined,
SchemaType = SchemaType.String
});
}
}
var methodParameterList = headerParameterList
.Union(pathParameterList)
.Union(bodyParameterList)
.Union(queryParameterList)
.OrderByDescending(p => p.Required)
.ToList();
var response = operation.Responses.First();
object returnType = null;
if (response.Value != null && TryGetOpenApiMediaType(response.Value.Content, SupportedContentType.ApplicationJson, out OpenApiMediaType responseJson, out var _))
{
switch (responseJson.Schema?.GetSchemaType())
{
case SchemaType.Array:
string arrayType = responseJson.Schema.Items.Reference != null ?
MakeValidModelName(responseJson.Schema.Items.Reference.Id) :
MapSchema(responseJson.Schema.Items, null, false, true, null).ToString();
returnType = MapArrayType(arrayType);
break;
case SchemaType.Object:
if (responseJson.Schema.Reference != null)
{
// Existing defined object
returnType = MakeValidModelName(responseJson.Schema.Reference.Id);
}
else if (responseJson.Schema.AdditionalProperties != null)
{
// Use AdditionalProperties
returnType = MapSchema(responseJson.Schema.AdditionalProperties, null, responseJson.Schema.AdditionalProperties.Nullable, false, null);
}
else
{
// Object is defined `inline`, create a new Model and use that one.
string className = !string.IsNullOrEmpty(responseJson.Schema.Title)
? CSharpUtils.CreateValidIdentifier(responseJson.Schema.Title, CasingType.Pascal)
: $"{methodRestEaseMethodName.ToPascalCase()}Result";
var existingModel = @interface.InlineModels.FirstOrDefault(m => m.ClassName == className);
if (existingModel == null)
{
var newModel = new RestEaseModel
{
Namespace = Settings.Namespace,
ClassName = className,
Properties = MapSchema(responseJson.Schema, null, false, true, null) as ICollection<string>
};
@interface.InlineModels.Add(newModel);
}
returnType = className;
}
break;
default:
if (Settings.ReturnObjectFromMethodWhenResponseIsDefinedButNoModelIsSpecified)
{
returnType = "object";
}
break;
}
}
var method = new RestEaseInterfaceMethodDetails
{
Headers = headers,
Summary = operation.Summary ?? $"{methodRestEaseMethodName} ({path})",
SummaryParameters = methodParameterList.Select(mp => $"<param name=\"{mp.Identifier}\">{mp.Summary.StripHtml()}</param>").ToList(),
RestEaseAttribute = $"[{methodRestEaseForAnnotation}(\"{path}\")]",
RestEaseMethod = new RestEaseInterfaceMethod
{
ReturnType = MapReturnType(returnType),
Name = methodRestEaseMethodName,
ParametersAsString = string.Join(", ", methodParameterList.Select(mp => mp.IdentifierWithRestEase)),
Parameters = methodParameterList
}
};
if (requestDetails?.IsExtension == true)
{
var combinedMethodParameterList = new List<RestEaseParameter>
{
new RestEaseParameter
{
Identifier = "api",
IdentifierWithType = $"this {@interface.Name} api",
IdentifierWithRestEase = $"this {@interface.Name} api",
Summary = "The Api"
}
};
combinedMethodParameterList.AddRange(methodParameterList.Where(p => !p.IsSpecial));
combinedMethodParameterList.AddRange(extensionMethodParameterList);
method.ExtensionMethodDetails = new RestEaseInterfaceMethodDetails
{
Summary = operation.Summary ?? $"{methodRestEaseMethodName} ({path})",
SummaryParameters = combinedMethodParameterList.Select(mp => $"<param name=\"{mp.Identifier}\">{mp.Summary.StripHtml()}</param>").ToList(),
RestEaseMethod = new RestEaseInterfaceMethod
{
ReturnType = method.RestEaseMethod.ReturnType,
Name = method.RestEaseMethod.Name,
ParametersAsString = string.Join(", ", combinedMethodParameterList.Select(mp => mp.IdentifierWithType)),
Parameters = combinedMethodParameterList
}
};
method.ExtensionMethodParameters = extensionMethodParameterList;
method.ExtensionMethodContentType = requestDetails.DetectedContentType;
}
return method;
}
private static void BuildApplicationOctetStreamExtensionMethodBody(GeneratorSettings settings, StringBuilder builder, RestEaseInterfaceMethodDetails method)
{
builder.AppendLine(" var content = new MultipartFormDataContent();");
builder.AppendLine();
var formUrlEncodedContentList = new List <string>();
foreach (var parameter in method.ExtensionMethodParameters)
{
switch (parameter.SchemaType)
{
case SchemaType.String:
switch (parameter.SchemaFormat)
{
case SchemaFormat.Binary:
case SchemaFormat.Byte:
string identifierName = $"{parameter.Identifier}Content";
switch (settings.ApplicationOctetStreamType)
{
case ApplicationOctetStreamType.Stream:
builder.AppendLine($" var {identifierName} = new StreamContent({parameter.Identifier});");
break;
default:
builder.AppendLine($" var {identifierName} = new ByteArrayContent({parameter.Identifier});");
break;
}
builder.AppendLine($" content.Add({identifierName});");
builder.AppendLine();
break;
default:
formUrlEncodedContentList.Add(parameter.Identifier);
break;
}
break;
default:
formUrlEncodedContentList.Add(parameter.Identifier);
break;
}
}
if (formUrlEncodedContentList.Any())
{
builder.AppendLine(" var formUrlEncodedContent = new FormUrlEncodedContent(new[] {");
foreach (var formUrlEncodedContent in formUrlEncodedContentList)
{
string comma = formUrlEncodedContent != formUrlEncodedContentList.Last() ? "," : string.Empty;
builder.AppendLine(
$" new KeyValuePair<string, string>(\"{formUrlEncodedContent}\", {formUrlEncodedContent}.ToString()){comma}");
}
builder.AppendLine(" });");
builder.AppendLine();
builder.AppendLine(" content.Add(formUrlEncodedContent);");
}
}
