private CodeGenerationConfiguration GetConfigurationFromFormInput()
{
var includeTables = IncludeTablesBox.Text.Split(',').Select(s => s.Trim()).ToArray();
if (IncludeTablesBox.Text.Trim().Length == 0)
{
includeTables = new string[0];
}
var excludeSchemas = ExcludeSchemasBox?.Text?.Split(',')?.Select(s => s.Trim())?.ToArray() ?? new string[0];
if (ExcludeSchemasBox?.Text?.Trim().Length == 0)
{
excludeSchemas = new string[0];
}
var connectionString = new SqlConnectionStringBuilder
{
DataSource = ServerNameBox.Text,
InitialCatalog = DatabaseNameBox.Text,
IntegratedSecurity = true
}.ToString();
var codeGenerationConfiguration = new CodeGenerationConfiguration
{
DatabaseName = DatabaseNameBox.Text,
ConnectionString = connectionString,
CoreNamespace = DtosNamespaceBox.Text.Replace(" ", string.Empty),
DataNamespace = GatewaysNamespaceBox.Text.Replace(" ", string.Empty),
IncludeTables = includeTables,
ExcludeSchemas = excludeSchemas
};
return(codeGenerationConfiguration);
}
public string GenerateGatewayClass(CodeGenerationConfiguration configuration, DatabaseTableDefinition tableDefinition)
{
var insertStatement = _sqlGenerator.GenerateInsert(tableDefinition);
var selectStatement = _sqlGenerator.GenerateSelect(tableDefinition);
const string template = @"using {0};
namespace {1}
{{
public class {2}DataGateway : GatewayBase
{{
public {2}DataGateway(string connectionString) : base(connectionString)
{{
}}
public {3}[] GetAll()
{{
const string sql = @""{4}"";
return GetFromDatabase<{3}>(sql, null);
}}
public int AddItems({3}[] dtos)
{{
const string sql = @""{5}"";
return AddToDatabase(sql, dtos);
}}
}}
}}";
return(string.Format(template, configuration.CoreNamespace, configuration.DataNamespace, tableDefinition.FormattedName, tableDefinition.DtoName, selectStatement, insertStatement));
}
private void WriteTemplate(CodeGenerationConfiguration.TemplateSetting template, XmlTextWriter writer)
{
writer.WriteStartElement("template");
writer.WriteAttributeString("name", template.Name);
writer.WriteAttributeString("id", template.Id.ToString());
writer.WriteAttributeString("base", template.BaseClass);
writer.WriteAttributeString("csname", template.ClassName);
writer.WriteAttributeString("access", template.AccessModifier);
writer.WriteAttributeString("path", template.Path);
writer.WriteStartElement("sections");
foreach (var section in template.FieldSettings.Values.GroupBy(f => f.Section))
{
writer.WriteStartElement("section");
writer.WriteAttributeString("name", section.Key);
foreach (var field in section)
{
writer.WriteStartElement("field");
writer.WriteAttributeString("name", field.Name);
writer.WriteAttributeString("csname", field.PropertyName);
writer.WriteAttributeString("cstype", field.CsType);
writer.WriteAttributeString("method", field.Method);
writer.WriteAttributeString("access", field.AccessModifier);
writer.WriteAttributeString("typeTable", field.TypeTable);
writer.WriteEndElement(); // field
}
writer.WriteEndElement();
}
writer.WriteEndElement(); // fields
writer.WriteEndElement(); // template
}
public void ProcessRequest(HttpContext context)
{
string configName = context.Request.QueryString["configuration"];
_configuration = CodeGenerationSettings.Instance.GetConfiguration(configName);
context.Response.ContentType = "text/plain";
using (XmlTextWriter writer = new XmlTextWriter(context.Response.OutputStream, Encoding.UTF8))
{
writer.Formatting = Formatting.Indented;
writer.WriteRaw("<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n");
writer.WriteStartElement("namespaces");
_templates = _configuration.GetTemplateSettings().ToDictionary(t => t.Path);
foreach (var nameSpace in _templates.Values.GroupBy(c => c.NameSpace))
{
writer.WriteStartElement("namespace");
writer.WriteAttributeString("name", nameSpace.Key);
foreach (var template in nameSpace)
WriteTemplate(template, writer);
writer.WriteEndElement();
}
writer.WriteEndElement();
}
}
private static void RemoveFeed(FeedConfigurationOptions options, CodeGenerationConfiguration configuration)
{
var feedName = options.Name?.Trim();
if (string.IsNullOrEmpty(feedName))
{
Console.WriteLine("No feed name provided");
Environment.ExitCode |= (int)ExitCodes.InvalidFeedName;
}
else
{
var feedItem = configuration.NugetFeeds.FirstOrDefault(x =>
x.Name.Equals(feedName, StringComparison.InvariantCultureIgnoreCase));
if (feedItem == null)
{
Console.WriteLine($"No feed with name {feedName} found");
Environment.ExitCode |= (int)ExitCodes.InvalidFeedName;
}
else
{
configuration.NugetFeeds.Remove(feedItem);
UpdateConfiguration(configuration);
Console.WriteLine($"Nuget feed {feedName} removed");
}
}
}
private static void Main()
{
var dtog = new DataTransferObjectGenerator();
var databaseTableDefinition = new DatabaseTableDefinition
{
Name = "Foobar",
Columns = new[]
{
new DatabaseColumnDefinition
{
SqlDataType = SqlDataType.NVarchar,
IsIdentity = false,
IsNullable = true,
Name = "Name"
},
new DatabaseColumnDefinition
{
SqlDataType = SqlDataType.Decimal,
IsIdentity = false,
IsNullable = true,
Name = "HeightInInches"
}
}
};
var codeGenerationConfiguration = new CodeGenerationConfiguration
{
CoreNamespace = "Birchy.Core"
};
var generate = dtog.GenerateCode(codeGenerationConfiguration, databaseTableDefinition);
System.Console.WriteLine(generate);
}
public string GenerateGatewayBaseObject(CodeGenerationConfiguration configuration)
{
string template = @"using System.Data;
using System.Data.SqlClient;
using System.Linq;
using Dapper;
namespace {0}
{{
public abstract class GatewayBase
{{
private readonly string _connectionString;
protected GatewayBase(string connectionString)
{{
_connectionString = connectionString;
}}
private SqlConnection ConnectionFactory()
{{
return new SqlConnection(_connectionString);
}}
protected T[] GetFromDatabase<T>(string sql, object param)
{{
T[] data;
using (var connection = ConnectionFactory())
{{
connection.Open();
data = connection.Query<T>(sql, param).ToArray();
connection.Close();
}}
return data;
}}
protected int AddToDatabase(string sql, object param)
{{
int rowCount;
using (var connection = ConnectionFactory())
{{
connection.Open();
using (IDbTransaction transAction = connection.BeginTransaction())
{{
rowCount = connection.Execute(sql, param, transAction);
transAction.Commit();
connection.Close();
}}
}}
return rowCount;
}}
}}
}}";
return(string.Format(template, configuration.DataNamespace));
}
private static void UpdateConfiguration(CodeGenerationConfiguration configuration)
{
var container = new ConfigurationRootElement
{
Build = configuration
};
var serialized = JsonConvert.SerializeObject(container, Formatting.Indented);
var configFilePath = GetConfigFilePath();
File.WriteAllText(configFilePath, serialized);
}
public void GenerateCode_CreatesCorrectDtoSourceCode_UgleColumnNames()
{
var dataTransferObjectGenerator = GetGenerator();
var codeGenerationConfiguration = new CodeGenerationConfiguration {
CoreNamespace = "Birchy.Core"
};
var databaseTableDefinition = new DatabaseTableDefinition
{
Name = "TestTable",
ObjectId = 101,
SchemaName = "dbo",
Columns = new[]
{
new DatabaseColumnDefinition
{
Name = "Foo_Id",
IsIdentity = true,
IsNullable = true,
SqlDataType = SqlDataType.Integer
},
new DatabaseColumnDefinition
{
Name = "bar_id",
IsIdentity = false,
IsNullable = false,
SqlDataType = SqlDataType.Integer
},
new DatabaseColumnDefinition
{
Name = "BazName",
SqlDataType = SqlDataType.NVarchar,
IsNullable = true,
IsIdentity = false
},
new DatabaseColumnDefinition
{
Name = "birchy_weight",
SqlDataType = SqlDataType.Decimal,
IsIdentity = false,
IsNullable = true
}
}
};
var generateCode = dataTransferObjectGenerator.GenerateCode(codeGenerationConfiguration, databaseTableDefinition);
Assert.Contains("public class TestTableDto", generateCode);
Assert.Contains("public int? FooId", generateCode);
Assert.Contains("public int BarId", generateCode);
Assert.Contains("public string BazName", generateCode);
Assert.Contains("public decimal? BirchyWeight", generateCode);
Assert.Contains("namespace Birchy.Core", generateCode);
}
private static MethodDeclarationSyntax GenerateFactoryMethod(CodeGenerationConfiguration configuration)
{
return(SyntaxFactory.MethodDeclaration(SyntaxFactory.ParseTypeName(ProviderConnectionType), FactoryMethodName)
.AddModifiers(SyntaxFactory.Token(SyntaxKind.PrivateKeyword))
.AddBodyStatements(
SyntaxFactory.ReturnStatement(
SyntaxFactory.ObjectCreationExpression(SyntaxFactory.ParseTypeName(ProviderConnectionType))
.WithArgumentList(SyntaxFactory.ArgumentList()
.AddArguments(
SyntaxFactory.Argument(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.ParseExpression(SettingsFieldName),
SyntaxFactory.Token(SyntaxKind.DotToken),
SyntaxFactory.IdentifierName(configuration.ConnectionStringName))))))));
}
public GeneratedDataAccessLayer GenerateDataAccessLayer(CodeGenerationConfiguration configuration)
{
var databaseTableDefinitions = _tableInfoRepository.GetDefinitions(configuration);
var generateGatewayBaseObject = _baseObjectGenerator.GenerateGatewayBaseObject(configuration);
return(new GeneratedDataAccessLayer
{
GatewayBaseCode = generateGatewayBaseObject,
TableLevelCode = databaseTableDefinitions.Select(s => new GeneratedCode
{
GatewayCode = _gatewayGenerator.GenerateGatewayClass(configuration, s),
EntityName = s.FormattedName,
DataTransferObjectCode = _dtoGenerator.GenerateCode(configuration, s)
}).ToArray()
});
}
public string GenerateGatewayBaseObject(CodeGenerationConfiguration configuration)
{
var compilationUnit = SyntaxFactory.CompilationUnit()
.AddUsings(GenerateUsings())
.AddMembers(configuration.DataNamespaceSyntax()
.AddMembers(SyntaxFactory.ClassDeclaration(configuration.DalBaseClassName)
.AddModifiers(GetClassModifiers())
.AddMembers(
GenerateSettingsField(),
GenerateConstructor(configuration),
GenerateFactoryMethod(configuration),
GenerateGetManyMethod()
)
));
return(compilationUnit.ToFormattedSource(Workspace));
}
private static ConstructorDeclarationSyntax GenerateConstructor(CodeGenerationConfiguration configuration)
{
return(SyntaxFactory.ConstructorDeclaration(configuration.DalBaseClassName)
.AddModifiers(SyntaxFactory.Token(SyntaxKind.ProtectedKeyword))
.AddParameterListParameters(
SyntaxFactory.Parameter(new SyntaxList <AttributeListSyntax>(), new SyntaxTokenList(),
SyntaxFactory.ParseTypeName(SettingsInterfaceName),
SyntaxFactory.Identifier(SettingsParamName), null)
)
.AddBodyStatements(
SyntaxFactory.ExpressionStatement(
SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression,
SyntaxFactory.IdentifierName(SettingsFieldName),
SyntaxFactory.Token(SyntaxKind.EqualsToken),
SyntaxFactory.IdentifierName(SettingsParamName))
)
));
}
private static void CheckConfigAndGenCode(MappingConfiguration config, string pathSuffix, bool allPropertiesAndFieldsShouldBeMapped = true)
{
string missingMaps;
var areAllMapsComplete = config.AreAllMapsComplete(out missingMaps, allPropertiesAndFieldsShouldBeMapped);
Console.WriteLine("Is complete = " + areAllMapsComplete);
if (!areAllMapsComplete)
{
Console.WriteLine("Missing maps = " + missingMaps);
}
else
{
var solutionConfiguration = new SolutionConfiguration(@"C:\src\temp\Generated\"+pathSuffix, "temp");
var codeGenerationConfiguration = new CodeGenerationConfiguration();
codeGenerationConfiguration.AddNullChecksForNestedPropertiesAndFields = false;
codeGenerationConfiguration.DefineAMethodForEachPropertyOrFieldBeingMappedByAMapper = false;
SolutionGenerator.GenerateOnlyMappers(solutionConfiguration, config, codeGenerationConfiguration);
}
}
public string GenerateCode(CodeGenerationConfiguration config, DatabaseTableDefinition tableDefinition)
{
SyntaxNode compilationUnitSyntax = SyntaxFactory.CompilationUnit()
.AddUsings(
CreateUsingDirectives())
.AddMembers(
SyntaxFactory.NamespaceDeclaration(SyntaxFactory.ParseName(config.CoreNamespace))
.AddMembers(
SyntaxFactory.ClassDeclaration(tableDefinition.DtoName)
.AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword))
.AddMembers(BuildPropertyMembers(tableDefinition))
)
);
var adhocWorkspace = new AdhocWorkspace();
var syntaxNode = Formatter.Format(compilationUnitSyntax, adhocWorkspace);
return(syntaxNode.ToFullString());
}
public DatabaseTableDefinition[] GetDefinitions(CodeGenerationConfiguration configuration)
{
var columnInfoGateway = ColumnInfoGatewayFactory(configuration);
var tableInfoGateway = TableInfoGatewayFactory(configuration);
var tableInfoDtos = tableInfoGateway.GetAll();
var columnDtos = columnInfoGateway.GetAll();
var columnDtoses = columnDtos.GroupBy(g => g.ObjectId)
.ToDictionary(k => k.Key, v => v.Select(s => s).ToArray());
var relevantTables = tableInfoDtos
.Where(d => SchemaNotExcluded(configuration, d) && TableIsIncluded(configuration, d))
.ToArray();
var tableDefinitions = new List <DatabaseTableDefinition>();
foreach (var relevantTable in relevantTables)
{
tableDefinitions.Add(new DatabaseTableDefinition(relevantTable, columnDtoses));
}
return(tableDefinitions.ToArray());
}
private static void AddFeed(FeedConfigurationOptions options, CodeGenerationConfiguration configuration)
{
var feedName = options.Name?.Trim();
if (string.IsNullOrEmpty(feedName))
{
Console.WriteLine("No feed name provided");
Environment.ExitCode |= (int)ExitCodes.InvalidFeedName;
return;
}
var source = options.Source?.Trim();
if (string.IsNullOrEmpty(source))
{
Console.WriteLine("No feed source provided");
Environment.ExitCode |= (int)ExitCodes.InvalidFeedSource;
return;
}
var feedItemExists = configuration.NugetFeeds.Any(x =>
x.Name.Equals(feedName, StringComparison.InvariantCultureIgnoreCase));
if (feedItemExists)
{
Console.WriteLine($"Feed with name {feedName} already exists");
Environment.ExitCode |= (int)ExitCodes.InvalidFeedName;
}
else
{
var feedItem = new NugetSourceConfiguration
{
Name = feedName,
Source = source,
ProtocolVersion = options.ProtocolVersion
};
configuration.NugetFeeds.Add(feedItem);
UpdateConfiguration(configuration);
Console.WriteLine($"Nuget feed {feedName} added");
}
}
public GeneratedCode[] GenerateCode(CodeGenerationConfiguration configuration)
{
var databaseTableDefinitions = _tableInfoRepository.GetDefinitions(configuration);
List <GeneratedCode> generatedCode = new List <GeneratedCode>();
foreach (var databaseTableDefinition in databaseTableDefinitions)
{
var generateInsert = _sqlGenerator.GenerateInsert(databaseTableDefinition);
var generateSelect = _sqlGenerator.GenerateSelect(databaseTableDefinition);
var generatedDto = _dtoGenerator.GenerateCode(configuration, databaseTableDefinition);
generatedCode.Add(new GeneratedCode
{
EntityName = databaseTableDefinition.FormattedName,
DataTransferObjectCode = generatedDto,
SqlCode = $"{generateSelect}\r\n--================\r\n{generateInsert}"
});
}
return(generatedCode.ToArray());
}
public string CreateSettingsInterface(CodeGenerationConfiguration configuration)
{
SyntaxNode compilationUnitSyntax = SyntaxFactory.CompilationUnit()
.AddMembers(
SyntaxFactory.NamespaceDeclaration(SyntaxFactory.ParseName(configuration.CoreNamespace))
.AddMembers(
SyntaxFactory.InterfaceDeclaration("IDatabaseSettings")
.AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword))
.AddMembers(
SyntaxFactory.PropertyDeclaration(SyntaxFactory.ParseTypeName("string"),
configuration.ConnectionStringName)
.AddAccessorListAccessors(
SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration)
.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)))
)
));
var syntaxNode = Formatter.Format(compilationUnitSyntax, WorkSpace);
return(syntaxNode.ToFullString());
}
private static void ShowFeeds(FeedConfigurationOptions options, CodeGenerationConfiguration configuration)
{
if (configuration.NugetFeeds == null || !configuration.NugetFeeds.Any())
{
Console.WriteLine("<not set>");
}
else
{
var maxNameLength = configuration
.NugetFeeds
.Select(f => f.Name.Length)
.Max();
Console.WriteLine($"{"Name",-24} Source");
foreach (var feed in configuration.NugetFeeds)
{
var protocolVersionSuffix = feed.ProtocolVersion > 0 ? $" (protocol {feed.ProtocolVersion})" : "";
Console.WriteLine($"{feed.Name,-24} {feed.Source}{protocolVersionSuffix}");
}
}
}
public GeneratedCode[] GenerateCode(CodeGenerationConfiguration configuration)
{
return(_repository.GenerateCode(configuration));
}
public static NamespaceDeclarationSyntax ContractNamespaceSyntax(this CodeGenerationConfiguration config)
{
return(SyntaxFactory.NamespaceDeclaration(SyntaxFactory.ParseName(config.ContractNamespace)));
}
private static bool SchemaNotExcluded(CodeGenerationConfiguration configuration, TableInfoDto d)
{
return((!configuration?.ExcludeSchemas?.Contains(d.SchemaName, StringComparer.OrdinalIgnoreCase) ??
true) ||
(configuration.ExcludeSchemas.Length == 0));
}
private static bool TableIsIncluded(CodeGenerationConfiguration configuration, TableInfoDto d)
{
return((configuration?.IncludeTables?.Contains(d.Name, StringComparer.OrdinalIgnoreCase) ?? true) ||
(configuration.IncludeTables.Length == 0));
}
private static IColumnInfoGateway ColumnInfoGatewayFactory(CodeGenerationConfiguration configuration)
{
return(new ColumnInfoGateway(configuration.ConnectionString));
}
private static ITableInfoGateway TableInfoGatewayFactory(CodeGenerationConfiguration configuration)
{
return(new TableInfoGateway(configuration.ConnectionString));
}
public GeneratedDataAccessLayer GenerateDataAccessLayer(CodeGenerationConfiguration configuration)
{
return(_repository.GenerateDataAccessLayer(configuration));
}
