public static ConstructorDeclarationSyntax CreateConstructorDeclaration(this CommandDefinitionModel entity)
{
var constructor = SyntaxFactory.ConstructorDeclaration(entity.ClassName)
.WithModifiers(SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword)));
return(constructor);
}
private static ConstructorDeclarationSyntax[] BuildConstructor(CommandDefinitionModel model)
{
var parameters = BuildConstructorTokenList(model.InputMetadata);
var constructor = model.CreateConstructorDeclaration()
.WithParameterList(
SyntaxFactory.ParameterList(
SyntaxFactory.SeparatedList <ParameterSyntax>(parameters)))
.WithBody(BuildConstructorAssignmentBlock(model.InputMetadata));
return(new ConstructorDeclarationSyntax[] { constructor });
}
private static SyntaxList <MemberDeclarationSyntax> CreateClassMembers(CommandDefinitionModel model)
{
var members = BuildMemberProperties(model.InputMetadata.Properties)
.OfType <MemberDeclarationSyntax>();
var constructors = BuildConstructor(model)
.OfType <MemberDeclarationSyntax>();
var memberList = SyntaxFactory.List(members.Union(constructors));
return(memberList);
}
private static SyntaxList <MemberDeclarationSyntax> CreateClassMembers(CommandDefinitionModel model)
{
var memberDeclaration = SyntaxFactory.MethodDeclaration(
SyntaxFactory.IdentifierName(model.ClassName),
SyntaxFactory.Identifier("ToCommand"))
.WithModifiers(
SyntaxFactory.TokenList(
new[] {
SyntaxFactory.Token(SyntaxKind.PublicKeyword),
SyntaxFactory.Token(SyntaxKind.StaticKeyword)
}))
.WithParameterList(
SyntaxFactory.ParameterList(
SyntaxFactory.SingletonSeparatedList <ParameterSyntax>(
SyntaxFactory.Parameter(
SyntaxFactory.Identifier("input"))
.WithModifiers(
SyntaxFactory.TokenList(
SyntaxFactory.Token(SyntaxKind.ThisKeyword)))
.WithType(
SyntaxFactory.IdentifierName(model.InputDtoClassName)))));
var argumentList = BuildArgumentsTokenList(model.InputMetadata);
memberDeclaration = memberDeclaration
.WithBody(
SyntaxFactory.Block(
SyntaxFactory.LocalDeclarationStatement(
SyntaxFactory.VariableDeclaration(
SyntaxFactory.IdentifierName("var"))
.WithVariables(
SyntaxFactory.SingletonSeparatedList <VariableDeclaratorSyntax>(
SyntaxFactory.VariableDeclarator(
SyntaxFactory.Identifier("command"))
.WithInitializer(
SyntaxFactory.EqualsValueClause(
SyntaxFactory.ObjectCreationExpression(
SyntaxFactory.IdentifierName(model.ClassName))
.WithArgumentList(
SyntaxFactory.ArgumentList(argumentList))))))),
SyntaxFactory.ReturnStatement(
SyntaxFactory.IdentifierName("command"))));
var memberDeclarationList = SyntaxFactory.SingletonList <MemberDeclarationSyntax>(memberDeclaration);
return(memberDeclarationList);
}
private static CommandDefinitionModel BuildModel(InputDtoClassLocator locator)
{
var model = new CommandDefinitionModel();
// set the class name to create the command with
var className = locator.InputDtoName.Replace("InputDTO", "Command");
model.ClassName = className;
// parse the input class
var entityParser = new EntityParser();
var entityMetadata = entityParser.Parse(locator.InputDtoNode);
model.InputMetadata = entityMetadata;
return(model);
}
private static CompilationUnitSyntax BuildClass(CommandDefinitionModel model)
{
// create root node
var root = CreateRoot();
// add default usings
root = root.AddUsings(GetDefaultUsings().ToArray())
.NormalizeWhitespace();
// create the namespace
var @namespace = CreateNamespace(model.Namespace);
// create the command class
var classDeclaration = SyntaxFactory.ClassDeclaration(model.ClassName);
// add set it accessibility to public
classDeclaration = classDeclaration
.AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword));
// add on the base class/interface implementations
classDeclaration = classDeclaration.WithBaseList(BuildBaseList());
// add on the member properties
classDeclaration = classDeclaration
.NormalizeWhitespace()
.WithMembers(CreateClassMembers(model));
// add the class to the namespace
@namespace = @namespace
.AddMembers(classDeclaration);
root = root
// add members to the root compilation unit
.AddMembers(@namespace);
return(root);
}
