public GeneratorActionResult ExecuteAction(GeneratorArguments arguments, Core.InputFields.ActionInputValues values, Dictionary <string, string> parameters)
{
var location = values.GetString("DestinationFolder");
var iisExpressUrl = parameters.ContainsKey("iisExpressUrl") ? parameters["iisExpressUrl"] : "";
var copier = new DirectoryRenamerCopier(arguments.TemplateInformation.TemplatePath, location)
{
ExcludeExtensions = arguments.TemplateInformation.ExcludeExtensions.Select(x => x.FileExtension).ToList(),
RemoveExtensions = arguments.TemplateInformation.RemoveExtensions.Select(x => x.FileExtension).ToList(),
RenameExtensions = arguments.TemplateInformation.RenameExtensions.Select(x => x.FileExtension).ToList(),
UtfExtensions = arguments.TemplateInformation.RenameExtensions.Where(x => x.UseUtf8Encoding).Select(x => x.FileExtension).ToList(),
RenameWords = arguments.TemplateInformation.Renames
};
copier.RenameWords.Add(iisExpressUrl, string.Format("http://localhost:{0}/", GetRandomPort()));
if (copier.StartRenaming())
{
return(new GeneratorActionResult(true, ""));
}
else
{
return(new GeneratorActionResult(false, ""));
}
}
public GeneratorActionResult RollbackAction(GeneratorArguments arguments, Core.InputFields.ActionInputValues values, Dictionary <string, string> parameters)
{
var registerIis = values.GetBool("RegisterIis");
if (registerIis)
{
var serverManager = new ServerManager();
var site = serverManager.Sites.FirstOrDefault(x => x.Name == arguments.Name);
if (site != null)
{
serverManager.Sites.Remove(site);
}
var appPool = serverManager.ApplicationPools.FirstOrDefault(x => x.Name == arguments.Name);
if (appPool != null)
{
serverManager.ApplicationPools.Remove(appPool);
}
// Commit
serverManager.CommitChanges();
}
return(new GeneratorActionResult(true, ""));
}
public void TestStrongTypesRepo()
{
var folder = @"..\UnitTests\TestAtoms\CareRelated";
var args = new GeneratorArguments <CSharpTargetConfig>(
new CSharpTargetConfig
{
Entities =
{
StrongTypes = true
}
},
folder, AtomCreator.LoadDefaults(folder));
var sqlArgs = new GeneratorArguments <SqlTargetConfig>(new SqlTargetConfig(), args.AtomsFolder, AtomCreator.LoadDefaults(folder));
var sqlGenerator = new SqlGenerator().Generate(sqlArgs);
var result = new RepositoryGenerator(sqlGenerator).Generate(args);
foreach (var item in result)
{
Console.WriteLine(item.Output);
}
}
public GeneratorActionResult ExecuteAction(GeneratorArguments arguments, Core.InputFields.ActionInputValues values, Dictionary <string, string> parameters)
{
var location = values.GetString("DestinationFolder");
RemoveFile(Path.Combine(location, "Template.xml"));
return(new GeneratorActionResult(true, ""));
}
public GeneratorActionResult ExecuteAction(GeneratorArguments arguments, Core.InputFields.ActionInputValues values, Dictionary <string, string> parameters)
{
var location = values.GetString("DestinationFolder");
var repo = new Repository(location);
repo.Push(new PushCommand().WithTimeout(60 * 60));
return(new GeneratorActionResult(true, ""));
}
public GeneratorActionResult RollbackAction(GeneratorArguments arguments, ActionInputValues values, Dictionary <string, string> parameters)
{
var location = values.GetString("DestinationFolder");
if (Directory.Exists(location))
{
Directory.Delete(location, true);
}
return(new GeneratorActionResult(true, ""));
}
public GeneratorActionResult ExecuteAction(GeneratorArguments arguments, Core.InputFields.ActionInputValues values, Dictionary <string, string> parameters)
{
var location = values.GetString("DestinationFolder");
var repo = new Repository(location);
repo.Add(new AddCommand().WithPaths(location));
repo.Commit(string.Format(MercurialCommitMessage, Environment.UserName));
return(new GeneratorActionResult(true, ""));
}
private IEnumerable <GeneratorResult> FromTargetConfigs(SqlTargetConfig sqlConfig)
{
var args = new GeneratorArguments <SqlTargetConfig>(sqlConfig, AtomsFolder, AtomCreator.LoadDefaults(AtomsFolder));
var sqlResult = new SqlGenerator().Generate(args);
sqlResult.OutputPath = sqlConfig.OutputPath;
if (Directory.Exists(sqlResult.OutputPath))
{
foreach (var file in Directory.EnumerateFiles(sqlResult.OutputPath, "*.generated.sql", SearchOption.AllDirectories))
{
sqlResult.Deletions.Add(file);
}
}
string redGateFile = Path.Combine(sqlConfig.OutputPath, "RedGateDatabaseInfo.xml");
Log.Information("Looking for redgate database info xml at {RedGateDatabaseInfoXml}", redGateFile);
if (sqlResult.DataFiles.Any() &&
File.Exists(redGateFile))
{
Log.Information("Found redgate file, updating...");
var regate = XDocument.Load(uri: redGateFile);
var dataFiles = regate.Root.Elements("DataFileSet").First();
var allDataFiles = dataFiles.Elements("DataFile")
.Select(n => n.Value).Union(sqlResult.DataFiles, StringComparer.OrdinalIgnoreCase).ToList();
dataFiles.Elements("Count")
.First()
.Value = allDataFiles.Count().ToString();
Log.Information("DataFiles Count: {DataFileCount}", allDataFiles.Count());
dataFiles.Elements("DataFile").Remove();
dataFiles.Add(allDataFiles.Select(s => new XElement("DataFile", s)));
var genResult = new GeneratorResult()
{
OutputPath = _config.OutputPath
};
genResult.AddOutput("RedGateDatabaseInfo.xml", regate.ToString());
yield return(genResult);
}
yield return(sqlResult);
}
private IEnumerable <ProjectedAtomRoot> GetProjectionAtoms(GeneratorArguments <CSharpTargetConfig> generatorArguments, CSharpTargetConfig config)
{
var atoms = AtomCreator.FromFolder(generatorArguments.AtomsFolder, generatorArguments.Defaults)
.ToList();
var generator = new ProjectionMemberGenerator(atoms);
var projectedAtoms = generator.GetProjections(AtomCreator.ProjectionsFromFolder(generatorArguments.AtomsFolder));
return(atoms.Select(ProjectedAtomRoot.FromAtom)
.Concat(projectedAtoms));
}
private IEnumerable<GeneratorResult> FromTargetConfigs(SqlTargetConfig sqlConfig)
{
var args = new GeneratorArguments<SqlTargetConfig>(sqlConfig, AtomsFolder, AtomCreator.LoadDefaults(AtomsFolder));
var sqlResult = new SqlGenerator().Generate(args);
sqlResult.OutputPath = sqlConfig.OutputPath;
if (Directory.Exists(sqlResult.OutputPath))
{
foreach (var file in Directory.EnumerateFiles(sqlResult.OutputPath, "*.generated.sql", SearchOption.AllDirectories))
{
sqlResult.Deletions.Add(file);
}
}
string redGateFile = Path.Combine(sqlConfig.OutputPath, "RedGateDatabaseInfo.xml");
Log.Information("Looking for redgate database info xml at {RedGateDatabaseInfoXml}", redGateFile);
if (sqlResult.DataFiles.Any() &&
File.Exists(redGateFile))
{
Log.Information("Found redgate file, updating...");
var regate = XDocument.Load(uri: redGateFile);
var dataFiles = regate.Root.Elements("DataFileSet").First();
var allDataFiles = dataFiles.Elements("DataFile")
.Select(n => n.Value).Union(sqlResult.DataFiles, StringComparer.OrdinalIgnoreCase).ToList();
dataFiles.Elements("Count")
.First()
.Value = allDataFiles.Count().ToString();
Log.Information("DataFiles Count: {DataFileCount}", allDataFiles.Count());
dataFiles.Elements("DataFile").Remove();
dataFiles.Add(allDataFiles.Select(s => new XElement("DataFile", s)));
var genResult = new GeneratorResult()
{
OutputPath = _config.OutputPath
};
genResult.AddOutput("RedGateDatabaseInfo.xml", regate.ToString());
yield return genResult;
}
yield return sqlResult;
}
public GeneratorActionResult ExecuteAction(GeneratorArguments arguments, Core.InputFields.ActionInputValues values, Dictionary <string, string> parameters)
{
var location = values.GetString("DestinationFolder");
var repo = new Repository(location);
if (repo.Manifest().Any())
{
return(new GeneratorActionResult(false, "Repository has commits, and is therefor not empty!"));
}
return(new GeneratorActionResult(true, ""));
}
public GeneratorResult Generate(GeneratorArguments <CSharpTargetConfig> generatorArguments)
{
var result = new GeneratorResult();
var generator = new CSharpCodeClassGenerator(generatorArguments.Config);
var atoms = GetProjectionAtoms(generatorArguments, generatorArguments.Config);
foreach (var generatorOutput in generator.Generate(atoms))
{
result.AddOutput(generatorOutput);
}
return(result);
}
public void TestRepos()
{
var folder = @"..\UnitTests\TestAtoms\CareRelated";
var args = new GeneratorArguments<CSharpTargetConfig>(new CSharpTargetConfig(), folder, AtomCreator.LoadDefaults(folder));
var sqlArgs = new GeneratorArguments<SqlTargetConfig>(new SqlTargetConfig(), args.AtomsFolder, AtomCreator.LoadDefaults(folder));
var sqlGenerator = new SqlGenerator().Generate(sqlArgs);
var result = new RepositoryGenerator(sqlGenerator).Generate(args);
foreach (var item in result)
{
Console.WriteLine(item.Output);
}
}
public GeneratorActionResult ExecuteAction(GeneratorArguments arguments, Core.InputFields.ActionInputValues values, Dictionary <string, string> parameters)
{
var location = values.GetString("DestinationFolder");
var connectionString = parameters["connectionString"];
var databasePrefix = parameters["databasePrefix"];
var databaseScriptName = parameters["databaseScriptName"];
var databaseServerName = parameters["databaseServerName"];
var databaseUsername = parameters["databaseUsername"];
var databasePassword = parameters["databasePassword"];
using (var sqlConnection = new SqlConnection(connectionString))
{
using (var sqlCommand = new SqlCommand(string.Format(DatabaseCreateStatement, string.Format(DatabaseNameFormat, databasePrefix, arguments.Name))
, sqlConnection))
{
sqlCommand.Connection.Open();
sqlCommand.ExecuteNonQuery();
sqlCommand.Connection.Close();
}
}
var databaseScriptFilePath = System.IO.Path.Combine(location, databaseScriptName);
var osqlCommand = string.Concat(string.Format(DatabaseOsqlCommand, databaseServerName, databaseUsername, databasePassword), " -d ", string.Format(DatabaseNameFormat, databasePrefix, arguments.Name),
" -i \"", databaseScriptFilePath, "\"");
using (var process = new Process()
{
StartInfo = new ProcessStartInfo()
{
Arguments = osqlCommand,
WindowStyle = ProcessWindowStyle.Normal,
CreateNoWindow = false,
FileName = "osql.exe"
}
})
{
process.Start();
process.WaitForExit(300 * 1000);
if (!process.HasExited)
{
process.Kill();
throw new Exception("OSQL process was niet klaar binnen 5 minuten");
}
}
return(new GeneratorActionResult(true, ""));
}
public virtual GeneratorActionResult ExecuteAction(GeneratorArguments arguments, Core.InputFields.ActionInputValues values, Dictionary <string, string> parameters)
{
var location = values.GetString("DestinationFolder");
try
{
GitCommandRunner.RunCommand("add -A", location);
GitCommandRunner.RunCommand(string.Format("commit -m \"{0}\"", string.Format(GitCommitMessage, Environment.UserName)), location);
}
catch (Exception ex)
{
return(new GeneratorActionResult(false, ex.Message));
}
return(new GeneratorActionResult(true, ""));
}
public virtual GeneratorActionResult ExecuteAction(GeneratorArguments arguments, Core.InputFields.ActionInputValues values, Dictionary <string, string> parameters)
{
var location = values.GetString("DestinationFolder");
try
{
GitCommandRunner.RunCommand("config --global http.postBuffer 1548576000", location);
GitCommandRunner.RunCommand("push --all origin", location);
}
catch (Exception ex)
{
return(new GeneratorActionResult(false, ex.Message));
}
return(new GeneratorActionResult(true, ""));
}
public GeneratorActionResult ExecuteAction(GeneratorArguments arguments, Core.InputFields.ActionInputValues values, Dictionary <string, string> parameters)
{
url = parameters["url"];
token = parameters["token"];
try
{
values.Add("CloneUrl", GetCloneUrl(values.GetString("projectId")));
}
catch (Exception ex)
{
return(new GeneratorActionResult(false, ex.Message));
}
return(new GeneratorActionResult(true, ""));
}
public virtual GeneratorActionResult ExecuteAction(GeneratorArguments arguments, Core.InputFields.ActionInputValues values, Dictionary <string, string> parameters)
{
var cloneUrl = values.GetString("CloneUrl");
var location = values.GetString("DestinationFolder");
try
{
GitCommandRunner.RunCommand(string.Format("clone {0} ./", cloneUrl), location);
}
catch (Exception ex)
{
return(new GeneratorActionResult(false, ex.Message));
}
return(new GeneratorActionResult(true, ""));
}
public GeneratorActionResult RollbackAction(GeneratorArguments arguments, Core.InputFields.ActionInputValues values, Dictionary <string, string> parameters)
{
var editHostsFile = values.GetBool("EditHostsFile");
if (editHostsFile)
{
if (System.IO.File.Exists(string.Concat(HostFileWriter.HostFilePath, ".backup")))
{
// Replace backup
System.IO.File.WriteAllText(HostFileWriter.HostFilePath,
System.IO.File.ReadAllText(string.Concat(HostFileWriter.HostFilePath, ".backup"), Encoding.UTF8),
Encoding.UTF8);
}
}
return(new GeneratorActionResult(true, ""));
}
public GeneratorActionResult ExecuteAction(GeneratorArguments arguments, ActionInputValues values, Dictionary <string, string> parameters)
{
var location = values.GetString("DestinationFolder");
if (Directory.Exists(location))
{
if (Directory.GetFiles(location).Length > 0 | Directory.GetDirectories(location).Length > 0)
{
return(new GeneratorActionResult(false, "Directory already exists and is not empty!"));
}
}
else
{
Directory.CreateDirectory(location);
}
return(new GeneratorActionResult(true, ""));
}
public GeneratorActionResult ExecuteAction(GeneratorArguments arguments, Core.InputFields.ActionInputValues values, Dictionary <string, string> parameters)
{
url = parameters["url"];
token = parameters["token"];
moveToken = parameters["moveToken"];
try
{
var projectId = CreateProject(arguments.Name, "", "Websites");
values.Add("projectId", projectId);
}
catch (Exception ex)
{
return(new GeneratorActionResult(false, ex.Message));
}
return(new GeneratorActionResult(true, ""));
}
public GeneratorActionResult RollbackAction(GeneratorArguments arguments, Core.InputFields.ActionInputValues values, Dictionary <string, string> parameters)
{
var connectionString = parameters["connectionString"];
var databasePrefix = parameters["databasePrefix"];
using (var sqlConnection = new SqlConnection(connectionString))
{
using (var sqlCommand = new SqlCommand(string.Format(DatabaseDropStatement, string.Format(DatabaseNameFormat, databasePrefix, arguments.Name)),
sqlConnection))
{
sqlCommand.Connection.Open();
sqlCommand.ExecuteNonQuery();
sqlCommand.Connection.Close();
}
}
return(new GeneratorActionResult(true, ""));
}
public GeneratorActionResult ExecuteAction(GeneratorArguments arguments, Core.InputFields.ActionInputValues values, Dictionary <string, string> parameters)
{
var location = values.GetString("DestinationFolder");
var cloneUrl = values.GetString("CloneUrl");
if (Directory.Exists(location))
{
var repo = new Repository(location);
repo.CloneGui(new CloneGuiCommand {
Source = cloneUrl, WaitForGuiToClose = true
});
}
else
{
return(new GeneratorActionResult(false, "Directory doesn't exist!"));
}
return(new GeneratorActionResult(true, ""));
}
private void GenerateButtonClick(object sender, EventArgs e)
{
if (!(ValidateSiteNameBox()) || (!inputFieldRepeater1.ValidateAllControl()))
{
return;
}
selectedTemplate.Prepare(ProjectNameBox.Text);
var generatorArguments = new GeneratorArguments
{
Name = ProjectNameBox.Text,
TemplateInformation = selectedTemplate,
InputValues = inputFieldRepeater1.GetInputValues()
};
var generatorForm = new GeneratorForm(generatorArguments);
generatorForm.ShowDialog();
}
public GeneratorResult Generate(GeneratorArguments <AtomGenerationTargetConfig> generatorArguments)
{
_config = generatorArguments;
Log.Information("Beginning reverse atom genernation {@Config}", new { generatorArguments.Config });
var server = new Server(generatorArguments.Config.Host);
var db = server.Databases[generatorArguments.Config.Database];
var result = new GeneratorResult();
foreach (Table table in db.Tables)
{
Log.Information("Processing: {Name} {Schema}", table.Name, table.Schema);
result.AddOutput(CreateOutput(db, table));
}
return(result);
}
public GeneratorResult Generate(GeneratorArguments <CSharpTargetConfig> generatorArguments)
{
var result = new GeneratorResult();
var allAtoms = AtomCreator.FromFolder(generatorArguments.AtomsFolder);
var repositoryMembers = _sqlGenerationResults.SqlAccessors.Select(sqlAccessorMetadata => ToRepoMember(sqlAccessorMetadata, allAtoms))
.ToList();
var singleRepoGenerator = new CSharpSingleRepositoryGenerator(generatorArguments.Config);
var singleRepo = singleRepoGenerator.Generate(repositoryMembers);
result.AddOutput(Path.ChangeExtension(singleRepo.Name, generatorArguments.Config.FileExtension), singleRepo.CodeString);
var dbFile = singleRepoGenerator.GenerateDbFile(repositoryMembers);
result.AddOutput(Path.ChangeExtension(dbFile.Name, generatorArguments.Config.FileExtension), dbFile.CodeString);
return(result);
}
private IEnumerable<GeneratorResult> FromTargetConfigs(CSharpTargetConfig targetConfig)
{
var args = new GeneratorArguments<CSharpTargetConfig>(targetConfig, AtomsFolder, AtomCreator.LoadDefaults(AtomsFolder));
if(targetConfig.Repository != null){
var sqlArgs = new GeneratorArguments<SqlTargetConfig>(new SqlTargetConfig(), args.AtomsFolder, AtomCreator.LoadDefaults(AtomsFolder));
var sqlGenerator = new SqlGenerator().Generate(sqlArgs);
var repoResult = new RepositoryGenerator(sqlGenerator).Generate(args);
repoResult.OutputPath = targetConfig.Repository.OutputPath;
yield return repoResult;
}
var codeResult = new CodeGenerator().Generate(args);
codeResult.OutputPath = targetConfig.Entities.OutputPath;
yield return codeResult;
}
public GeneratorActionResult ExecuteAction(GeneratorArguments arguments, Core.InputFields.ActionInputValues values, Dictionary <string, string> parameters)
{
var editHostsFile = values.GetBool("EditHostsFile");
var hostName = values.GetString("HostName");
if (editHostsFile)
{
// Create backup
System.IO.File.WriteAllText(string.Concat(HostFileWriter.HostFilePath, ".backup"),
System.IO.File.ReadAllText(HostFileWriter.HostFilePath, Encoding.UTF8),
Encoding.UTF8);
var hostEditor = new HostFileWriter();
hostEditor.AddOrUpdateEntry(hostName, "127.0.0.1", String.Concat("Dev URL for ", arguments.Name));
hostEditor.Save();
}
return(new GeneratorActionResult(true, ""));
}
private IEnumerable <GeneratorResult> FromTargetConfigs(CSharpTargetConfig targetConfig)
{
var args = new GeneratorArguments <CSharpTargetConfig>(targetConfig, AtomsFolder, AtomCreator.LoadDefaults(AtomsFolder));
if (targetConfig.Repository != null)
{
var sqlArgs = new GeneratorArguments <SqlTargetConfig>(new SqlTargetConfig(), args.AtomsFolder, AtomCreator.LoadDefaults(AtomsFolder));
var sqlGenerator = new SqlGenerator().Generate(sqlArgs);
var repoResult = new RepositoryGenerator(sqlGenerator).Generate(args);
repoResult.OutputPath = targetConfig.Repository.OutputPath;
yield return(repoResult);
}
var codeResult = new CodeGenerator().Generate(args);
codeResult.OutputPath = targetConfig.Entities.OutputPath;
yield return(codeResult);
}
public GeneratorActionResult ExecuteAction(GeneratorArguments arguments, Core.InputFields.ActionInputValues values, Dictionary <string, string> parameters)
{
var registerIis = values.GetBool("RegisterIis");
var hosttName = values.GetString("HostName");
var location = values.GetString("DestinationFolder");
var umbracoRelativePath = parameters["umbracoRelativePath"];
foreach (var renameWord in arguments.TemplateInformation.Renames)
{
umbracoRelativePath = StringHelpers.ReplaceEx(umbracoRelativePath, renameWord.Key, renameWord.Value);
}
if (registerIis)
{
// Get IIS reference
var serverManager = new ServerManager();
// Create new AppPool or use existing
var appPool = serverManager.ApplicationPools.FirstOrDefault(x => x.Name == arguments.Name) ??
serverManager.ApplicationPools.Add(arguments.Name);
// Umbraco is .NET 4.0
appPool.ManagedRuntimeVersion = "v4.0";
// Add site and configure
var physicalPath = System.IO.Path.Combine(location, umbracoRelativePath);
serverManager.Sites.Add(arguments.Name, physicalPath, 80);
serverManager.Sites[arguments.Name].ApplicationDefaults.ApplicationPoolName = arguments.Name;
serverManager.Sites[arguments.Name].Bindings.Clear();
serverManager.Sites[arguments.Name].Bindings.Add("*:80:" + hosttName, "http");
serverManager.Sites[arguments.Name].ServerAutoStart = true;
// Commit
serverManager.CommitChanges();
}
return(new GeneratorActionResult(true, ""));
}
private static void Visitor(bool fast, string[] projectFiles, Action <IGeneratorArguments> func)
{
ProjectVisitor projects = new ProjectVisitor(fast, projectFiles);
Check.Assert <ApplicationException>(projects.Count > 0, "Unable to locate any projects matching: " + String.Join(" ", projectFiles));
projects.VisitProjectItems(
delegate(IProjectInfo p, IProjectItem item)
{
if (!StringComparer.OrdinalIgnoreCase.Equals("CmdTool", item.CustomTool))
{
return;
}
string itemPath = item.FullFileName;
if (File.Exists(itemPath))
{
GeneratorArguments args = new GeneratorArguments(true, itemPath, item, p);
args.OutputMessage += OutputMessage;
func(args);
}
}
);
}
protected override IEnumerable<GeneratorResult> Generate()
{
AtomConfig config = TryLoadAtomConfig();
if (config == null)
{
yield break;
}
var sqlConfig = config.Targets.Values.OfType<SqlTargetConfig>().Single();
var csharpConfig = config.Targets.Values.OfType<CSharpTargetConfig>().Single();
var defaults = AtomCreator.LoadDefaults(config.AtomPath);
var sqlArgs = new GeneratorArguments<SqlTargetConfig>(sqlConfig, config.AtomPath, defaults);
var args = new GeneratorArguments<CSharpTargetConfig>(csharpConfig, config.AtomPath, defaults, sqlArgs.Atoms);
var sqlResult = new SqlGenerator().Generate(sqlArgs);
sqlResult.OutputPath = sqlConfig.OutputPath;
//if (Directory.Exists(sqlResult.OutputPath))
//{
// foreach (var file in Directory.EnumerateFiles(sqlResult.OutputPath, "*.generated.sql", SearchOption.AllDirectories))
// {
// sqlResult.Deletions.Add(file);
// }
//}
string redGateFile = Path.Combine(sqlConfig.OutputPath, "RedGateDatabaseInfo.xml");
Log.Information("Looking for redgate database info xml at {RedGateDatabaseInfoXml}", redGateFile);
if (sqlResult.DataFiles.Any() &&
File.Exists(redGateFile))
{
Log.Information("Found redgate file, updating...");
var regate = XDocument.Load(uri: redGateFile);
var dataFiles = regate.Root.Elements("DataFileSet").First();
var allDataFiles = dataFiles.Elements("DataFile")
.Select(n => n.Value).Union(sqlResult.DataFiles, StringComparer.OrdinalIgnoreCase).ToList();
dataFiles.Elements("Count")
.First()
.Value = allDataFiles.Count().ToString();
Log.Information("DataFiles Count: {DataFileCount}", allDataFiles.Count());
dataFiles.Elements("DataFile").Remove();
dataFiles.Add(allDataFiles.Select(s => new XElement("DataFile", s)));
var genResult = new GeneratorResult()
{
OutputPath = sqlConfig.OutputPath
};
genResult.AddOutput("RedGateDatabaseInfo.xml", regate.ToString());
yield return genResult;
}
yield return sqlResult;
if (csharpConfig.Repository != null)
{
var repoResult = new RepositoryGenerator(sqlResult).Generate(args);
repoResult.OutputPath = csharpConfig.Repository.OutputPath;
yield return repoResult;
}
var codeResult = new CodeGenerator().Generate(args);
codeResult.OutputPath = csharpConfig.Entities.OutputPath;
yield return codeResult;
}
public GeneratorActionResult RollbackAction(GeneratorArguments arguments, Core.InputFields.ActionInputValues values, Dictionary <string, string> parameters)
{
throw new NotImplementedException();
}
public GeneratorForm(GeneratorArguments arguments)
{
generatorArguments = arguments;
InitializeComponent();
}
