private static MethodDeclarationSyntax CreateTypeRequestWithMessage(
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.PredefinedType(SyntaxTokenFactory.StringKeyword())))))
.WithExpressionBody(
SyntaxFactory.ArrowExpressionClause(
SyntaxObjectCreationExpressionFactory.Create(className)
.WithArgumentList(
SyntaxFactory.ArgumentList(
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.Argument(
SyntaxObjectCreationExpressionFactory.Create(typeRequestName)
.WithArgumentList(
SyntaxArgumentListFactory.CreateWithOneItem(parameterName))))))))
.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)));
}
public static MemberDeclarationSyntax?CreateToStringMethod(IDictionary <string, OpenApiSchema> apiSchemaProperties)
{
if (apiSchemaProperties == null)
{
throw new ArgumentNullException(nameof(apiSchemaProperties));
}
var content = new List <InterpolatedStringContentSyntax>();
if (apiSchemaProperties.Count > 0)
{
var lastKey = apiSchemaProperties.Keys.Last();
foreach (var schema in apiSchemaProperties)
{
var name = schema.Key.EnsureFirstCharacterToUpper();
var hasAnyProperties = schema.Value.HasAnyProperties();
if (!hasAnyProperties)
{
content.Add(SyntaxInterpolatedFactory.CreateNameOf(name));
content.Add(SyntaxInterpolatedFactory.StringTextColon());
content.Add(SyntaxFactory.Interpolation(SyntaxFactory.IdentifierName(name)));
}
else
{
content.Add(SyntaxInterpolatedFactory.CreateNameOf(name));
content.Add(SyntaxInterpolatedFactory.StringTextColonAndParenthesesStart());
content.Add(SyntaxFactory.Interpolation(SyntaxFactory.IdentifierName(name)));
content.Add(SyntaxInterpolatedFactory.StringTextParenthesesEnd());
}
if (schema.Key != lastKey)
{
content.Add(SyntaxInterpolatedFactory.StringTextComma());
}
}
}
if (content.Count == 0)
{
return(null);
}
var codeBody = SyntaxFactory.Block(
SyntaxFactory.SingletonList <StatementSyntax>(
SyntaxFactory.ReturnStatement(
SyntaxFactory.InterpolatedStringExpression(
SyntaxFactory.Token(SyntaxKind.InterpolatedStringStartToken))
.WithContents(SyntaxFactory.List(content)))));
return(SyntaxFactory.MethodDeclaration(
SyntaxFactory.PredefinedType(SyntaxTokenFactory.StringKeyword()),
SyntaxFactory.Identifier("ToString"))
.WithModifiers(SyntaxTokenListFactory.PublicOverrideKeyword())
.WithBody(codeBody));
}
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()));
}
public static PropertyDeclarationSyntax CreateAuto(
ParameterLocation?parameterLocation,
bool isNullable,
bool isRequired,
string dataType,
string propertyName,
bool useNullableReferenceTypes,
IOpenApiAny?initializer)
{
switch (useNullableReferenceTypes)
{
case true when !isRequired && (isNullable || parameterLocation == ParameterLocation.Query):
case true when isRequired && isNullable:
dataType += "?";
break;
}
var propertyDeclaration = CreateAuto(dataType, propertyName);
if (initializer is null)
{
return(propertyDeclaration);
}
switch (initializer)
{
case OpenApiInteger apiInteger:
propertyDeclaration = propertyDeclaration.WithInitializer(
SyntaxFactory.EqualsValueClause(
SyntaxFactory.LiteralExpression(
SyntaxKind.NumericLiteralExpression,
SyntaxFactory.Literal(apiInteger !.Value))))
.WithSemicolonToken(SyntaxTokenFactory.Semicolon());
break;
case OpenApiString apiString:
var expressionSyntax = string.IsNullOrEmpty(apiString !.Value)
? (ExpressionSyntax)SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.PredefinedType(SyntaxTokenFactory.StringKeyword()),
SyntaxFactory.IdentifierName("Empty"))
: SyntaxFactory.LiteralExpression(
SyntaxKind.StringLiteralExpression,
SyntaxFactory.Literal(apiString !.Value));
propertyDeclaration = propertyDeclaration.WithInitializer(
SyntaxFactory.EqualsValueClause(expressionSyntax))
.WithSemicolonToken(SyntaxTokenFactory.Semicolon());
break;
case OpenApiBoolean apiBoolean when apiBoolean.Value:
propertyDeclaration = propertyDeclaration.WithInitializer(
SyntaxFactory.EqualsValueClause(
SyntaxFactory.LiteralExpression(SyntaxKind.TrueLiteralExpression)))
.WithSemicolonToken(SyntaxTokenFactory.Semicolon());
break;
case OpenApiBoolean apiBoolean when !apiBoolean.Value:
propertyDeclaration = propertyDeclaration.WithInitializer(
SyntaxFactory.EqualsValueClause(
SyntaxFactory.LiteralExpression(SyntaxKind.FalseLiteralExpression)))
.WithSemicolonToken(SyntaxTokenFactory.Semicolon());
break;
default:
throw new NotImplementedException("Property initializer: " + initializer.GetType());
}
return(propertyDeclaration);
}
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 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()));
}