private MemberDeclarationSyntax CreateInvokeExecuteAsyncMethod(
string parameterTypeName,
string resultTypeName,
bool hasParameters)
{
var arguments = hasParameters
? new SyntaxNodeOrToken[]
{
SyntaxParameterFactory.Create(parameterTypeName, "parameters"),
SyntaxTokenFactory.Comma(),
SyntaxParameterFactory.Create(nameof(CancellationToken), nameof(CancellationToken).EnsureFirstCharacterToLower()),
}
: new SyntaxNodeOrToken[]
{
SyntaxParameterFactory.Create(nameof(CancellationToken), nameof(CancellationToken).EnsureFirstCharacterToLower()),
};
var bodyBlockSyntaxStatements = CreateBodyBlockSyntaxStatements(resultTypeName);
return(SyntaxFactory.MethodDeclaration(
SyntaxFactory.GenericName(SyntaxFactory.Identifier(nameof(Task)))
.WithTypeArgumentList(
SyntaxFactory.TypeArgumentList(
SyntaxFactory.SingletonSeparatedList <TypeSyntax>(
SyntaxFactory.IdentifierName(EndpointResultTypeName)))),
SyntaxFactory.Identifier("InvokeExecuteAsync"))
.WithModifiers(SyntaxTokenListFactory.PrivateAsyncKeyword())
.WithParameterList(
SyntaxFactory.ParameterList(SyntaxFactory.SeparatedList <ParameterSyntax>(arguments)))
.WithBody(
SyntaxFactory.Block(bodyBlockSyntaxStatements)));
}
public static MethodDeclarationSyntax CreateInterfaceMethod(
string parameterTypeName,
string resultTypeName,
bool hasParameters)
{
ArgumentNullException.ThrowIfNull(parameterTypeName);
ArgumentNullException.ThrowIfNull(resultTypeName);
var arguments = hasParameters
? new SyntaxNodeOrToken[]
{
SyntaxParameterFactory.Create(parameterTypeName, "parameters"),
SyntaxTokenFactory.Comma(),
SyntaxParameterFactory.Create(nameof(CancellationToken), nameof(CancellationToken).EnsureFirstCharacterToLower())
.WithDefault(SyntaxFactory.EqualsValueClause(
SyntaxFactory.LiteralExpression(SyntaxKind.DefaultLiteralExpression, SyntaxTokenFactory.DefaultKeyword()))),
}
: new SyntaxNodeOrToken[]
{
SyntaxParameterFactory.Create(nameof(CancellationToken), nameof(CancellationToken).EnsureFirstCharacterToLower())
.WithDefault(SyntaxFactory.EqualsValueClause(
SyntaxFactory.LiteralExpression(SyntaxKind.DefaultLiteralExpression, SyntaxTokenFactory.DefaultKeyword()))),
};
return(SyntaxFactory.MethodDeclaration(
SyntaxFactory.GenericName(SyntaxFactory.Identifier(nameof(Task)))
.WithTypeArgumentList(SyntaxTypeArgumentListFactory.CreateWithOneItem(resultTypeName)),
SyntaxFactory.Identifier("ExecuteAsync"))
.WithParameterList(SyntaxFactory.ParameterList(SyntaxFactory.SeparatedList <ParameterSyntax>(arguments)))
.WithSemicolonToken(SyntaxTokenFactory.Semicolon()));
}
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 static ReturnStatementSyntax CreateCodeBlockReturnStatement(
string helperMethodName,
bool hasParameters)
{
var arguments = hasParameters
? new SyntaxNodeOrToken[]
{
SyntaxArgumentFactory.Create("parameters"),
SyntaxTokenFactory.Comma(),
SyntaxArgumentFactory.Create("handler"),
SyntaxTokenFactory.Comma(),
SyntaxArgumentFactory.Create(nameof(CancellationToken).EnsureFirstCharacterToLower()),
}
: new SyntaxNodeOrToken[]
{
SyntaxArgumentFactory.Create("handler"),
SyntaxTokenFactory.Comma(),
SyntaxArgumentFactory.Create(nameof(CancellationToken).EnsureFirstCharacterToLower()),
};
return(SyntaxFactory.ReturnStatement(
SyntaxFactory.InvocationExpression(SyntaxFactory.IdentifierName(helperMethodName))
.WithArgumentList(
SyntaxFactory.ArgumentList(
SyntaxFactory.SeparatedList <ArgumentSyntax>(arguments)))));
}
public static ClassDeclarationSyntax AddSuppressMessageAttribute(this ClassDeclarationSyntax classDeclaration, SuppressMessageAttribute suppressMessage)
{
if (classDeclaration == null)
{
throw new ArgumentNullException(nameof(classDeclaration));
}
if (suppressMessage == null)
{
throw new ArgumentNullException(nameof(suppressMessage));
}
if (string.IsNullOrEmpty(suppressMessage.Justification))
{
throw new ArgumentException(nameof(suppressMessage.Justification));
}
var attributeArgumentList = SyntaxFactory.AttributeArgumentList(
SyntaxFactory.SeparatedList <AttributeArgumentSyntax>(SyntaxFactory.NodeOrTokenList(
SyntaxFactory.AttributeArgument(SyntaxLiteralExpressionFactory.Create(suppressMessage.Category)),
SyntaxTokenFactory.Comma(),
SyntaxFactory.AttributeArgument(SyntaxLiteralExpressionFactory.Create(suppressMessage.CheckId)),
SyntaxTokenFactory.Comma(),
SyntaxFactory.AttributeArgument(SyntaxLiteralExpressionFactory.Create(suppressMessage.Justification !))
.WithNameEquals(
SyntaxNameEqualsFactory.Create(nameof(SuppressMessageAttribute.Justification))
.WithEqualsToken(SyntaxTokenFactory.Equals())))));
return(classDeclaration
.AddAttributeLists(SyntaxAttributeListFactory.Create(nameof(SuppressMessageAttribute), attributeArgumentList)));
}
public static InterfaceDeclarationSyntax AddGeneratedCodeAttribute(this InterfaceDeclarationSyntax interfaceDeclaration, string toolName, string version)
{
if (interfaceDeclaration == null)
{
throw new ArgumentNullException(nameof(interfaceDeclaration));
}
if (toolName == null)
{
throw new ArgumentNullException(nameof(toolName));
}
if (version == null)
{
throw new ArgumentNullException(nameof(version));
}
var attributeArgumentList = SyntaxFactory.AttributeArgumentList(
SyntaxFactory.SeparatedList <AttributeArgumentSyntax>(SyntaxFactory.NodeOrTokenList(
SyntaxFactory.AttributeArgument(SyntaxLiteralExpressionFactory.Create(toolName)),
SyntaxTokenFactory.Comma(),
SyntaxFactory.AttributeArgument(SyntaxLiteralExpressionFactory.Create(version)))));
return(interfaceDeclaration
.AddAttributeLists(SyntaxAttributeListFactory.Create(nameof(GeneratedCodeAttribute), attributeArgumentList)));
}
private MemberDeclarationSyntax CreateConstructor()
=> SyntaxFactory.ConstructorDeclaration(
SyntaxFactory.Identifier(EndpointTypeName))
.WithModifiers(
SyntaxFactory.TokenList(
SyntaxTokenFactory.PublicKeyword()))
.WithParameterList(
SyntaxFactory.ParameterList(
SyntaxFactory.SeparatedList <ParameterSyntax>(
new SyntaxNodeOrToken[]
{
SyntaxFactory.Parameter(SyntaxFactory.Identifier("factory"))
.WithType(SyntaxFactory.IdentifierName(nameof(IHttpClientFactory))),
SyntaxTokenFactory.Comma(), SyntaxFactory
.Parameter(SyntaxFactory.Identifier("httpMessageFactory"))
.WithType(SyntaxFactory.IdentifierName(nameof(IHttpMessageFactory))),
})))
.WithBody(
SyntaxFactory.Block(
SyntaxFactory.ExpressionStatement(
SyntaxFactory.AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.ThisExpression(),
SyntaxFactory.IdentifierName("factory")),
SyntaxFactory.IdentifierName("factory"))),
SyntaxFactory.ExpressionStatement(
SyntaxFactory.AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.ThisExpression(),
SyntaxFactory.IdentifierName("httpMessageFactory")),
SyntaxFactory.IdentifierName("httpMessageFactory")))));
private MemberDeclarationSyntax CreateInvokeExecuteAsyncMethod(string parameterTypeName, string resultTypeName, bool hasParameters)
{
var arguments = hasParameters
? new SyntaxNodeOrToken[]
{
SyntaxParameterFactory.Create(parameterTypeName, "parameters"),
SyntaxTokenFactory.Comma(),
SyntaxParameterFactory.Create(nameof(CancellationToken), nameof(CancellationToken).EnsureFirstCharacterToLower()),
}
: new SyntaxNodeOrToken[]
{
SyntaxParameterFactory.Create(nameof(CancellationToken), nameof(CancellationToken).EnsureFirstCharacterToLower()),
};
return(SyntaxFactory.MethodDeclaration(
SyntaxFactory.GenericName(SyntaxFactory.Identifier(nameof(Task)))
.WithTypeArgumentList(SyntaxTypeArgumentListFactory.CreateWithOneItem(resultTypeName)),
SyntaxFactory.Identifier("InvokeExecuteAsync"))
.WithModifiers(
SyntaxFactory.TokenList(
SyntaxFactory.Token(
CreatePragmaWarningCodeStyle1998(true),
SyntaxKind.PrivateKeyword,
SyntaxFactory.TriviaList()), SyntaxFactory.Token(SyntaxKind.AsyncKeyword)))
.WithParameterList(SyntaxFactory.ParameterList(SyntaxFactory.SeparatedList <ParameterSyntax>(arguments)))
.WithBody(
SyntaxFactory.Block(SyntaxThrowStatementFactory.CreateNotImplementedException())
.WithOpenBraceToken(
SyntaxFactory.Token(
CreatePragmaWarningCodeStyle1998(false),
SyntaxKind.OpenBraceToken,
SyntaxFactory.TriviaList()))));
}
private MemberDeclarationSyntax CreateExecuteAsyncMethod(
string parameterTypeName,
bool hasParameters)
{
var arguments = hasParameters
? new SyntaxNodeOrToken[]
{
SyntaxParameterFactory.Create(parameterTypeName, "parameters"),
SyntaxTokenFactory.Comma(),
SyntaxParameterFactory.Create(nameof(CancellationToken), nameof(CancellationToken).EnsureFirstCharacterToLower())
.WithDefault(SyntaxFactory.EqualsValueClause(
SyntaxFactory.LiteralExpression(SyntaxKind.DefaultLiteralExpression, SyntaxTokenFactory.DefaultKeyword()))),
}
: new SyntaxNodeOrToken[]
{
SyntaxParameterFactory.Create(nameof(CancellationToken), nameof(CancellationToken).EnsureFirstCharacterToLower())
.WithDefault(SyntaxFactory.EqualsValueClause(
SyntaxFactory.LiteralExpression(SyntaxKind.DefaultLiteralExpression, SyntaxTokenFactory.DefaultKeyword()))),
};
return(SyntaxFactory.MethodDeclaration(
SyntaxFactory.GenericName(SyntaxFactory.Identifier(nameof(Task)))
.WithTypeArgumentList(
SyntaxFactory.TypeArgumentList(
SyntaxFactory.SingletonSeparatedList <TypeSyntax>(
SyntaxFactory.IdentifierName(EndpointResultTypeName)))),
SyntaxFactory.Identifier("ExecuteAsync"))
.WithModifiers(SyntaxTokenListFactory.PublicKeyword())
.WithParameterList(SyntaxFactory.ParameterList(SyntaxFactory.SeparatedList <ParameterSyntax>(arguments)))
.WithSemicolonToken(SyntaxTokenFactory.Semicolon()));
}
private static ReturnStatementSyntax CreateCodeBlockReturnStatementForHelper(bool hasParameters)
{
var arguments = hasParameters
? new SyntaxNodeOrToken[]
{
SyntaxArgumentFactory.Create("parameters"),
SyntaxTokenFactory.Comma(),
SyntaxArgumentFactory.Create("cancellationToken")
}
: new SyntaxNodeOrToken[]
{
SyntaxArgumentFactory.Create("cancellationToken")
};
return(SyntaxFactory.ReturnStatement(
SyntaxFactory.AwaitExpression(
SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName("handler"),
SyntaxFactory.IdentifierName("ExecuteAsync")))
.WithArgumentList(
SyntaxFactory.ArgumentList(
SyntaxFactory.SeparatedList <ArgumentSyntax>(arguments))))));
}
private MemberDeclarationSyntax CreateExecuteAsyncMethod(
string parameterTypeName,
string resultTypeName,
bool hasParameters)
{
var arguments = hasParameters
? new SyntaxNodeOrToken[]
{
SyntaxParameterFactory.Create(parameterTypeName, "parameters"),
SyntaxTokenFactory.Comma(),
SyntaxParameterFactory.Create(nameof(CancellationToken), nameof(CancellationToken).EnsureFirstCharacterToLower())
.WithDefault(SyntaxFactory.EqualsValueClause(
SyntaxFactory.LiteralExpression(SyntaxKind.DefaultLiteralExpression, SyntaxTokenFactory.DefaultKeyword()))),
}
: new SyntaxNodeOrToken[]
{
SyntaxParameterFactory.Create(nameof(CancellationToken), nameof(CancellationToken).EnsureFirstCharacterToLower())
.WithDefault(SyntaxFactory.EqualsValueClause(
SyntaxFactory.LiteralExpression(SyntaxKind.DefaultLiteralExpression, SyntaxTokenFactory.DefaultKeyword()))),
};
SyntaxTokenList methodModifiers;
BlockSyntax codeBlockSyntax;
if (hasParameters)
{
methodModifiers = SyntaxTokenListFactory.PublicKeyword();
codeBlockSyntax = SyntaxFactory.Block(
SyntaxIfStatementFactory.CreateParameterArgumentNullCheck("parameters", false),
SyntaxFactory.ReturnStatement(
SyntaxFactory.InvocationExpression(SyntaxFactory.IdentifierName("InvokeExecuteAsync"))
.WithArgumentList(
SyntaxArgumentListFactory.CreateWithTwoItems("parameters", nameof(CancellationToken).EnsureFirstCharacterToLower()))));
}
else
{
methodModifiers = SyntaxTokenListFactory.PublicAsyncKeyword();
var bodyBlockSyntaxStatements = CreateBodyBlockSyntaxStatements(resultTypeName);
codeBlockSyntax = SyntaxFactory.Block(bodyBlockSyntaxStatements);
}
return(SyntaxFactory.MethodDeclaration(
SyntaxFactory.GenericName(SyntaxFactory.Identifier(nameof(Task)))
.WithTypeArgumentList(
SyntaxFactory.TypeArgumentList(
SyntaxFactory.SingletonSeparatedList <TypeSyntax>(
SyntaxFactory.IdentifierName(EndpointResultTypeName)))),
SyntaxFactory.Identifier("ExecuteAsync"))
.WithModifiers(methodModifiers)
.WithParameterList(SyntaxFactory.ParameterList(SyntaxFactory.SeparatedList <ParameterSyntax>(arguments)))
.WithBody(codeBlockSyntax));
}
private MemberDeclarationSyntax CreateExecuteAsyncMethod(string parameterTypeName, string resultTypeName, bool hasParameters)
{
var arguments = hasParameters
? new SyntaxNodeOrToken[]
{
SyntaxParameterFactory.Create(parameterTypeName, "parameters"),
SyntaxTokenFactory.Comma(),
SyntaxParameterFactory.Create(nameof(CancellationToken), nameof(CancellationToken).EnsureFirstCharacterToLower())
.WithDefault(SyntaxFactory.EqualsValueClause(
SyntaxFactory.LiteralExpression(SyntaxKind.DefaultLiteralExpression, SyntaxTokenFactory.DefaultKeyword()))),
}
: new SyntaxNodeOrToken[]
{
SyntaxParameterFactory.Create(nameof(CancellationToken), nameof(CancellationToken).EnsureFirstCharacterToLower())
.WithDefault(SyntaxFactory.EqualsValueClause(
SyntaxFactory.LiteralExpression(SyntaxKind.DefaultLiteralExpression, SyntaxTokenFactory.DefaultKeyword()))),
};
var codeBody = hasParameters
? SyntaxFactory.Block(
SyntaxIfStatementFactory.CreateParameterArgumentNullCheck("parameters"),
SyntaxFactory.ReturnStatement(
SyntaxFactory.InvocationExpression(
SyntaxFactory.IdentifierName("InvokeExecuteAsync"))
.WithArgumentList(
SyntaxFactory.ArgumentList(
SyntaxFactory.SeparatedList <ArgumentSyntax>(
new SyntaxNodeOrToken[]
{
SyntaxFactory.Argument(SyntaxFactory.IdentifierName("parameters")),
SyntaxTokenFactory.Comma(),
SyntaxFactory.Argument(SyntaxFactory.IdentifierName(nameof(CancellationToken).EnsureFirstCharacterToLower())),
})))))
: SyntaxFactory.Block(
SyntaxThrowStatementFactory.CreateNotImplementedException());
return(SyntaxFactory.MethodDeclaration(
SyntaxFactory.GenericName(SyntaxFactory.Identifier(nameof(Task)))
.WithTypeArgumentList(
SyntaxFactory.TypeArgumentList(
SyntaxFactory.SingletonSeparatedList <TypeSyntax>(
SyntaxFactory.GenericName(
SyntaxFactory.Identifier("EndpointResult"))
.WithTypeArgumentList(
SyntaxFactory.TypeArgumentList(
SyntaxFactory.SingletonSeparatedList <TypeSyntax>(
SyntaxFactory.IdentifierName(resultTypeName))))))),
SyntaxFactory.Identifier("ExecuteAsync"))
.WithModifiers(SyntaxTokenListFactory.PublicKeyword())
.WithParameterList(SyntaxFactory.ParameterList(SyntaxFactory.SeparatedList <ParameterSyntax>(arguments)))
.WithBody(codeBody));
}
private static ParameterListSyntax CreateParameterList(
bool hasParametersOrRequestBody,
string parameterTypeName,
string interfaceName,
bool useFromServicesAttributeOnInterface)
{
ParameterListSyntax parameterList;
if (hasParametersOrRequestBody)
{
if (useFromServicesAttributeOnInterface)
{
parameterList = SyntaxFactory.ParameterList(
SyntaxFactory.SeparatedList <ParameterSyntax>(
new SyntaxNodeOrToken[]
{
SyntaxParameterFactory.Create(parameterTypeName, "parameters"),
SyntaxTokenFactory.Comma(),
SyntaxParameterFactory.CreateWithAttribute(nameof(FromServicesAttribute), interfaceName, "handler"),
SyntaxTokenFactory.Comma(),
SyntaxParameterFactory.Create(nameof(CancellationToken), nameof(CancellationToken).EnsureFirstCharacterToLower())
}));
}
else
{
parameterList = SyntaxFactory.ParameterList(
SyntaxFactory.SeparatedList <ParameterSyntax>(
new SyntaxNodeOrToken[]
{
SyntaxParameterFactory.Create(parameterTypeName, "parameters"),
SyntaxTokenFactory.Comma(),
SyntaxParameterFactory.Create(interfaceName, "handler"),
SyntaxTokenFactory.Comma(),
SyntaxParameterFactory.Create(nameof(CancellationToken), nameof(CancellationToken).EnsureFirstCharacterToLower())
}));
}
}
else
{
parameterList = SyntaxFactory.ParameterList(
SyntaxFactory.SeparatedList <ParameterSyntax>(
new SyntaxNodeOrToken[]
{
SyntaxParameterFactory.CreateWithAttribute(nameof(FromServicesAttribute), interfaceName, "handler"),
SyntaxTokenFactory.Comma(),
SyntaxParameterFactory.Create(nameof(CancellationToken), nameof(CancellationToken).EnsureFirstCharacterToLower())
}));
}
return(parameterList);
}
private static MethodDeclarationSyntax CreateTypeRequestWithObject(
string className,
HttpStatusCode httpStatusCode,
string typeRequestName,
string parameterName = "message")
{
return(SyntaxFactory.MethodDeclaration(
SyntaxFactory.IdentifierName(className),
SyntaxFactory.Identifier(httpStatusCode.ToNormalizedString()))
.WithModifiers(SyntaxTokenListFactory.PublicStaticKeyword())
.WithParameterList(
SyntaxFactory.ParameterList(
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.Parameter(SyntaxFactory.Identifier(parameterName))
.WithType(SyntaxFactory.NullableType(SyntaxFactory.PredefinedType(SyntaxTokenFactory.StringKeyword())))
.WithDefault(
SyntaxFactory.EqualsValueClause(
SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression))))))
.WithExpressionBody(
SyntaxFactory.ArrowExpressionClause(
SyntaxObjectCreationExpressionFactory.Create(className)
.WithArgumentList(
SyntaxFactory.ArgumentList(
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.Argument(
SyntaxObjectCreationExpressionFactory.Create(typeRequestName)
.WithInitializer(
SyntaxFactory.InitializerExpression(
SyntaxKind.ObjectInitializerExpression,
SyntaxFactory.SeparatedList <ExpressionSyntax>(
new SyntaxNodeOrToken[]
{
SyntaxFactory.AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
SyntaxFactory.IdentifierName("StatusCode"),
SyntaxFactory.CastExpression(
SyntaxFactory.PredefinedType(
SyntaxFactory.Token(SyntaxKind.IntKeyword)),
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName(nameof(HttpStatusCode)),
SyntaxFactory.IdentifierName(httpStatusCode.ToNormalizedString())))),
SyntaxTokenFactory.Comma(),
SyntaxFactory.AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
SyntaxFactory.IdentifierName("Content"),
SyntaxFactory.IdentifierName(parameterName)),
})))))))))
.WithSemicolonToken(SyntaxTokenFactory.Semicolon()));
}
private static ArgumentListSyntax CreateOneParameterArg(string parameterNameTo, string parameterNameFrom) =>
SyntaxFactory.ArgumentList(
SyntaxFactory.SeparatedList <ArgumentSyntax>(
new SyntaxNodeOrToken[]
{
SyntaxFactory.Argument(
SyntaxFactory.LiteralExpression(
SyntaxKind.StringLiteralExpression,
SyntaxFactory.Literal(parameterNameTo))),
SyntaxTokenFactory.Comma(),
SyntaxFactory.Argument(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName("parameters"),
SyntaxFactory.IdentifierName(parameterNameFrom))),
}));
private static MethodDeclarationSyntax CreateTypeRequestWithSpecifiedResultFactoryMethodWithMessageAllowNull(
string resultFactoryMethodName,
string className,
HttpStatusCode httpStatusCode,
string parameterName = "message")
{
return(SyntaxFactory.MethodDeclaration(
SyntaxFactory.IdentifierName(className),
SyntaxFactory.Identifier(httpStatusCode.ToNormalizedString()))
.WithModifiers(SyntaxTokenListFactory.PublicStaticKeyword())
.WithParameterList(
SyntaxFactory.ParameterList(
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.Parameter(SyntaxFactory.Identifier(parameterName))
.WithType(SyntaxFactory.NullableType(SyntaxFactory.PredefinedType(SyntaxTokenFactory.StringKeyword())))
.WithDefault(
SyntaxFactory.EqualsValueClause(
SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression))))))
.WithExpressionBody(
SyntaxFactory.ArrowExpressionClause(
SyntaxFactory.ObjectCreationExpression(
SyntaxFactory.IdentifierName(className))
.WithArgumentList(
SyntaxFactory.ArgumentList(
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.Argument(
SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName("ResultFactory"),
SyntaxFactory.IdentifierName(resultFactoryMethodName)))
.WithArgumentList(
SyntaxFactory.ArgumentList(
SyntaxFactory.SeparatedList <ArgumentSyntax>(
new SyntaxNodeOrToken[]
{
SyntaxFactory.Argument(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName(nameof(HttpStatusCode)),
SyntaxFactory.IdentifierName(httpStatusCode.ToString()))),
SyntaxTokenFactory.Comma(),
SyntaxFactory.Argument(SyntaxFactory.IdentifierName(parameterName)),
})))))))))
.WithSemicolonToken(SyntaxTokenFactory.Semicolon()));
}
private static MethodDeclarationSyntax CreateTypeRequestWithProblemDetailsWithMessage(
string className,
HttpStatusCode httpStatusCode,
string parameterName = "message")
{
return(SyntaxFactory.MethodDeclaration(
SyntaxFactory.IdentifierName(className),
SyntaxFactory.Identifier(httpStatusCode.ToNormalizedString()))
.WithModifiers(SyntaxTokenListFactory.PublicStaticKeyword())
.WithParameterList(
SyntaxFactory.ParameterList(
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.Parameter(SyntaxFactory.Identifier(parameterName))
.WithType(SyntaxFactory.PredefinedType(SyntaxTokenFactory.StringKeyword())))))
.WithExpressionBody(
SyntaxFactory.ArrowExpressionClause(
SyntaxFactory.ObjectCreationExpression(
SyntaxFactory.IdentifierName(className))
.WithArgumentList(
SyntaxFactory.ArgumentList(
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.Argument(
SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName("ResultFactory"),
SyntaxFactory.IdentifierName("CreateContentResultWithProblemDetails")))
.WithArgumentList(
SyntaxFactory.ArgumentList(
SyntaxFactory.SeparatedList <ArgumentSyntax>(
new SyntaxNodeOrToken[]
{
SyntaxFactory.Argument(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName(nameof(HttpStatusCode)),
SyntaxFactory.IdentifierName(httpStatusCode.ToString()))),
SyntaxTokenFactory.Comma(),
SyntaxFactory.Argument(SyntaxFactory.IdentifierName(parameterName))
})))))))))
.WithSemicolonToken(SyntaxTokenFactory.Semicolon()));
}
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))))));
}
private ReturnStatementSyntax CreateInvokeExecuteAsyncMethodBlockReturn(string resultTypeName)
{
return(SyntaxFactory.ReturnStatement(
SyntaxFactory.AwaitExpression(
SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName("httpExchangeFactory"),
SyntaxFactory.IdentifierName("FromResponse")))
.WithArgumentList(
SyntaxFactory.ArgumentList(
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.Argument(
SyntaxFactory.IdentifierName("response"))))),
SyntaxFactory.GenericName(
SyntaxFactory.Identifier("AddSuccessResponse")) // TODO: nameof
.WithTypeArgumentList(
SyntaxFactory.TypeArgumentList(
SyntaxFactory.SingletonSeparatedList <TypeSyntax>(
SyntaxFactory.IdentifierName(resultTypeName))))))
.WithArgumentList(CreateResponseArgHttpStatusCode(HttpStatusCode.OK)),
SyntaxFactory.GenericName(
SyntaxFactory.Identifier("AddErrorResponse")) // TODO: nameof
.WithTypeArgumentList(
SyntaxFactory.TypeArgumentList(
SyntaxFactory.SingletonSeparatedList <TypeSyntax>(
SyntaxFactory.IdentifierName("ProblemDetails")))))) // TODO: nameof
.WithArgumentList(CreateResponseArgHttpStatusCode(HttpStatusCode.BadRequest)),
SyntaxFactory.IdentifierName("AddErrorResponse"))) // TODO: nameof
.WithArgumentList(CreateResponseArgHttpStatusCode(HttpStatusCode.NotFound)),
SyntaxFactory.IdentifierName("BuildResponseAsync"))) // TODO: nameof
.WithArgumentList(
SyntaxFactory.ArgumentList(
SyntaxFactory.SeparatedList <ArgumentSyntax>(
new SyntaxNodeOrToken[]
{
SyntaxFactory.Argument(
SyntaxFactory.SimpleLambdaExpression(
SyntaxFactory.Parameter(
SyntaxFactory.Identifier("x")))
.WithExpressionBody(
SyntaxFactory.ObjectCreationExpression(
SyntaxFactory.GenericName(
SyntaxFactory.Identifier("EndpointResult")) // TODO: nameof
.WithTypeArgumentList(
SyntaxFactory.TypeArgumentList(
SyntaxFactory.SingletonSeparatedList <TypeSyntax>(
SyntaxFactory.IdentifierName(resultTypeName)))))
.WithArgumentList(
SyntaxFactory.ArgumentList(
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.Argument(
SyntaxFactory.IdentifierName("x"))))))),
SyntaxTokenFactory.Comma(),
SyntaxFactory.Argument(SyntaxFactory.IdentifierName("cancellationToken")),
}))))));
}