public void CodeGen2_RunClassTemplate()
{
DataProvider provider = DataService.GetInstance("Northwind");
ICodeLanguage csharp = new VBCodeLanguage();
TurboTemplate bits = CodeService.BuildClassTemplate("Products", csharp, provider);
bits.Render();
Assert.IsTrue(bits.FinalCode.Length > 0);
}
public void Acc_CodeGen2_RunClassTemplate()
{
DataProvider provider = DataService.GetInstance("NorthwindAccess");
ICodeLanguage csharp = new VBCodeLanguage();
TurboTemplate bits = CodeService.BuildClassTemplate("Products", csharp, provider);
bits.Render();
Assert.IsTrue(bits.FinalCode.Length > 0);
}
private void ExecuteMigrationCode(string migrationFile)
{
//pull the whole code bits in - we're going to compile this to code
//and execute it :):):):)
string migrationCode = Files.GetFileText(migrationFile);
//get the extension
string codeExtension = Path.GetExtension(migrationFile);
ICodeLanguage codeLang = new CSharpCodeLanguage();
if (codeExtension.EndsWith(FileExtension.VB, StringComparison.InvariantCultureIgnoreCase))
{
codeLang = new VBCodeLanguage();
}
object[] parameters = new object[2];
parameters[0] = providerName;
parameters[1] = direction;
CodeRunner.RunAndExecute(codeLang, migrationCode, "Migrate", parameters);
}
protected void btnGo_Click(object sender, EventArgs e)
{
DataProvider provider = DataService.GetInstance(ddlProvider.SelectedValue);
if (provider != null)
{
try
{
StringBuilder sbIndex = new StringBuilder();
ArrayList fileNames = new ArrayList();
bool outputCode = radOutputType.SelectedIndex == 0;
string langIdentifier;
ICodeLanguage language;
string masterPageText = masterPageName.Text.Trim();
//string langPrefix;
string fileExt;
if (LanguageAbbreviation.IsCSharp(languageSelect.SelectedValue))
{
langIdentifier = "C#";
language = new CSharpCodeLanguage();
fileExt = ".cs";
}
else
{
langIdentifier = "VB";
language = new VBCodeLanguage();
fileExt = ".vb";
}
foreach (ListItem item in chkTables.Items)
{
TurboCompiler turboCompiler = new TurboCompiler();
if (item.Selected)
{
string tableFileName = item.Value.Replace(" ", "");
string tableName = item.Value;
string className = DataService.GetSchema(tableName, provider.Name, TableType.Table).ClassName;
string fileNameNoExtension = tbxPrefix.Text.Trim() + FormatTableName(tableFileName) + tbxSuffix.Text.Trim();
string fileName = fileNameNoExtension + FileExtension.DOT_ASPX;
string filePath = txtOut.Text + "\\" + fileName;
fileNames.Add(filePath);
NameValueCollection nVal = new NameValueCollection();
nVal.Add(TemplateVariable.LANGUAGE, langIdentifier);
nVal.Add(TemplateVariable.CLASS_NAME, className);
nVal.Add(TemplateVariable.TABLE_NAME, tableName);
nVal.Add(TemplateVariable.MASTER_PAGE, masterPageText);
if (outputCode)
{
nVal.Add(TemplateVariable.LANGUAGE_EXTENSION, fileExt);
nVal.Add(TemplateVariable.PROVIDER, provider.Name);
nVal.Add(TemplateVariable.PAGE_FILE, fileNameNoExtension);
TurboTemplate scaffoldCodeBehind = CodeService.BuildTemplate(CodeService.TemplateType.GeneratedScaffoldCodeBehind, nVal, language, provider);
scaffoldCodeBehind.AddUsingBlock = false;
scaffoldCodeBehind.OutputPath = filePath.Replace(FileExtension.DOT_ASPX, (FileExtension.DOT_ASPX + fileExt));
turboCompiler.AddTemplate(scaffoldCodeBehind);
TurboTemplate scaffoldMarkup = CodeService.BuildTemplate(CodeService.TemplateType.GeneratedScaffoldMarkup, nVal, language, provider);
scaffoldMarkup.AddUsingBlock = false;
scaffoldMarkup.OutputPath = filePath;
turboCompiler.AddTemplate(scaffoldMarkup);
}
else
{
TurboTemplate dynamicScaffold = CodeService.BuildTemplate(CodeService.TemplateType.DynamicScaffold, nVal, language, provider);
dynamicScaffold.AddUsingBlock = false;
dynamicScaffold.OutputPath = filePath;
turboCompiler.AddTemplate(dynamicScaffold);
}
sbIndex.AppendLine("<a href=\"" + fileName + "\">" + FormatTableName(tableName) + "</a><br/>");
}
if (turboCompiler.Templates.Count > 0)
{
turboCompiler.Run();
foreach (TurboTemplate template in turboCompiler.Templates)
{
Utility.WriteTrace("Writing " + template.TemplateName + " as " + template.OutputPath.Substring(template.OutputPath.LastIndexOf("\\") + 1));
SubSonic.Sugar.Files.CreateToFile(template.OutputPath, template.FinalCode);
}
}
}
if (chkIndexPage.Checked && tbxIndexName.Text != String.Empty)
{
string before = "<html><head><title>SubSonic Scaffold Index Page</title></head><body>";
string after = "</body></html>";
WriteToFile(txtOut.Text + "\\" + tbxIndexName.Text, before + sbIndex + after);
}
lblResult.Text = "Finished";
}
catch (Exception x)
{
lblResult.Text = "Error: " + x.Message;
}
}
}
private string GenerateProviderCode(StageNode selectedNode)
{
TurboCompiler turboCompiler = new TurboCompiler();
ICodeLanguage language;
if(miGenerateVB.Checked)
language = new VBCodeLanguage();
else
language = new CSharpCodeLanguage();
//string outDir = codeDestination;
DataProviderCollection generationProviders = new DataProviderCollection();
string navigatePath = config.CodeGenerationPath;
if (selectedNode.IsProjectNode)
{
generationProviders = DataService.Providers;
if (selectedNode.Nodes.Count > 1)
navigatePath = GetNodeGenerationPath(selectedNode);
}
else if (selectedNode.IsProviderNode)
{
generationProviders.Add(DataService.Providers[selectedNode.Provider.Name]);
navigatePath = GetNodeGenerationPath(selectedNode);
}
foreach(DataProvider provider in generationProviders)
{
StageNode currentNode = GetCurrentProviderNode(selectedNode, provider);
if(currentNode != null)
{
string providerDir = GetNodeGenerationPath(currentNode);
if(!Directory.Exists(providerDir))
Directory.CreateDirectory(providerDir);
string[] tables = DataService.GetTableNames(provider.Name);
foreach(string tbl in tables)
{
if(CodeService.ShouldGenerate(tbl, provider.Name))
{
ShowStatus(String.Format("Generating {0}...", tbl));
string className = DataService.GetSchema(tbl, provider.Name, TableType.Table).ClassName;
TurboTemplate tt = CodeService.BuildClassTemplate(tbl, language, provider);
tt.OutputPath = Path.Combine(providerDir, className + language.FileExtension);
turboCompiler.AddTemplate(tt);
if(provider.GenerateODSControllers && provider.TableBaseClass != "RepositoryRecord")
{
TurboTemplate ttODS = CodeService.BuildODSTemplate(tbl, language, provider);
ttODS.OutputPath = Path.Combine(providerDir, className + "Controller" + language.FileExtension);
turboCompiler.AddTemplate(ttODS);
}
}
}
string[] views = DataService.GetViewNames(provider.Name);
foreach(string tbl in views)
{
if(CodeService.ShouldGenerate(tbl, provider.Name))
{
ShowStatus(String.Format("Generating {0}...", tbl));
string className = DataService.GetSchema(tbl, provider.Name, TableType.View).ClassName;
TurboTemplate tt = CodeService.BuildViewTemplate(tbl, language, provider);
tt.OutputPath = Path.Combine(providerDir, className + language.FileExtension);
turboCompiler.AddTemplate(tt);
}
}
if(provider.UseSPs)
{
ShowStatus("Generating Stored Procedures...");
string outPath = Path.Combine(providerDir, provider.SPClassName + language.FileExtension);
TurboTemplate tt = CodeService.BuildSPTemplate(language, provider);
tt.OutputPath = outPath;
turboCompiler.AddTemplate(tt);
}
ShowStatus("Generating Structs...");
string structPath = Path.Combine(providerDir, "AllStructs" + language.FileExtension);
TurboTemplate ttStructs = CodeService.BuildStructsTemplate(language, DataService.Provider);
ttStructs.OutputPath = structPath;
turboCompiler.AddTemplate(ttStructs);
if(miScriptSchemas.Checked && provider.NamedProviderType == DataProviderTypeName.SQL_SERVER)
{
ShowStatus("Scripting Schema...");
string schema = ScriptSchema(provider.DefaultConnectionString);
string outSchemaFileName =
string.Format("{0}_{1}_{2}_{3}_{4}_Schema.sql", DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day, Environment.UserName, provider.Name);
Files.CreateToFile(Path.Combine(providerDir, outSchemaFileName), schema);
}
if(miScriptData.Checked)
{
string outFileName = string.Format("{0}_Data_{1}_{2}_{3}.sql", provider.Name, DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day);
string outPath = Path.Combine(providerDir, outFileName);
using(StreamWriter sw = File.CreateText(outPath))
{
foreach(string tbl in tables)
{
if(CodeService.ShouldGenerate(tbl, provider.Name))
{
Utility.WriteTrace(String.Format("Scripting Table: {0}", tbl));
string dataScript = DataService.ScriptData(tbl, provider.Name);
sw.Write(dataScript);
sw.Write(Environment.NewLine);
}
}
}
}
}
}
turboCompiler.Run();
foreach(TurboTemplate template in turboCompiler.Templates)
{
ShowStatus(String.Concat("Writing ", template.TemplateName, " as ", template.OutputPath.Substring(template.OutputPath.LastIndexOf("\\") + 1)));
Files.CreateToFile(template.OutputPath, template.FinalCode);
}
ShowStatus("Finished.");
Application.DoEvents();
return navigatePath;
}
protected void btnGo_Click(object sender, EventArgs e)
{
string sOutPath = txtOut.Text;
if (!Directory.Exists(sOutPath))
{
Directory.CreateDirectory(sOutPath);
}
try
{
string fileExtension;
ICodeLanguage language;
if (LanguageAbbreviation.IsCSharp(languageSelect.SelectedValue))
{
fileExtension = FileExtension.DOT_CS;
language = new CSharpCodeLanguage();
}
else
{
fileExtension = FileExtension.DOT_VB;
language = new VBCodeLanguage();
}
string providerName = (string)Session[PROVIDER_NAME];
if (!String.IsNullOrEmpty(providerName))
{
DataProvider provider = DataService.GetInstance(providerName);
if (provider != null)
{
TurboCompiler turboCompiler = new TurboCompiler();
StringBuilder sbTableList = new StringBuilder();
foreach (ListItem item in chkTables.Items)
{
if (item.Selected)
{
sbTableList.AppendLine(item.Value);
}
}
foreach (ListItem item in chkTables.Items)
{
if (item.Selected)
{
TableSchema.Table t = DataService.GetTableSchema(item.Value, provider.Name, TableType.Table);
if (t.ForeignKeys.Count > 0)
{
//provider.GetManyToManyTables(t, evalTables);
}
string className = DataService.GetTableSchema(item.Value, providerName, TableType.Table).ClassName;
string filePath = Path.Combine(sOutPath, className + fileExtension);
TurboTemplate classTemplate = CodeService.BuildClassTemplate(item.Value, language, provider);
classTemplate.OutputPath = filePath;
turboCompiler.AddTemplate(classTemplate);
//SubSonic.Sugar.Files.CreateToFile(filePath, usings + CodeService.RunClass(item.Value, providerName, language));
if (chkODS.Checked)
{
filePath = Path.Combine(sOutPath, className + "Controller" + fileExtension);
TurboTemplate odsTemplate = CodeService.BuildODSTemplate(item.Value, language, provider);
odsTemplate.OutputPath = filePath;
turboCompiler.AddTemplate(odsTemplate);
//SubSonic.Sugar.Files.CreateToFile(filePath, usings + CodeService.RunODS(item.Value, providerName, language));
}
}
}
//output the Views
foreach (ListItem item in chkViews.Items)
{
if (item.Selected)
{
string className = DataService.GetTableSchema(item.Value, providerName, TableType.View).ClassName;
string filePath = Path.Combine(sOutPath, className + fileExtension);
TurboTemplate viewTemplate = CodeService.BuildViewTemplate(item.Value, language, provider);
viewTemplate.OutputPath = filePath;
turboCompiler.AddTemplate(viewTemplate);
//SubSonic.Sugar.Files.CreateToFile(filePath, usings + CodeService.RunReadOnly(item.Value, providerName, language));
}
}
//output the SPs
if (chkSP.Checked)
{
string filePath = Path.Combine(sOutPath, "StoredProcedures" + fileExtension);
TurboTemplate spTemplate = CodeService.BuildSPTemplate(language, provider);
spTemplate.OutputPath = filePath;
turboCompiler.AddTemplate(spTemplate);
//SubSonic.Sugar.Files.CreateToFile(filePath, usings + CodeService.RunSPs(providerName, language));
}
//structs
string structPath = Path.Combine(sOutPath, "AllStructs" + fileExtension);
TurboTemplate structsTemplate = CodeService.BuildStructsTemplate(language, provider);
structsTemplate.OutputPath = structPath;
turboCompiler.AddTemplate(structsTemplate);
//SubSonic.Sugar.Files.CreateToFile(structPath, usings + CodeService.RunStructs(language));
if (turboCompiler.Templates.Count > 0)
{
turboCompiler.Run();
foreach (TurboTemplate template in turboCompiler.Templates)
{
Utility.WriteTrace("Writing " + template.TemplateName + " as " + template.OutputPath.Substring(template.OutputPath.LastIndexOf("\\") + 1));
SubSonic.Sugar.Files.CreateToFile(template.OutputPath, template.FinalCode);
}
}
lblResult.Text = "View your files: <a href='file://" + sOutPath + "'>" + sOutPath + "</a>";
}
}
}
catch (Exception x)
{
lblResult.Text = "Error: " + x.Message;
}
}