public void TestCsGenerator()
{
IOutputGenerator generator = new CsGenerator("tstNSpace", true);
string outputCode = generator.generateCode(tstAnalysisResult);
//ToDo
}
static void Main(string[] args)
{
CmdLineArgs cmdLineArgs = new CmdLineArgs(args);
string srcPath = cmdLineArgs.GetFirstSwitchArgument(""); //direct after call
if (srcPath == null)
{
Console.WriteLine("ERROR: No Input File (Tbs-Definition was given");
DumpHelp();
return;
}
Console.WriteLine($"Reading Tbs-Definition in File {srcPath}...");
var srcCode = File.ReadAllText(srcPath);
Console.WriteLine("Parsing Tbs-Definition...");
var parseResult = new ParseResult(srcCode);
Console.WriteLine("Analsing Tbs-Definition...");
var analysisResult = new AnalysisResult(parseResult);
Console.WriteLine(analysisResult.AnalysisLog.ToString());
if (analysisResult.AnalysisLog.ContainsErrors)
{
Console.WriteLine("ERROR: Errors Occured during Tbs Analysis - aborting");
return;
}
Console.WriteLine("Generating Output...");
if (cmdLineArgs.HasSwitch("cpp"))
{
string nmespce = cmdLineArgs.GetFirstSwitchArgument("namespace", "TinybuffersGenerated");
IOutputGenerator generator = new CppGenerator(nmespce);
string outputPath = GetDefaultPath(srcPath, generator);
outputPath = cmdLineArgs.GetFirstSwitchArgument("cpp", outputPath);
GenerateAndSave(generator, outputPath, analysisResult);
}
if (cmdLineArgs.HasSwitch("cs"))
{
string nmespce = cmdLineArgs.GetFirstSwitchArgument("namespace", "TinybuffersGenerated");
bool isPublic = cmdLineArgs.HasSwitch("public");
IOutputGenerator generator = new CsGenerator(nmespce, isPublic);
string outputPath = GetDefaultPath(srcPath, generator);
outputPath = cmdLineArgs.GetFirstSwitchArgument("cs", outputPath);
GenerateAndSave(generator, outputPath, analysisResult);
}
Console.WriteLine("DONE");
}
private static IEnumerable <IGeneratedFile> GenerateFiles(string configPath)
{
var options = SimpletOptions.ReadFrom(configPath);
var dirInfo = Directory.CreateDirectory(options.TargetDirectory);
var csGenerator = new CsGenerator();
var csFiles = csGenerator.Generate(options).ToArray();
var txtGenerator = new TxtGenerator(csFiles.OfType <IGeneratedClass>());
var txtFiles = txtGenerator.Generate(options);
var csprojGenerator = new CsProjGenerator();
var csprojFiles = csprojGenerator.Generate(options);
foreach (var file in csprojFiles.Concat(txtFiles.Concat(csFiles)))
{
yield return(new FullPathFile(dirInfo, file));
}
}
// VS has Bug that lockes files on writing
// : Severity Code Description Project File Line Cannot open '.pdb' because it is being used by another process...
/*[Theory]
* [InlineData(null)]
* [InlineData("Generated")]*/
public void ShouldWriteToDiskEntityUserFile(string directory)
{
CsGenerator csGenerator = new CsGenerator();
csGenerator.OutputDirectory = directory ?? csGenerator.OutputDirectory;
FileModel userFile = GetEntityUserFile();
csGenerator.Files.Add(userFile);
csGenerator.CreateFiles();
List <string> fileLines = ReadFileFromDisk(csGenerator.Path);
string result = userFile.ToString();
string text = GetText(fileLines);
Assert.Equal(result, text);
}
private void WriteComplexNumberFile()
{
var usingDirectives = new List <string>
{
"System;",
"System.ComponentModel;"
};
string fileNameSpace = "CsCodeGenerator.Tests";
string complexNumberText = "ComplexNumber";
ClassModel complexNumberClass = new ClassModel(complexNumberText);
complexNumberClass.SingleKeyWord = KeyWord.Partial; //or: complexNumberClass.KeyWords.Add(KeyWord.Partial);
var descriptionAttribute = new AttributeModel("Description")
{
SingleParameter = new Parameter(@"""Some class info""")
};
complexNumberClass.AddAttribute(descriptionAttribute);
complexNumberClass.DefaultConstructor.IsVisible = true;
Constructor secondConstructor = new Constructor(complexNumberClass.Name);
secondConstructor.Parameters.Add(new Parameter(BuiltInDataType.Double, "real"));
secondConstructor.Parameters.Add(new Parameter(BuiltInDataType.Double, "imaginary")
{
Value = "0"
});
secondConstructor.BodyLines.Add("Real = real;");
secondConstructor.BodyLines.Add("Imaginary = imaginary;");
complexNumberClass.Constructors.Add(secondConstructor);
var fields = new List <Field>
{
new Field(BuiltInDataType.Double, "PI")
{
SingleKeyWord = KeyWord.Const, DefaultValue = "3.14"
},
new Field(BuiltInDataType.String, "remark")
{
AccessModifier = AccessModifier.Private
},
};
var properties = new List <Property>
{
new Property(BuiltInDataType.String, "DefaultFormat")
{
SingleKeyWord = KeyWord.Static,
IsGetOnly = true,
DefaultValue = @"""a + b * i"""
},
new Property(BuiltInDataType.Double, "Real"),
new Property(BuiltInDataType.Double, "Imaginary"),
new Property(BuiltInDataType.String, "Remark")
{
SingleKeyWord = KeyWord.Virtual,
IsAutoImplemented = false,
GetterBody = "remark",
SetterBody = "remark = value"
},
};
var methods = new List <Method>
{
new Method(BuiltInDataType.Double, "Modul")
{
BodyLines = new List <string> {
"return Math.Sqrt(Real * Real + Imaginary * Imaginary);"
}
},
new Method(complexNumberText, "Add")
{
Parameters = new List <Parameter> {
new Parameter("ComplexNumber", "input")
},
BodyLines = new List <string>
{
"ComplexNumber result = new ComplexNumber();",
"result.Real = Real + input.Real;",
"result.Imaginary = Imaginary + input.Imaginary;",
"return result;"
}
},
new Method(BuiltInDataType.String, "ToString")
{
Comment = "example of 2 KeyWords(new and virtual), usually here would be just virtual",
KeyWords = new List <KeyWord> {
KeyWord.New, KeyWord.Virtual
},
BodyLines = new List <string> {
"return $\"({Real:0.00}, {Imaginary:0.00})\";"
}
}
};
complexNumberClass.Fields = fields;
complexNumberClass.Properties = properties;
complexNumberClass.Methods = methods;
FileModel complexNumberFile = new FileModel(complexNumberText);
complexNumberFile.LoadUsingDirectives(usingDirectives);
complexNumberFile.Namespace = fileNameSpace;
complexNumberFile.Classes.Add(complexNumberClass);
CsGenerator csGenerator = new CsGenerator();
csGenerator.Files.Add(complexNumberFile);
//csGenerator.CreateFiles(); //Console.Write(complexNumberFile);
string result = complexNumberFile.ToString();
string text = GetComplexNumberFileText();
Debug.Write(result);
Assert.Equal(result, text);
}
/// <summary>
/// Generates the SQL and C# code for the specified database.
/// </summary>
/// <param name="outputDirectory">The directory where the C# and SQL code should be created.</param>
/// <param name="connectionString">The connection string to be used to connect the to the database.</param>
/// <param name="grantLoginName">The SQL Server login name that should be granted execute rights on the generated stored procedures.</param>
/// <param name="storedProcedurePrefix">The prefix that should be used when creating stored procedures.</param>
/// <param name="createMultipleFiles">A flag indicating if the generated stored procedures should be created in one file or separate files.</param>
/// <param name="projectName">The name of the project file to be generated.</param>
/// <param name="targetNamespace">The namespace that the generated C# classes should contained in.</param>
/// <param name="daoSuffix">The suffix to be applied to all generated DAO classes.</param>
/// <param name="dtoSuffix">The suffix to be applied to all generated DTO classes.</param>
public static void Generate(string outputDirectory, string connectionString, string grantLoginName, string storedProcedurePrefix, bool createMultipleFiles, string projectName, string targetNamespace, string daoSuffix, string dtoSuffix)
{
List <Table> tableList = new List <Table>();
string databaseName;
string sqlPath;
string csPath;
using (SqlConnection connection = new SqlConnection(connectionString))
{
databaseName = Utility.FormatPascal(connection.Database);
sqlPath = Path.Combine(outputDirectory, "SQL");
csPath = Path.Combine(outputDirectory, "CS");
connection.Open();
// Get a list of the entities in the database
DataTable dataTable = new DataTable();
SqlDataAdapter dataAdapter = new SqlDataAdapter(Utility.GetTableQuery(connection.Database), connection);
dataAdapter.Fill(dataTable);
// Process each table
foreach (DataRow dataRow in dataTable.Rows)
{
Table table = new Table();
table.Name = (string)dataRow["TABLE_NAME"];
QueryTable(connection, table);
tableList.Add(table);
}
}
DatabaseCounted(null, new CountEventArgs(tableList.Count));
// Generate the necessary SQL and C# code for each table
int count = 0;
if (tableList.Count > 0)
{
// Create the necessary directories
Utility.CreateSubDirectory(sqlPath, true);
Utility.CreateSubDirectory(csPath, true);
Utility.CreateSubDirectory(Path.Combine(csPath, "Repositories"), true);
Utility.CreateSubDirectory(Path.Combine(csPath, "FormClasses"), true);
Utility.CreateSubDirectory(Path.Combine(sqlPath, "SaveSPs"), true);
Utility.CreateSubDirectory(Path.Combine(sqlPath, "SaveSPScienterModel"), true);
Utility.CreateSubDirectory(Path.Combine(csPath, "Dapper"), true);
Utility.CreateSubDirectory(Path.Combine(csPath, "WebAPI"), true);
Utility.CreateSubDirectory(Path.Combine(csPath, "FrontEndAngular"), true);
Utility.CreateSubDirectory(Path.Combine(csPath, "FrontEndAngularHTML"), true);
// Create the necessary "use [database]" statement
SqlGenerator.CreateUseDatabaseStatement(databaseName, sqlPath, createMultipleFiles);
// Create the necessary database logins
SqlGenerator.CreateUserQueries(databaseName, grantLoginName, sqlPath, createMultipleFiles);
Table table2 = new Table();
// Create the CRUD stored procedures and data access code for each table
foreach (Table table in tableList)
{
SqlGenerator.CreateSaveStoredProcedure(databaseName, table, grantLoginName, storedProcedurePrefix, sqlPath, createMultipleFiles);
SqlGenerator.CreateInsertStoredProcedure(databaseName, table, grantLoginName, storedProcedurePrefix, sqlPath, createMultipleFiles);
SqlGenerator.CreateUpdateStoredProcedure(databaseName, table, grantLoginName, storedProcedurePrefix, sqlPath, createMultipleFiles);
SqlGenerator.CreateDeleteStoredProcedure(databaseName, table, grantLoginName, storedProcedurePrefix, sqlPath, createMultipleFiles);
SqlGenerator.CreateDeleteAllByStoredProcedures(databaseName, table, grantLoginName, storedProcedurePrefix, sqlPath, createMultipleFiles);
SqlGenerator.CreateSelectStoredProcedure(databaseName, table, grantLoginName, storedProcedurePrefix, sqlPath, createMultipleFiles);
SqlGenerator.CreateSelectAllStoredProcedure(databaseName, table, grantLoginName, storedProcedurePrefix, sqlPath, createMultipleFiles);
SqlGenerator.CreateSelectAllByStoredProcedures(databaseName, table, grantLoginName, storedProcedurePrefix, sqlPath, createMultipleFiles);
SqlGenerator.CreateSaveStoredProcedureForSceinter(databaseName, table, grantLoginName, storedProcedurePrefix, sqlPath, createMultipleFiles);
CsGenerator.CreateDataTransferClass(table, targetNamespace, dtoSuffix, csPath);
CsGenerator.CreateDataAccessClass(databaseName, table, targetNamespace, storedProcedurePrefix, daoSuffix, dtoSuffix, csPath);
CsGenerator.CreateFORMClasses(databaseName, table, targetNamespace, storedProcedurePrefix, daoSuffix, dtoSuffix, csPath);
CsGenerator.DapperClasses(databaseName, table, targetNamespace, storedProcedurePrefix, daoSuffix, dtoSuffix, csPath);
CsGenerator.WebApimethods(databaseName, table, targetNamespace, storedProcedurePrefix, daoSuffix, dtoSuffix, csPath);
CsGenerator.FrontEndAngular(databaseName, table, targetNamespace, storedProcedurePrefix, daoSuffix, dtoSuffix, csPath);
CsGenerator.FrontEndAngularHTML(databaseName, table, targetNamespace, storedProcedurePrefix, daoSuffix, dtoSuffix, csPath);
table2 = table;
count++;
TableCounted(null, new CountEventArgs(count));
}
CsGenerator.CreateSharpCore(csPath);
CsGenerator.CreateAssemblyInfo(csPath, databaseName, databaseName);
CsGenerator.CreateProjectFile(csPath, projectName, tableList, daoSuffix, dtoSuffix);
//CsGenerator.CreateFORMClasses(csPath, projectName, tableList, daoSuffix, dtoSuffix);
}
}
static void Main(string[] args)
{
PostgresDbCreator postgresDbCreator = new PostgresDbCreator();
PostgresDbSeeder postgresDbSeeder = new PostgresDbSeeder();
SQLiteDbCreator sqLiteDbCreator = new SQLiteDbCreator();
SQLiteDbSeeder sqLiteDbSeeder = new SQLiteDbSeeder();
PostgresDbExtractor postgresDbExtractor = new PostgresDbExtractor();
SQLiteDbExtractor sqLiteDbExtractor = new SQLiteDbExtractor();
CsvGenerator csvGenerator = new CsvGenerator();
HtmlGenerator htmlGenerator = new HtmlGenerator();
XmlGenerator xmlGenerator = new XmlGenerator();
CsGenerator csGenerator = new CsGenerator();
try
{
using (DbConnection connection = new SQLiteConnection(Configuration.SQLiteConnectionString))
{
connection.Open();
var path = "D:\\sqLite_output";
if (Directory.Exists(path))
{
Directory.Delete(path, true);
}
Directory.CreateDirectory(path);
var sqLiteTables = sqLiteDbExtractor.GetTables(connection);
foreach (var sqLiteTable in sqLiteTables.Where(x => x != "sqlite_sequence"))
{
csvGenerator.Generate(sqLiteDbExtractor, connection, sqLiteTable, path);
htmlGenerator.Generate(sqLiteDbExtractor, connection, sqLiteTable, path);
xmlGenerator.Generate(sqLiteDbExtractor, connection, sqLiteTable, path);
csGenerator.Generate(sqLiteDbExtractor, connection, sqLiteTable, path);
}
}
using (DbConnection connection = new NpgsqlConnection(Configuration.NpgsqlConnectionString))
{
connection.Open();
var path = "D:\\pgsql_output";
if (Directory.Exists(path))
{
Directory.Delete(path, true);
}
Directory.CreateDirectory(path);
var pgsqlTables = postgresDbExtractor.GetTables(connection);
foreach (var pgsqlTable in pgsqlTables)
{
csvGenerator.Generate(postgresDbExtractor, connection, pgsqlTable, path);
htmlGenerator.Generate(postgresDbExtractor, connection, pgsqlTable, path);
xmlGenerator.Generate(postgresDbExtractor, connection, pgsqlTable, path);
csGenerator.Generate(postgresDbExtractor, connection, pgsqlTable, path);
}
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
throw;
}
}
