/// <summary>
/// Ejecuta un script de powershell
/// </summary>
private async Task ExecuteContentAsync(BlockLogModel block, string content, NormalizedDictionary <object> parameters, ExecuteScriptSentence sentence)
{
PowerShellManager manager = new PowerShellManager();
// Carga el script en memoria
manager.LoadScript(content);
// Asigna los parámetros
if (!AddParameters(manager, parameters, sentence, out string error))
{
Errors.Add(error);
}
else
{
// Ejecuta
await manager.ExecuteAsync();
// Comprueba los errores
if (manager.Errors.Count > 0)
{
Errors.AddRange(manager.Errors);
}
else if (manager.OutputItems.Count > 0)
{
foreach (object output in manager.OutputItems)
{
block.Info($"{manager.OutputItems.IndexOf(output).ToString()}: {output?.ToString()}");
}
}
}
}
/// <summary>
/// Procesa una exportación de las tablas de esquema a archivos CSV
/// </summary>
internal bool Execute(SentenceExportCsvSchema sentence)
{
bool exported = false;
// Exporta los archivos
using (BlockLogModel block = Processor.Manager.Logger.Default.CreateBlock(LogModel.LogType.Info, $"Start exporting tables from {sentence.Source}"))
{
ProviderModel provider = Processor.GetProvider(sentence.Source);
if (provider == null)
{
block.Error($"Can't find the provider '{sentence.Source}'");
}
else
{
// Supone que se ha exportado correctamente
exported = true;
// Elimina los archivos si es necesario
if (sentence.DeleteOldFiles)
{
DeletePathFiles(block, Processor.Manager.Step.Project.GetFullFileName(sentence.Path));
}
// Exporta las tablas del esquema (mientras no haya errores
foreach (SentenceExportCsv sentenceCsv in GetExportFileSentences(block, provider, sentence))
{
if (exported)
{
exported = new ExportCsvManager(Processor).Execute(sentenceCsv);
}
}
}
}
// Devuelve el valor que indica si se ha exportado
return(exported);
}
/// <summary>
/// Ejecuta el método
/// </summary>
private async Task <List <BaseSentence> > ExecuteMethodAsync(BlockLogModel block, CallApiMethodSentence method, HttpClientManager client, CancellationToken cancellationToken)
{
List <BaseSentence> sentences = new List <BaseSentence>();
int result = -1;
// Ejecuta el método
switch (method.Method)
{
case CallApiMethodSentence.MethodType.Post:
result = await client.PostAsync(method.EndPoint, TransformVariables(method.Body), cancellationToken);
break;
}
// Trata el resultado
if (result == -1)
{
Errors.Add($"Error when call {method.EndPoint}: {method.Method.ToString()}");
}
else
{
sentences = GetContinuation(method, result);
}
// Devuelve la lista de sentencias
return(sentences);
}
/// <summary>
/// Convierte un archivo Excel a parquet
/// </summary>
internal async Task <bool> ConvertAsync(BlockLogModel block, string source, string target, ExcelfileOptions options, CancellationToken cancellationToken)
{
bool converted = false;
// Convierte el archivo
try
{
LibParquetFiles.Writers.ParquetWriter writer = new LibParquetFiles.Writers.ParquetWriter(target);
// Evita el error de await
await Task.Delay(1);
// Crea el directorio de salida
LibHelper.Files.HelperFiles.MakePath(System.IO.Path.GetDirectoryName(target));
// Escribe el archivo
using (System.Data.IDataReader reader = new LibExcelFiles.Data.ExcelDataTableReader().LoadFile(source, options.SheetIndex,
1, 10_000_000, options.WithHeader).CreateDataReader())
{
writer.Write(reader);
}
// Indica que se ha convertido el archivo
converted = true;
}
catch (Exception exception)
{
block.Error($"Error when convert '{source}' to '{target}'", exception);
}
// Devuelve el valor que indica si se ha convertido
return(converted);
}
/// <summary>
/// Ejecuta un paso
/// </summary>
protected override async Task <bool> ProcessStepAsync(List <JobContextModel> contexts, JobStepModel step, NormalizedDictionary <object> parameters,
CancellationToken cancellationToken)
{
bool processed = false;
DbAggregatorManager dataProviderManager = GetProviderManager(contexts, step);
// Procesa el paso
using (BlockLogModel block = Logger.Default.CreateBlock(LogModel.LogType.Debug, $"Start execute step {step.Name}"))
{
if (string.IsNullOrEmpty(step.ScriptFileName) || !System.IO.File.Exists(step.ScriptFileName))
{
block.Error($"Cant find the file {step.ScriptFileName}");
}
else
{
DbScriptManager scriptManager = new DbScriptManager(step, dataProviderManager, parameters, Logger);
// Ejecuta el paso
if (System.IO.Path.GetExtension(step.ScriptFileName).EqualsIgnoreCase(".sql"))
{
processed = await scriptManager.ProcessBySqlScriptAsync(step.Target, step.ScriptFileName, cancellationToken);
}
else
{
processed = await scriptManager.ProcessByFileAsync(step.ScriptFileName, cancellationToken);
}
}
}
// Devuelve el valor que indica si se ha procesado correctamente
return(processed);
}
/// <summary>
/// Exporta las tablas de una conexión a una serie de archivos
/// </summary>
public async Task <bool> ExportAsync(BlockLogModel block, ConnectionModel connection, string dataBase, string path,
SolutionManager.FormatType formatType, long blockSize, CancellationToken cancellationToken)
{
// Limpia los errores
Errors.Clear();
// Carga el esquema
await Manager.DbScriptsManager.LoadSchemaAsync(connection, cancellationToken);
// Crea el directorio
LibHelper.Files.HelperFiles.MakePath(path);
// Genera los archivos
foreach (ConnectionTableModel table in connection.Tables)
{
if (!cancellationToken.IsCancellationRequested &&
(string.IsNullOrWhiteSpace(dataBase) || dataBase.Equals(table.Schema, StringComparison.CurrentCultureIgnoreCase)))
{
try
{
// Log
block.Info($"Start export table {table.FullName}");
// Exporta la tabla
await Task.Run(() => ExportTable(block, connection, table, path, formatType, blockSize));
// Log
block.Info($"End export table {table.FullName}");
}
catch (Exception exception)
{
block.Error($"Error when export {table.FullName}", exception);
}
}
}
// Devuelve el valor que indica si la exportación ha sido correcta
return(Errors.Count == 0);
}
/// <summary>
/// Ejecuta los comandos de una cadena SQL
/// </summary>
internal async Task ExecuteAsync(IDbProvider provider, string sql, Models.ArgumentListModel arguments, TimeSpan timeout, CancellationToken cancellationToken)
{
using (BlockLogModel block = Manager.SolutionManager.Logger.Default.CreateBlock(LogModel.LogType.Info, "Execute script"))
{
if (string.IsNullOrWhiteSpace(sql))
{
block.Error("The query is empty");
}
else
{
List <ScriptSqlPartModel> scripts = new ScriptSqlTokenizer().Parse(sql, arguments.Constants);
int scriptsExecuted = 0;
// Ejecuta los scripts
if (scripts.Count > 0)
{
scriptsExecuted = await ExecuteCommandsAsync(provider, block, scripts, ConvertParameters(arguments.Parameters), timeout, cancellationToken);
}
// Log
if (scriptsExecuted == 0)
{
block.Error("The query is empty");
}
else
{
block.Info($"{scriptsExecuted} command/s executed");
}
}
}
}
/// <summary>
/// Descarga un archivo del blob
/// </summary>
private async Task ProcessDownloadAsync(BlockLogModel parent, DownloadBlobSentence sentence)
{
using (BlockLogModel block = parent.CreateBlock(LogModel.LogType.Info, $"Start downloading from '{sentence.Source.ToString()}'"))
{
CloudConnection connection = GetConnection(sentence.StorageKey);
if (connection == null)
{
AddError(block, $"Can't find the connection for '{sentence.StorageKey}'");
}
else
{
try
{
// Descarga el archivo
using (ICloudStorageManager manager = new StorageManager().OpenAzureStorageBlob(connection.StorageConnectionString))
{
string fileName = Step.Project.GetFullFileName(sentence.FileName);
// Crea el directorio
LibHelper.Files.HelperFiles.MakePath(System.IO.Path.GetDirectoryName(fileName));
// Descarga el archivo
await manager.DownloadAsync(GetContainerName(sentence.Source.Container), sentence.Source.Blob, fileName);
}
// Log
block.Info($"Downloaded file '{sentence.FileName}' to '{sentence.Source.ToString()}'");
}
catch (Exception exception)
{
AddError(block, $"Error when download '{sentence.FileName}' to '{sentence.Source.ToString()}'", exception);
}
}
}
}
/// <summary>
/// Procesa los datos
/// </summary>
private async Task ExecuteAsync(BlockLogModel block, List <BaseSentence> sentences, CancellationToken cancellationToken)
{
foreach (BaseSentence sentenceBase in sentences)
{
if (!HasError && sentenceBase.Enabled && !cancellationToken.IsCancellationRequested)
{
switch (sentenceBase)
{
case BlockSentence sentence:
await ProcessBlockAsync(block, sentence, cancellationToken);
break;
case ExceptionSentence sentence:
ProcessException(block, sentence);
break;
case CallApiSentence sentence:
await ProcessCallApiAsync(block, sentence, cancellationToken);
break;
}
}
}
}
/// <summary>
/// Crea los archivos SQL de creación de un esquema para reporting sobre una base de datos
/// </summary>
private void CreateSchemaReportingSql()
{
Details.Reporting.Tools.CreateScriptsSqlReportingViewModel viewModel = new Details.Reporting.Tools.CreateScriptsSqlReportingViewModel(this);
if (MainController.OpenDialog(viewModel) == BauMvvm.ViewModels.Controllers.SystemControllerEnums.ResultType.Yes)
{
using (BlockLogModel block = MainController.Logger.Default.CreateBlock(LogModel.LogType.Info, "Comienzo de la creación de scripts SQL de reporting"))
{
// Crea los archivos de esquema
try
{
LibReporting.Solution.ReportingSolutionManager manager = new LibReporting.Solution.ReportingSolutionManager();
// Graba el archivo
manager.ConvertSchemaReportingToSql(viewModel.SchemaFileName, viewModel.OutputFileName);
// Log
block.Info("Fin de la creación de archivos de scripts SQL para informes");
MainController.MainWindowController
.ShowNotification(BauMvvm.ViewModels.Controllers.SystemControllerEnums.NotificationType.Information,
"Generación de archivos SQL para informes",
"Ha terminado correctamente la generación de los archivos SQL de esquema para informes");
}
catch (Exception exception)
{
block.Error($"Error en la generación de archivos de esquema. {exception.Message}");
}
// Log
MainController.Logger.Flush();
}
}
}
/// <summary>
/// Ejecuta un script de SQL
/// </summary>
internal async Task ExecuteAsync(IDbProvider dbProvider, string query, ArgumentListModel arguments, TimeSpan timeout, CancellationToken cancellationToken)
{
using (BlockLogModel block = Manager.Logger.Default.CreateBlock(LogModel.LogType.Info, "Start script execution"))
{
SqlScriptExecutor executor = new SqlScriptExecutor(Manager, dbProvider, arguments, timeout);
DbScriptsInterpreter interpreter = new DbScriptsInterpreter(executor, Manager.Logger);
// Ejecuta el archivo
await interpreter.ExecuteAsync(query, null, cancellationToken);
// Recopila los errores
Errors.AddRange(interpreter.Errors);
// y los pasa al log
if (Errors.Count == 0)
{
block.Info("End script execution");
}
else
{
string error = string.Empty;
// Agrega los errores
foreach (string inner in Errors)
{
error += inner + Environment.NewLine;
}
// log
block.Error($"Error when execute sql script: {Environment.NewLine}{error}");
}
}
}
/// <summary>
/// Procesa una copia de archivos
/// </summary>
private async Task ProcessCopyAsync(BlockLogModel parent, CopySentence sentence)
{
using (BlockLogModel block = parent.CreateBlock(LogModel.LogType.Info, $"Start copy from '{sentence.Source}' to '{sentence.Target}'"))
{
string source = Step.Project.GetFullFileName(sentence.Source);
string target = Step.Project.GetFullFileName(sentence.Target);
try
{
if (Directory.Exists(source))
{
await LibHelper.Files.HelperFiles.CopyPathAsync(source, target, sentence.Mask, sentence.Recursive, sentence.FlattenPaths);
}
else if (File.Exists(source))
{
if (!string.IsNullOrWhiteSpace(Path.GetExtension(target)))
{
await LibHelper.Files.HelperFiles.CopyFileAsync(source, target);
}
else
{
await LibHelper.Files.HelperFiles.CopyFileAsync(source, Path.Combine(target, Path.GetFileName(source)));
}
}
else
{
AddError(block, $"Cant find source file or path '{source}'");
}
}
catch (Exception exception)
{
AddError(block, $"Error when copy '{source}' to '{target}'. {exception.Message}");
}
}
}
/// <summary>
/// Borra un blob
/// </summary>
private async Task DeleteBlobAsync(NodeStorageContainerFileViewModel item)
{
if (item != null &&
SolutionViewModel.MainViewModel.MainController.HostController.SystemController.ShowQuestion($"¿Desea elimina el blob '{item.Text}'?"))
{
using (BlockLogModel block = SolutionViewModel.MainViewModel.MainController.Logger.Default.CreateBlock(LogModel.LogType.Info, "Comienza el borrado de blobs"))
{
// Borra los elementos
try
{
ICloudStorageManager manager = new StorageManager().OpenAzureStorageBlob(item.Storage.GetNormalizedConnectionString());
// Borra cada uno de los blobs del nodo
foreach (BlobNodeModel blob in GetBlobs(item.Blob))
{
// Log
block.Info($"Borrando {blob.Blob.FullFileName}");
// Borra el blob
await manager.DeleteAsync(blob.Blob.Container, blob.Blob.FullFileName);
}
}
catch (Exception exception)
{
SolutionViewModel.MainViewModel.MainController.Logger.Default.LogItems.Error($"Error al borrar el blob. {exception.Message}");
}
// Log
block.Info("Fin del borrado de blobs");
SolutionViewModel.MainViewModel.MainController.Logger.Flush();
// Actualiza el árbol
Load();
}
}
}
/// <summary>
/// Procesa un bloque de sentencias
/// </summary>
private async Task ProcessBlockAsync(BlockLogModel parent, BlockSentence sentence, CancellationToken cancellationToken)
{
using (BlockLogModel block = parent.CreateBlock(LogModel.LogType.Info, sentence.GetMessage("Start block")))
{
await ExecuteAsync(block, sentence.Sentences, cancellationToken);
}
}
/// <summary>
/// Convierte un archivo
/// </summary>
private async Task ConvertFileAsync(BlockLogModel block, string source, string target, ExcelfileOptions options, CancellationToken cancellationToken)
{
bool converted = false;
// Log
block.Info($"Converting '{source}' to '{target}'");
// Convierte el archivo
if (source.EndsWith(".csv", StringComparison.CurrentCultureIgnoreCase) && target.EndsWith(".parquet", StringComparison.CurrentCultureIgnoreCase))
{
converted = await new CsvToParquetConversor().ConvertAsync(block, source, target, cancellationToken);
}
else if (source.EndsWith(".parquet", StringComparison.CurrentCultureIgnoreCase) && target.EndsWith(".csv", StringComparison.CurrentCultureIgnoreCase))
{
converted = await new ParquetToCsvConversor().ConvertAsync(block, source, target, cancellationToken);
}
else if (source.EndsWith(".xlsx", StringComparison.CurrentCultureIgnoreCase) && target.EndsWith(".parquet", StringComparison.CurrentCultureIgnoreCase))
{
converted = await new ExcelToParquetConversor().ConvertAsync(block, source, target, options, cancellationToken);
}
// Indica el error si es necesario
if (!converted)
{
AddError(block, $"Cant convert file '{source}' to '{target}'");
}
}
/// <summary>
/// Convierte un archivo parquet a csv
/// </summary>
internal async Task <bool> ConvertAsync(BlockLogModel block, string source, string target, CancellationToken cancellationToken)
{
bool converted = false;
// Convierte el archivo
try
{
LibCsvFiles.Controllers.CsvDataReaderWriter writer = new LibCsvFiles.Controllers.CsvDataReaderWriter();
// Evita el error de await
await Task.Delay(1);
// Crea el directorio de salida
LibHelper.Files.HelperFiles.MakePath(System.IO.Path.GetDirectoryName(target));
// Escribe el archivo
using (LibParquetFiles.Readers.ParquetDataReader reader = new LibParquetFiles.Readers.ParquetDataReader(source))
{
writer.Save(reader, target);
}
// Indica que se ha convertido
converted = true;
}
catch (Exception exception)
{
block.Error($"Error when convert '{source}' to '{target}'", exception);
}
// Devuelve el valor que indica si se ha convertido
return(converted);
}
/// <summary>
/// Crea los archivos XML de un esquema
/// </summary>
private async Task CreateSchemaXmlAsync()
{
Details.EtlProjects.CreateSchemaXmlViewModel viewModel = new Details.EtlProjects.CreateSchemaXmlViewModel(this);
if (MainController.OpenDialog(viewModel) == BauMvvm.ViewModels.Controllers.SystemControllerEnums.ResultType.Yes)
{
using (BlockLogModel block = MainController.Logger.Default.CreateBlock(LogModel.LogType.Info, "Comienzo de la creación de archivos de esquema"))
{
// Crea los archivos de esquema
try
{
// Crea los archivos
await new Application.Controllers.Schema.SchemaManager(Manager).SaveAsync(viewModel.ComboConnections.GetSelectedConnection(), viewModel.OutputFileName);
// Log
block.Info("Fin de la creación de archivos de esquema");
MainController.MainWindowController
.ShowNotification(BauMvvm.ViewModels.Controllers.SystemControllerEnums.NotificationType.Information,
"Generación de archivos de esquema",
"Ha terminado correctamente la generación de los archivos de esquema");
}
catch (Exception exception)
{
block.Error($"Error en la generación de archivos de esqu{exception.Message}");
}
// Log
MainController.Logger.Flush();
}
}
}
/// <summary>
/// Ejecuta una sentencia de bloque
/// </summary>
private void ExecuteBlock(SentenceBlock sentence)
{
using (BlockLogModel block = Manager.Logger.Default.CreateBlock(LogModel.LogType.Info, $"Start block {sentence.Message}"))
{
ExecuteWithContext(sentence.Sentences);
}
}
/// <summary>
/// Ejecuta el proyecto
/// </summary>
private async Task ExecuteProjectAsync(BlockLogModel block, string project, string context, CancellationToken cancellationToken)
{
JobProjectManager manager = new JobProjectManager(Logger);
// Añade los procesadores
manager.AddProcessor(new LibJobProcessor.Cloud.JobCloudManager(Logger));
manager.AddProcessor(new LibJobProcessor.Database.JobDatabaseManager(Logger));
manager.AddProcessor(new LibJobProcessor.FilesShell.JobFileShellManager(Logger));
manager.AddProcessor(new LibJobProcessor.Rest.JobRestManager(Logger));
// Ejecuta el proyecto
await manager.ProcessAsync(project, context, cancellationToken);
// Asigna los errores
if (manager.Errors.Count == 0)
{
block.Info("La ejecución del proyecto ha terminado correctamente");
}
else
{
string errorTotal = "Error en la ejecución del proyecto";
// Añade los errores
foreach (string error in manager.Errors)
{
if (!string.IsNullOrWhiteSpace(error))
{
errorTotal += Environment.NewLine + error.Trim();
}
}
// Lanza el mensaje de error
block.Error(errorTotal);
}
}
/// <summary>
/// Graba el archivo de comparación de tablas
/// </summary>
private void SaveAssertFile(BlockLogModel block, string fileName, string provider, string pathVariable, string databaseVariable, string sufixTestTables)
{
MLFile fileML = new MLFile();
MLNode rootML = fileML.Nodes.Add("DbScript");
// Log
block.Info($"Start generate file '{fileName}'");
// Crea los nodos de creación de los archivos de pruebas
foreach (ConnectionTableModel table in Connection.Tables)
{
if (!string.IsNullOrWhiteSpace(DataBase) && DataBase.Equals(table.Schema, StringComparison.CurrentCultureIgnoreCase))
{
MLNode blockML = rootML.Nodes.Add("Block");
MLNode nodeAssertML = blockML.Nodes.Add("AssertScalar");
// Mensaje del bloque
blockML.Attributes.Add("Message", $"Assert table {table.Name}");
// Añade los atributos de la sentencia de comparación
nodeAssertML.Attributes.Add("Target", provider);
nodeAssertML.Attributes.Add("Message", $"Assert table {table.Name}");
nodeAssertML.Attributes.Add("Result", 0);
// Añade la cadena de consulta
nodeAssertML.Value = GetSqlCompare(table, pathVariable, databaseVariable, sufixTestTables);
}
}
// Graba el archivo
new LibMarkupLanguage.Services.XML.XMLWriter().Save(System.IO.Path.Combine(Path, fileName), fileML);
// Log
block.Info($"End generation file '{fileName}'");
}
/// <summary>
/// Exporta los archivos
/// </summary>
internal void Export(DeploymentModel deployment)
{
using (BlockLogModel block = Manager.Logger.Default.CreateBlock(LogModel.LogType.Info, $"Start deployment '{deployment.Name}'"))
{
(NormalizedDictionary <object> constants, string error) = GetParameters(deployment.JsonParameters);
if (!string.IsNullOrWhiteSpace(error))
{
block.Error(error);
}
else
{
ExporterOptions options = new ExporterOptions(deployment.SourcePath, deployment.TargetPath);
// Asigna las propiedades
options.WriteComments = deployment.WriteComments;
options.LowcaseFileNames = deployment.LowcaseFileNames;
options.ReplaceArguments = deployment.ReplaceArguments;
// Añade los parámetros
foreach ((string key, object value) in constants.Enumerate())
{
options.AddParameter(key, value);
}
// Exporta los archivos
new DatabrickExporter(Manager.Logger, options).Export();
}
}
}
/// <summary>
/// Graba un archivo de pruebas
/// </summary>
private void SaveTestFile(BlockLogModel block, string fileName, string provider, string pathVariable, string databaseVariable, string sufixTestTables)
{
MLFile fileML = new MLFile();
MLNode rootML = fileML.Nodes.Add("DbScript");
// Log
block.Info($"Start generate file '{fileName}'");
// Crea los nodos de creación de los archivos de pruebas
foreach (ConnectionTableModel table in Connection.Tables)
{
if (!string.IsNullOrWhiteSpace(DataBase) && DataBase.Equals(table.Schema, StringComparison.CurrentCultureIgnoreCase))
{
MLNode blockML = rootML.Nodes.Add("Block");
MLNode nodeDropML = blockML.Nodes.Add("Execute");
MLNode nodeCreateML = blockML.Nodes.Add("Execute");
// Mensaje del bloque
blockML.Attributes.Add("Message", $"Test table {table.Name}");
// Crea el nodo para borrar la tabla
nodeDropML.Attributes.Add("Target", provider);
nodeDropML.Value = $"DROP TABLE IF EXISTS {table.Name}{sufixTestTables}";
// Crea el nodo de creación de la tabla
nodeCreateML.Attributes.Add("Target", provider);
nodeCreateML.Value = Environment.NewLine + $"\t\t\tCREATE EXTERNAL TABLE {table.Name}{sufixTestTables} STORED AS parquet";
nodeCreateML.Value += Environment.NewLine + "\t\t\t\tLOCATION '{{" + pathVariable + "}}" + $"/testing/{table.Name}{sufixTestTables}.parquet' AS ";
nodeCreateML.Value += Environment.NewLine + "\t\t\t\tSELECT * FROM {{" + databaseVariable + "}}" + $".{table.Name}";
nodeCreateML.Value += Environment.NewLine;
}
}
// Graba el archivo
new LibMarkupLanguage.Services.XML.XMLWriter().Save(System.IO.Path.Combine(Path, fileName), fileML);
// Log
block.Info($"End generation file '{fileName}'");
}
/// <summary>
/// Ejecuta un archivo de script SQL
/// </summary>
private void ExecuteScriptSql(SentenceExecuteScript sentence)
{
using (BlockLogModel block = Manager.Logger.Default.CreateBlock(LogModel.LogType.Info, $"Execute script {sentence.FileName}"))
{
ProviderModel provider = GetProvider(sentence.Target);
if (provider == null)
{
AddError($"Can't find the provider. Key: '{sentence.Target}'");
}
else if (string.IsNullOrWhiteSpace(sentence.FileName))
{
AddError($"The script filename is not defined");
}
else
{
string fileName = Manager.Step.Project.GetFullFileName(sentence.FileName);
if (!System.IO.File.Exists(fileName))
{
AddError($"Cant find the file '{fileName}'");
}
else if (!sentence.MustParse)
{
ExecuteScriptSqlRaw(provider, fileName, sentence.Timeout, sentence.SkipParameters);
}
else
{
ExecuteScriptSqlParsed(provider, fileName, sentence);
}
}
}
}
/// <summary>
/// Procesa un script
/// </summary>
private async Task ProcessScriptAsync(BlockLogModel parent, ExecuteScriptSentence sentence, NormalizedDictionary <object> parameters,
CancellationToken cancellationToken)
{
// Ejecuta la sentencia
using (BlockLogModel block = parent.CreateBlock(LogModel.LogType.Info, $"Start execute script"))
{
try
{
PowerShellController controller = new PowerShellController(this, Step);
// Ejecuta el script
await controller.ExecuteAsync(block, sentence, parameters);
// Muestra los errores
if (controller.Errors.Count > 0)
{
AddErrors(block, controller.Errors);
}
else
{
block.Info("End script execution");
}
}
catch (Exception exception)
{
AddError(block, $"Error when execute script Powershell. {exception.Message}");
}
}
}
/// <summary>
/// Procesa una importación de archivos CSV para las tablas de esquema de base de datos
/// </summary>
internal bool Execute(SentenceImportCsvSchema sentence)
{
bool imported = false;
// Importa los archivos
using (BlockLogModel block = Processor.Manager.Logger.Default.CreateBlock(LogModel.LogType.Info, $"Start importing tables from {sentence.Target}"))
{
ProviderModel provider = Processor.GetProvider(sentence.Target);
if (provider == null)
{
block.Error($"Can't find the provider '{sentence.Target}'");
}
else
{
// Supone que todo se importa correctamente
imported = true;
// Ejecuta las sentencias de importación obtenidas a partir del esquema y los archivos
foreach (SentenceImportCsv sentenceCsv in GetImportFileSentences(block, provider, sentence))
{
if (imported)
{
// Log
block.Info($"Importing '{sentenceCsv.FileName}' in '{sentenceCsv.Table}'");
// Importa el archivo
imported = new ImportCsvManager(Processor).Execute(sentenceCsv);
}
}
}
}
// Devuelve el valor que indica si se ha importado
return(imported);
}
/// <summary>
/// Procesa las sentencias del script
/// </summary>
internal async Task <bool> ProcessAsync(BlockLogModel block, List <BaseSentence> program, NormalizedDictionary <object> parameters, CancellationToken cancellationToken)
{
// Ejecuta el programa
await ExecuteAsync(block, program, parameters, cancellationToken);
// Devuelve el valor que indica si todo es correcto
return(!HasError);
}
/// <summary>
/// Añade una serie de errores a la colección
/// </summary>
private void AddErrors(BlockLogModel block, List <string> errors)
{
foreach (string error in errors)
{
block.Error(error);
Errors.Add(error);
}
}
/// <summary>
/// Obtiene el generador de archivos parquet
/// </summary>
private ParquetWriter GetDataWriter(string fileName, int recordsPerBlock, BlockLogModel block)
{
ParquetWriter writer = new ParquetWriter(fileName, recordsPerBlock);
// Asigna el manejador de eventos
writer.Progress += (sender, args) => block.Progress("Writing to file", args.Records, 0);
// Devuelve el generador
return(writer);
}
/// <summary>
/// Exporta la tabla a CSV
/// </summary>
private async Task ExportToCsvAsync(BlockLogModel block, string fileName, DbDataReader reader, CancellationToken cancellationToken)
{
LibCsvFiles.Controllers.CsvDataReaderWriter writer = new LibCsvFiles.Controllers.CsvDataReaderWriter();
// Asigna el evento de progreso
writer.Progress += (sender, args) => block.Progress(System.IO.Path.GetFileName(fileName), args.Records, args.Records + 1);
// Graba el archivo
await writer.SaveAsync(reader, fileName, cancellationToken);
}
/// <summary>
/// Sube una lista de archivos
/// </summary>
private async Task UploadFilesAsync(List <string> files)
{
ICloudStorageManager manager = GetStorageManager();
// Sube los archivos
if (manager == null)
{
SolutionViewModel.MainController.SystemController.ShowMessage("Seleccione una cuenta de almacenamiento");
}
else
{
(string container, bool isFolder, string remoteFileName) = GetStorageItems();
if (string.IsNullOrWhiteSpace(container))
{
SolutionViewModel.MainController.SystemController.ShowMessage("Seleccione un contenedor");
}
else
{
// Sube los archivos
using (BlockLogModel block = SolutionViewModel.MainController.Logger.Default.CreateBlock(LogModel.LogType.Info, "Comienzo de la subida de archivos"))
{
// Sube cada archivo
foreach (string file in files)
{
if (!string.IsNullOrWhiteSpace(file) && System.IO.File.Exists(file))
{
string targetFile = System.IO.Path.GetFileName(file);
// Si es un directorio, añade el directorio
if (isFolder && !string.IsNullOrWhiteSpace(remoteFileName))
{
targetFile = System.IO.Path.Combine(remoteFileName, targetFile);
}
else if (!isFolder && !string.IsNullOrWhiteSpace(remoteFileName))
{
targetFile = System.IO.Path.Combine(System.IO.Path.GetDirectoryName(remoteFileName), targetFile);
}
// Log
block.Info($"Comienza la subida del archivo {file}");
// Sube el archivo
await manager.UploadAsync(container, targetFile, file);
// Log
block.Info($"Finaliza la subida del archivo {file}");
}
}
// Log
block.Info("Fin de la subida de archivos");
}
// Actualiza el árbol
Load();
// Log
SolutionViewModel.MainController.Logger.Flush();
}
}
}
