예제 #1
0
 public static void Compile()
 {
     if (turboCompiler.Templates.Count > 0)
     {
         AddLogEntry(LogState.Information, "Running Compiler...");
         turboCompiler.Run();
         AddLogEntry(LogState.Information, "Writing Files...");
         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);
         }
         AddLogEntry(LogState.Information, "Done!");
     }
 }
예제 #2
0
    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;
            }
        }
    }
예제 #3
0
    protected void btnGo_Click(object sender, EventArgs e)
    {
        string sOutPath = txtOut.Text;

        if (!Directory.Exists(sOutPath))
        {
            Directory.CreateDirectory(sOutPath);
        }
        try
        {
            ICodeLanguage language = CodeLanguageFactory.GetByShortName(languageSelect.SelectedValue);

            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 + language.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" + language.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 + language.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" + language.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" + language.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;
        }
    }
예제 #4
0
        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;
        }