private StatementSyntax CreateExpressionStatementForWithMethodParameterMap(
OpenApiParameter parameter)
{
var methodName = parameter.In switch
{
ParameterLocation.Query => nameof(IMessageRequestBuilder.WithQueryParameter),
ParameterLocation.Header => nameof(IMessageRequestBuilder.WithHeaderParameter),
ParameterLocation.Path => nameof(IMessageRequestBuilder.WithPathParameter),
_ => throw new NotSupportedException(nameof(parameter.In))
};
var parameterMapName = parameter.Name;
var parameterName = parameter.Name.EnsureFirstCharacterToUpper();
return(SyntaxFactory.ExpressionStatement(
SyntaxFactory.InvocationExpression(
SyntaxMemberAccessExpressionFactory.Create(methodName, "requestBuilder"))
.WithArgumentList(
SyntaxFactory.ArgumentList(
SyntaxFactory.SeparatedList <ArgumentSyntax>(
new SyntaxNodeOrToken[]
{
SyntaxFactory.Argument(
SyntaxFactory.LiteralExpression(
SyntaxKind.StringLiteralExpression,
SyntaxFactory.Literal(parameterMapName))),
SyntaxTokenFactory.Comma(),
SyntaxFactory.Argument(
SyntaxMemberAccessExpressionFactory.Create(parameterName, "parameters")),
})))));
}
private StatementSyntax CreateExpressionStatementForWithMethodBodyMap()
=> SyntaxFactory.ExpressionStatement(
SyntaxFactory.InvocationExpression(
SyntaxMemberAccessExpressionFactory.Create(nameof(IMessageRequestBuilder.WithBody), "requestBuilder"))
.WithArgumentList(
SyntaxFactory.ArgumentList(
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.Argument(
SyntaxMemberAccessExpressionFactory.Create("Request", "parameters"))))));
private MemberDeclarationSyntax CreatePropertyForIsStatusCode(
HttpStatusCode statusCode)
=> SyntaxFactory.PropertyDeclaration(
SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.BoolKeyword)),
SyntaxFactory.Identifier("Is" + statusCode.ToNormalizedString()))
.WithModifiers(SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword)))
.WithExpressionBody(
SyntaxFactory.ArrowExpressionClause(
SyntaxFactory.BinaryExpression(
SyntaxKind.EqualsExpression,
SyntaxFactory.IdentifierName("StatusCode"),
SyntaxMemberAccessExpressionFactory.Create(statusCode.ToString(), nameof(HttpStatusCode)))))
.WithSemicolonToken(SyntaxTokenFactory.Semicolon());
private LocalDeclarationStatementSyntax CreateInvokeExecuteAsyncMethodBlockLocalRequestMessage()
=> SyntaxFactory.LocalDeclarationStatement(
SyntaxFactory.VariableDeclaration(SyntaxFactory.IdentifierName("var"))
.WithVariables(
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.VariableDeclarator(SyntaxFactory.Identifier("requestMessage"))
.WithInitializer(
SyntaxFactory.EqualsValueClause(
SyntaxFactory.InvocationExpression(
SyntaxMemberAccessExpressionFactory.Create(nameof(IMessageRequestBuilder.Build), "requestBuilder"))
.WithArgumentList(
SyntaxFactory.ArgumentList(
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.Argument(
SyntaxMemberAccessExpressionFactory.Create(ApiOperationType.ToString(), nameof(HttpMethod)))))))))))
.WithUsingKeyword(SyntaxFactory.Token(SyntaxKind.UsingKeyword));
private ExpressionStatementSyntax CreateInvokeExecuteAsyncMethodBlockLocalResponseBuilderAddError(
Tuple <HttpStatusCode, string> responseType)
=> SyntaxFactory.ExpressionStatement(
SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName("responseBuilder"),
SyntaxFactory.GenericName(
SyntaxFactory.Identifier(nameof(IMessageResponseBuilder.AddErrorResponse)))
.WithTypeArgumentList(
SyntaxFactory.TypeArgumentList(
SyntaxFactory.SingletonSeparatedList <TypeSyntax>(
SyntaxFactory.IdentifierName(responseType.Item2))))))
.WithArgumentList(
SyntaxFactory.ArgumentList(
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.Argument(
SyntaxMemberAccessExpressionFactory.Create(responseType.Item1.ToString(), nameof(HttpStatusCode)))))));
private LocalDeclarationStatementSyntax CreateInvokeExecuteAsyncMethodBlockLocalClient()
=> SyntaxFactory.LocalDeclarationStatement(
SyntaxFactory.VariableDeclaration(SyntaxFactory.IdentifierName("var"))
.WithVariables(
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.VariableDeclarator(
SyntaxFactory.Identifier("client"))
.WithInitializer(
SyntaxFactory.EqualsValueClause(
SyntaxFactory.InvocationExpression(
SyntaxMemberAccessExpressionFactory.Create(nameof(IHttpClientFactory.CreateClient), "factory"))
.WithArgumentList(
SyntaxFactory.ArgumentList(
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.Argument(
SyntaxFactory.LiteralExpression(
SyntaxKind.StringLiteralExpression,
SyntaxFactory.Literal(
$"{ApiProjectOptions.ProjectPrefixName}-ApiClient")))))))))));
private StatementSyntax[] CreateInvokeExecuteAsyncMethodBlockLocalRequestBuilder()
{
var equalsClauseSyntax = SyntaxFactory.EqualsValueClause(
SyntaxFactory.InvocationExpression(
SyntaxMemberAccessExpressionFactory.Create(nameof(IHttpMessageFactory.FromTemplate), "httpMessageFactory"))
.WithArgumentList(CreateOneStringArg($"{ApiProjectOptions.RouteBase}{ApiUrlPath}")));
var requestBuilderSyntax = SyntaxFactory.LocalDeclarationStatement(
SyntaxFactory.VariableDeclaration(
SyntaxFactory.IdentifierName("var"))
.WithVariables(
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.VariableDeclarator(
SyntaxFactory.Identifier("requestBuilder"))
.WithInitializer(equalsClauseSyntax))));
var result = new List <StatementSyntax>
{
requestBuilderSyntax,
};
if (HasParametersOrRequestBody)
{
if (GlobalPathParameters.Any())
{
result.AddRange(GlobalPathParameters.Select(CreateExpressionStatementForWithMethodParameterMap));
}
if (ApiOperation.Parameters is not null)
{
result.AddRange(ApiOperation.Parameters.Select(CreateExpressionStatementForWithMethodParameterMap));
}
var bodySchema = ApiOperation.RequestBody?.Content.GetSchemaByFirstMediaType();
if (bodySchema is not null)
{
result.Add(CreateExpressionStatementForWithMethodBodyMap());
}
}
return(result.ToArray());
}
private LocalDeclarationStatementSyntax CreateInvokeExecuteAsyncMethodBlockLocalResponse()
=> SyntaxFactory.LocalDeclarationStatement(
SyntaxFactory.VariableDeclaration(SyntaxFactory.IdentifierName("var"))
.WithVariables(
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.VariableDeclarator(SyntaxFactory.Identifier("response"))
.WithInitializer(
SyntaxFactory.EqualsValueClause(
SyntaxFactory.AwaitExpression(
SyntaxFactory.InvocationExpression(
SyntaxMemberAccessExpressionFactory.Create(nameof(HttpClient.SendAsync), "client"))
.WithArgumentList(
SyntaxFactory.ArgumentList(
SyntaxFactory.SeparatedList <ArgumentSyntax>(
new SyntaxNodeOrToken[]
{
SyntaxFactory.Argument(SyntaxFactory.IdentifierName("requestMessage")),
SyntaxFactory.Token(SyntaxKind.CommaToken),
SyntaxFactory.Argument(SyntaxFactory.IdentifierName(nameof(CancellationToken).EnsureFirstCharacterToLower())),
})))))))))
.WithUsingKeyword(SyntaxFactory.Token(SyntaxKind.UsingKeyword));
private static ReturnStatementSyntax CreateCodeBlockReturnStatementForHelper(
bool hasParameters)
{
var arguments = hasParameters
? new SyntaxNodeOrToken[]
{
SyntaxArgumentFactory.Create("parameters"),
SyntaxTokenFactory.Comma(),
SyntaxArgumentFactory.Create(nameof(CancellationToken).EnsureFirstCharacterToLower()),
}
: new SyntaxNodeOrToken[]
{
SyntaxArgumentFactory.Create(nameof(CancellationToken).EnsureFirstCharacterToLower()),
};
return(SyntaxFactory.ReturnStatement(
SyntaxFactory.AwaitExpression(
SyntaxFactory.InvocationExpression(
SyntaxMemberAccessExpressionFactory.Create("ExecuteAsync", "handler"))
.WithArgumentList(
SyntaxFactory.ArgumentList(
SyntaxFactory.SeparatedList <ArgumentSyntax>(arguments))))));
}
