private void Button_Click(object sender, RoutedEventArgs e)
{
var outputDir = txt_outputDir.Content.ToString();
if (!Directory.Exists(outputDir))
{
MessageBox.Show("You must select an output directory before trying to generate!");
return;
}
btn_Generate.IsEnabled = false;
var connectionString = txt_connectionString.Text;
var @namespace = txt_namespace.Text;
if (string.IsNullOrWhiteSpace(connectionString))
{
Log("Connection string is not provide, process aborted.");
}
Log($"Start generate with settings : mode : {mode} | language : {language}");
Task.Run(async() =>
{
try
{
DatabaseDefinition databaseDefinition = GetDatabaseDefinition(connectionString);
switch (mode)
{
case SupportMode.Model:
var provider = language switch
{
SupportLanguage.CSharp => CSharpModelProvider.Context,
SupportLanguage.TypeScript => TypeScriptModelProvider.Context,
SupportLanguage.VisualBasic => VisualBasicModelProvider.Context,
_ => throw new NotSupportedException()
};
var modelGenerator = new ModelBuilder(outputDir, @namespace, databaseDefinition);
modelGenerator.OnFileGenerated += (f) => Log($"Generated {f}");
modelGenerator.Generate(provider);
break;
case SupportMode.FrontendService:
var consumerServiceProvider = language switch
{
SupportLanguage.CSharp => CSharpConsumerServiceProvider.Context,
SupportLanguage.TypeScript => TypescriptServiceProvider.Context,
_ => throw new NotSupportedException()
};
var consumerGenerator = new ServiceBuilder(outputDir, @namespace, databaseDefinition);
consumerGenerator.OnFileGenerated += (f) => Log($"Geenrated {f}");
consumerGenerator.Generate(consumerServiceProvider);
break;
case SupportMode.BackendService:
IServiceBuilderProvider serviceProvider = language switch
{
SupportLanguage.CSharp => CSharpServiceProvider.Context,
_ => throw new NotSupportedException()
};
var serviceGenerator = new ServiceBuilder(outputDir, @namespace, databaseDefinition);
serviceGenerator.OnFileGenerated += (f) => Log($"Generated {f}");
serviceGenerator.Generate(serviceProvider);
//GeneratorFactory.PerformRepositoryGenerate(targetLanguage, targetDatabaseConnector, txt_connectionString.Text, outputDir, txt_namespace.Text);
break;
case SupportMode.Controller:
IControllerProvider controllerProvider = language switch
{
SupportLanguage.CSharp => CSharpControllerProvider.Context,
_ => throw new NotSupportedException()
};
var controllerGenerator = new ControllerBuilder(outputDir, @namespace, databaseDefinition);
controllerGenerator.OnFileGenerated += (f) => Log($"Generated {f}");
controllerGenerator.Generate(controllerProvider);
break;
}
Log($"All tasks are done.");
Process.Start("explorer.exe", outputDir);
}
catch (Exception ex)
{
Log($"Error with message : {ex.Message}");
}
});
btn_Generate.IsEnabled = true;
}
public void Generate(IServiceBuilderProvider provider)
{
foreach (var table in this._databaseDefinition.Tables)
{
var modelCode = provider.GenerateModelFile(this._namespace, table);
var modelFileName = $"{table.Name}.{provider.FileExtension}";
if (!string.IsNullOrWhiteSpace(modelCode))
{
var fileLoc = Path.Combine(_modelDirectory, modelFileName);
File.WriteAllText(fileLoc, modelCode);
this.OnFileGenerated?.Invoke(fileLoc);
}
if (_allowGeneratePartialModel)
{
Directory.CreateDirectory(_partialModelDirectory);
var partialModelFileName = $"{table.Name}.{provider.FileExtension}";
var fileLoc = Path.Combine(_partialModelDirectory, modelFileName);
if (!File.Exists(fileLoc))
{
var partialModelCode = provider.GeneratePartialModelFile(this._namespace, table);
if (!string.IsNullOrWhiteSpace(partialModelCode))
{
File.WriteAllText(fileLoc, partialModelCode);
this.OnFileGenerated?.Invoke(fileLoc);
}
}
}
var repositoryName = $"{table.Name}Repository";
var repositoryCode = provider.GenerateRepositoryFile(this._namespace, table);
var repositoryFileName = $"{repositoryName}.{provider.FileExtension}";
if (!string.IsNullOrWhiteSpace(repositoryCode))
{
var fileLoc = Path.Combine(_repositoryDirectory, repositoryFileName);
File.WriteAllText(fileLoc, repositoryCode);
this.OnFileGenerated?.Invoke(fileLoc);
}
if (_allowGeneratePartialRepository)
{
Directory.CreateDirectory(_partialRepositoryDirectory);
var partialRepoFileName = $"{table.Name}.{provider.FileExtension}";
var partialServiceFileLoc = Path.Combine(_partialRepositoryDirectory, repositoryFileName);
if (!File.Exists(partialServiceFileLoc))
{
var partialRepoCode = provider.GeneratePartialRepositoryFile(this._namespace, table);
if (!string.IsNullOrWhiteSpace(partialRepoCode))
{
File.WriteAllText(partialServiceFileLoc, partialRepoCode);
this.OnFileGenerated?.Invoke(partialServiceFileLoc);
}
}
}
}
var repoBasedCode = provider.GenerateRepositoryBasedFile(this._namespace);
var repoBasedFile = Path.Combine(this._repositoryBasedDirectory, $"Repository.{provider.FileExtension}");
File.WriteAllText(repoBasedFile, repoBasedCode);
this.OnFileGenerated?.Invoke(repoBasedFile);
var serviceCode = provider.GenerateServiceFile(this._namespace, this._databaseDefinition.Tables, this._databaseDefinition.StoredProcedures);
var serviceFile = Path.Combine(this._directory, $"Service.{provider.FileExtension}");
File.WriteAllText(serviceFile, serviceCode);
this.OnFileGenerated?.Invoke(serviceFile);
}
