public static string FromDDBTableModel(TableDescription ddbTable)
{
var className = GetClassName(ddbTable);
var code = CompilationUnit();
code = code.AddUsings(DynamoUsingToken.NormalizeWhitespace());
var classDeclaration = ClassDeclaration(className)
.AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword))
.AddModifiers(SyntaxFactory.Token(SyntaxKind.PartialKeyword))
.AddAttributeLists(
AttributeList(
SingletonSeparatedList <AttributeSyntax>(
TableNameAttribute(ddbTable.TableName)
)
)
);
var properties = new List <MemberDeclarationSyntax>();
foreach (var ks in ddbTable.KeySchema)
{
var attr = ddbTable.AttributeDefinitions.Single(ad => ad.AttributeName == ks.AttributeName);
// if (prop == null || string.IsNullOrEmpty(prop.Name) || string.IsNullOrEmpty(prop.Type)) continue;
var property = PropertyDeclaration(ParseTypeName(FindType(attr.AttributeType)), attr.AttributeName)
.AddAccessorListAccessors(new AccessorDeclarationSyntax[]
{
AccessorDeclaration(SyntaxKind.GetAccessorDeclaration)
.WithSemicolonToken(Token(SyntaxKind.SemicolonToken)),
AccessorDeclaration(SyntaxKind.SetAccessorDeclaration)
.WithSemicolonToken(Token(SyntaxKind.SemicolonToken))
})
.NormalizeWhitespace();
if (ks.KeyType == HashType)
{
System.Console.WriteLine("Adding annotation...");
System.Console.WriteLine(HashKeyToken.ToFullString());
property = property.AddAttributeLists(
AttributeList(SingletonSeparatedList <AttributeSyntax>(
Attribute(HashKeyToken)
)
)
.NormalizeWhitespace());
}
else if (ks.KeyType == RangeType)
{
property = property.AddAttributeLists(
AttributeList(SingletonSeparatedList <AttributeSyntax>(
Attribute(RangeKeyToken)
)
)
.NormalizeWhitespace());
}
properties.Add(property);
}
classDeclaration = classDeclaration.AddMembers(properties.ToArray()).NormalizeWhitespace();
code = code.AddMembers(classDeclaration).NormalizeWhitespace();
System.Console.WriteLine(code.ToFullString());
return(code.ToFullString());
}
public override SyntaxNode?VisitUsingDirective(UsingDirectiveSyntax node)
{
if (unusedUsingSpan.Any(s => s.Contains(node.Span)))
{
return(null);
}
if (node.Parent.IsKind(SyntaxKind.CompilationUnit))
{
rootUsingsBuilder.Add(node.NormalizeWhitespace().ToString().Trim());
return(null);
}
return(base.VisitUsingDirective(node));
}
private static ICollection <UsingDirectiveSyntax> FormatUsings(IList <UsingDirectiveSyntax> usingsThatNeedToBeMoved)
{
var newList = new List <UsingDirectiveSyntax>(usingsThatNeedToBeMoved.Count);
for (int i = 0; i < usingsThatNeedToBeMoved.Count; i++)
{
UsingDirectiveSyntax usingNode = usingsThatNeedToBeMoved[i];
if (i == 0)
{
usingNode = usingNode.WithoutLeadingTrivia();
}
UsingDirectiveSyntax newNode = usingNode.NormalizeWhitespace().WithTrailingTrivia(SyntaxFactory.CarriageReturnLineFeed);
if (i == usingsThatNeedToBeMoved.Count - 1)
{
newNode = newNode.WithTrailingTrivia(SyntaxFactory.CarriageReturnLineFeed, SyntaxFactory.CarriageReturnLineFeed);
}
newList.Add(newNode);
}
return(newList);
}
private static NamespaceDeclarationSyntax AddUsing(NamespaceDeclarationSyntax nspaceSyntax, UsingDirectiveSyntax newUsing)
{
if (nspaceSyntax.Usings.Count > 0)
{
var lastUsing = nspaceSyntax.Usings.Last();
newUsing = newUsing
.WithLeadingTrivia(lastUsing.GetLeadingTrivia())
.WithTrailingTrivia(lastUsing.GetTrailingTrivia());
return nspaceSyntax.WithUsings(nspaceSyntax.Usings.Add(newUsing));
}
return nspaceSyntax.WithUsings(nspaceSyntax.Usings.Add(newUsing.NormalizeWhitespace()));
}
public void AddUsing(UsingDirectiveSyntax directive)
{
set.Add(directive.NormalizeWhitespace());
}
