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 static MethodDeclarationSyntax CreateMembersForEndpointsPrivateHelper(
KeyValuePair <OperationType, OpenApiOperation> apiOperation,
bool hasRouteParameters)
{
var operationName = apiOperation.Value.GetOperationName();
var interfaceName = "I" + operationName + NameConstants.ContractHandler;
var methodName = $"Invoke{operationName}Async";
var parameterTypeName = operationName + NameConstants.ContractParameters;
var hasParametersOrRequestBody = apiOperation.Value.HasParametersOrRequestBody() || hasRouteParameters;
// Create method # use CreateParameterList & CreateCodeBlockReturnStatement
var methodDeclaration = SyntaxFactory.MethodDeclaration(
SyntaxFactory.GenericName(SyntaxFactory.Identifier(nameof(Task)))
.WithTypeArgumentList(SyntaxTypeArgumentListFactory.CreateWithOneItem(nameof(ActionResult))),
SyntaxFactory.Identifier(methodName))
.AddModifiers(SyntaxTokenFactory.PrivateKeyword())
.AddModifiers(SyntaxTokenFactory.StaticKeyword())
.AddModifiers(SyntaxTokenFactory.AsyncKeyword())
.WithParameterList(CreateParameterList(hasParametersOrRequestBody, parameterTypeName, interfaceName, false))
.WithBody(
SyntaxFactory.Block(
CreateCodeBlockReturnStatementForHelper(hasParametersOrRequestBody)));
return(methodDeclaration);
}
public static PropertyDeclarationSyntax CreateListAuto(
string dataType,
string propertyName,
bool initializeList = true)
{
var propertyDeclaration = SyntaxFactory.PropertyDeclaration(
SyntaxFactory.GenericName(SyntaxFactory.Identifier(Microsoft.OpenApi.Models.NameConstants.List))
.WithTypeArgumentList(SyntaxTypeArgumentListFactory.CreateWithOneItem(dataType)),
SyntaxFactory.Identifier(propertyName))
.AddModifiers(SyntaxTokenFactory.PublicKeyword())
.WithAccessorList(
SyntaxFactory.AccessorList(
SyntaxFactory.List(
new[]
{
SyntaxAccessorDeclarationFactory.Get(),
SyntaxAccessorDeclarationFactory.Set(),
})));
if (initializeList)
{
propertyDeclaration = propertyDeclaration.WithInitializer(
SyntaxFactory.EqualsValueClause(
SyntaxFactory.ObjectCreationExpression(
SyntaxFactory.GenericName(SyntaxFactory.Identifier(Microsoft.OpenApi.Models.NameConstants.List))
.WithTypeArgumentList(SyntaxTypeArgumentListFactory.CreateWithOneItem(dataType)))
.WithArgumentList(
SyntaxFactory.ArgumentList())))
.WithSemicolonToken(SyntaxTokenFactory.Semicolon());
}
return(propertyDeclaration);
}
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 MethodDeclarationSyntax CreateMembersForEndpoints(
KeyValuePair <OperationType, OpenApiOperation> apiOperation,
string urlPath,
string area,
bool hasRouteParameters)
{
var operationName = apiOperation.Value.GetOperationName();
var interfaceName = "I" + operationName + NameConstants.ContractHandler;
var methodName = operationName + "Async";
var helperMethodName = $"Invoke{operationName}Async";
var parameterTypeName = operationName + NameConstants.ContractParameters;
// Create method # use CreateParameterList & CreateCodeBlockReturnStatement
var methodDeclaration = SyntaxFactory.MethodDeclaration(
SyntaxFactory.GenericName(SyntaxFactory.Identifier(nameof(Task)))
.WithTypeArgumentList(SyntaxTypeArgumentListFactory.CreateWithOneItem(nameof(ActionResult))),
SyntaxFactory.Identifier(methodName))
.AddModifiers(SyntaxTokenFactory.PublicKeyword())
.WithParameterList(CreateParameterList(apiOperation.Value.HasParametersOrRequestBody() || hasRouteParameters, parameterTypeName, interfaceName, true))
.WithBody(
SyntaxFactory.Block(
SyntaxIfStatementFactory.CreateParameterArgumentNullCheck("handler", false),
CreateCodeBlockReturnStatement(helperMethodName, apiOperation.Value.HasParametersOrRequestBody() || hasRouteParameters)));
// Create and add Http-method-attribute
var httpAttributeRoutePart = GetHttpAttributeRoutePart(urlPath);
methodDeclaration = string.IsNullOrEmpty(httpAttributeRoutePart)
? methodDeclaration.AddAttributeLists(
SyntaxAttributeListFactory.Create($"Http{apiOperation.Key}"))
: methodDeclaration.AddAttributeLists(
SyntaxAttributeListFactory.CreateWithOneItemWithOneArgument(
$"Http{apiOperation.Key}",
httpAttributeRoutePart));
// Create and add RequestFormLimits-attribute
if (apiOperation.Value.HasRequestBodyWithAnythingAsFormatTypeBinary())
{
methodDeclaration = methodDeclaration.AddAttributeLists(
SyntaxAttributeListFactory.Create(
"RequestFormLimits(MultipartBodyLengthLimit = long.MaxValue)"));
}
// Create and add producesResponseTypes-attributes
var producesResponseAttributeParts = apiOperation.Value.Responses.GetProducesResponseAttributeParts(
OperationSchemaMappings,
area,
ApiProjectOptions.ProjectName,
ApiProjectOptions.ApiOptions.Generator.Response.UseProblemDetailsAsDefaultBody,
apiOperation.Value.HasParametersOrRequestBody(),
includeIfNotDefinedAuthorization: false,
includeIfNotDefinedInternalServerError: false);
return(producesResponseAttributeParts
.Aggregate(
methodDeclaration,
(current, producesResponseAttributePart) => current.AddAttributeLists(
SyntaxAttributeListFactory.Create(producesResponseAttributePart))));
}
public void CreateWithOneItem()
{
// Arrange
var expected = SyntaxFactory.TypeArgumentList(
SyntaxFactory.SingletonSeparatedList <TypeSyntax>(
SyntaxFactory.IdentifierName("int")));
// Act
var actual = SyntaxTypeArgumentListFactory.CreateWithOneItem("int");
// Assert
Assert.Equal(expected.ToFullString(), actual.ToFullString());
}
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(SyntaxTypeArgumentListFactory.CreateWithOneItem(resultTypeName)),
SyntaxFactory.Identifier("ExecuteAsync"))
.WithModifiers(SyntaxTokenListFactory.PublicKeyword())
.WithParameterList(SyntaxFactory.ParameterList(SyntaxFactory.SeparatedList <ParameterSyntax>(arguments)))
.WithBody(codeBody));
}
public void CreateWithTwoItems()
{
// Arrange
var expected = SyntaxFactory.TypeArgumentList(
SyntaxFactory.SeparatedList <TypeSyntax>(
new SyntaxNodeOrToken[]
{
SyntaxFactory.IdentifierName("int"),
SyntaxFactory.Token(SyntaxTriviaList.Empty, SyntaxKind.CommaToken, new SyntaxTriviaList(SyntaxFactory.Space)),
SyntaxFactory.IdentifierName("bool"),
}));
// Act
var actual = SyntaxTypeArgumentListFactory.CreateWithTwoItems("int", "bool");
// Assert
Assert.Equal(expected.ToFullString(), actual.ToFullString());
}
