/// <summary>
/// Graba el archivo de esquema del dataWarehouse
/// </summary>
private void SaveDataWarehouse(DataWarehouseModel dataWarehouse)
{
// Graba la solución
ReportingSolutionViewModel.SaveDataWarehouse(dataWarehouse);
// Actualiza el árbol
Load();
}
/// <summary>
/// Elimina un origen de datos
/// </summary>
public void RemoveDataWarehouse(DataWarehouseModel dataWarehouse)
{
// Elimina el archivo de la lista
for (int index = ReportingSolution.DataWarehousesFiles.Count - 1; index >= 0; index--)
{
(string dataWarehouseId, string file) = ReportingSolution.DataWarehousesFiles[index];
// Elimina el archivo
if (dataWarehouse.Id.Equals(dataWarehouseId, StringComparison.CurrentCultureIgnoreCase) && !string.IsNullOrWhiteSpace(file))
{
// Elimina el archivo
for (int indexFile = ReportingSolution.Files.Count - 1; indexFile >= 0; indexFile--)
{
if (ReportingSolution.Files[indexFile].Equals(file, StringComparison.CurrentCultureIgnoreCase))
{
ReportingSolution.Files.RemoveAt(indexFile);
}
}
// Elimina el origen de datos del diccionario
ReportingSolution.DataWarehousesFiles.RemoveAt(index);
}
}
// Elimina el origen de datos del esquema
Manager.RemoveDataWarehouse(dataWarehouse);
}
/// <summary>
/// Obtiene un origen de datos para una consulta SQL
/// </summary>
private DataSourceSqlModel LoadDataSourceSql(DataWarehouseModel dataWarehouse, MLNode rootML)
{
DataSourceSqlModel dataSource = new DataSourceSqlModel(dataWarehouse);
// Carga las propiedades
dataSource.Id = rootML.Attributes[TagId].Value.TrimIgnoreNull();
// Asigna la base de datos y la cadena SQL
dataSource.Sql = rootML.Nodes[TagSql].Value.TrimIgnoreNull();
// Carga las columnas
foreach (MLNode nodeML in rootML.Nodes)
{
if (nodeML.Name == TagColumn)
{
dataSource.Columns.Add(LoadColumn(dataSource, nodeML));
}
}
// Carga los parámetros de consulta
foreach (MLNode nodeML in rootML.Nodes)
{
if (nodeML.Name == TagParameter)
{
dataSource.Parameters.Add(LoadParameter(nodeML));
}
}
// Devuelve el origen de datos
return(dataSource);
}
/// <summary>
/// Graba un origen de datos
/// </summary>
internal void SaveDataWarehouse(DataWarehouseModel dataWarehouse)
{
// Graba el archivo
ReportingSolutionManager.SaveDataWarehouse(dataWarehouse);
// Actualiza el árbol
TreeReportingViewModel.Load();
}
public DataWarehouseViewModel(ReportingSolutionViewModel reportingSolutionViewModel, DataWarehouseModel dataWarehouse)
{
// Inicializa las propiedades
ReportingSolutionViewModel = reportingSolutionViewModel;
DataWarehouse = dataWarehouse;
// Inicializa el viewModel
InitViewModel();
}
/// <summary>
/// Borra un almacén de datos
/// </summary>
private void DeleteDataWarehouse(DataWarehouseModel dataWarehouse)
{
if (ReportingSolutionViewModel.SolutionViewModel.MainController.SystemController.ShowQuestion($"¿Realmente desea borrar los datos del almacén de datos {dataWarehouse.Name}?"))
{
// Borra el almacén de datos
ReportingSolutionViewModel.ReportingSolutionManager.RemoveDataWarehouse(dataWarehouse);
// Graba la solución y actualiza el árbol
SaveSolution();
}
}
/// <summary>
/// Carga los orígenes de datos
/// </summary>
private void LoadDataSources()
{
DataWarehouseModel dataWarehouse = GetDataWarehouse();
if (dataWarehouse != null)
{
foreach (BaseDataSourceModel dataSource in dataWarehouse.DataSources.EnumerateValuesSorted())
{
Children.Add(new NodeDataSourceViewModel(TreeViewModel, this, dataSource));
}
}
}
/// <summary>
/// Carga las dimensiones
/// </summary>
private void LoadDimensions()
{
DataWarehouseModel dataWarehouse = GetDataWarehouse();
if (dataWarehouse != null)
{
foreach (DimensionModel dimension in dataWarehouse.Dimensions.EnumerateValuesSorted())
{
Children.Add(new NodeDimensionViewModel(TreeViewModel, this, dimension));
}
}
}
/// <summary>
/// Carga los informes
/// </summary>
private void LoadReports()
{
DataWarehouseModel dataWarehouse = GetDataWarehouse();
if (dataWarehouse != null)
{
foreach (ReportModel report in dataWarehouse.Reports.EnumerateValuesSorted())
{
Children.Add(new NodeReportViewModel(TreeViewModel, this, report));
}
}
}
/// <summary>
/// Convierte un <see cref="DataWarehouseModel"/> en SQL
/// </summary>
internal void Convert(DataWarehouseModel dataWarehouse, string scriptFileName)
{
// Crea las tablas
CreateTables();
// Inserta los orígenes de datos
CreateDataSources(dataWarehouse);
// Inserta las dimensiones
CreateDimensions(dataWarehouse);
// Inserta los informes
CreateReports(dataWarehouse);
// Graba el archivo
LibHelper.Files.HelperFiles.SaveTextFile(scriptFileName, Builder.ToString());
}
/// <summary>
/// Obtiene el nombre de archivo asociado con un almacén en la solución
/// </summary>
internal string GetFileName(DataWarehouseModel dataWarehouse)
{
// Busca el nombre de archivo
foreach ((string solutionDataWarehouse, string file) in DataWarehousesFiles)
{
if (solutionDataWarehouse.Equals(dataWarehouse.Id, StringComparison.CurrentCultureIgnoreCase))
{
return(file);
}
}
// Si ha llegado hasta aquí es porque no ha encontrado nada
return(string.Empty);
}
/// <summary>
/// Graba los datos de un <see cref="Models.DataWarehouses.DataWarehouseModel"/> en un archivo
/// </summary>
public void SaveDataWarehouse(DataWarehouseModel dataWarehouse)
{
string fileName = ReportingSolution.GetFileName(dataWarehouse);
// Graba el archivo
if (string.IsNullOrWhiteSpace(fileName))
{
throw new NotImplementedException($"Cant find file name for '{dataWarehouse.Name}'");
}
else
{
new Repositories.DataWarehouseRepository().Save(dataWarehouse, fileName);
}
}
/// <summary>
/// Carga los datos de un <see cref="DataWarehouseModel"/>
/// </summary>
internal DataWarehouseModel Load(ReportingSchemaModel schema, string fileName)
{
DataWarehouseModel dataWarehouse = new DataWarehouseModel(schema);
// Carga los datos
if (System.IO.File.Exists(fileName))
{
MLFile fileML = new LibMarkupLanguage.Services.XML.XMLParser().Load(fileName);
if (fileML != null)
{
foreach (MLNode rootML in fileML.Nodes)
{
if (rootML.Name == TagRoot)
{
// Asigna las propiedades
dataWarehouse.Id = rootML.Attributes[TagId].Value.TrimIgnoreNull();
dataWarehouse.Name = rootML.Nodes[TagName].Value.TrimIgnoreNull();
dataWarehouse.Description = rootML.Nodes[TagDescription].Value.TrimIgnoreNull();
// Carga las dimensiones y orígenes de datos
foreach (MLNode nodeML in rootML.Nodes)
{
switch (nodeML.Name)
{
case TagDataSourceTable:
dataWarehouse.DataSources.Add(LoadDataSourceTable(dataWarehouse, nodeML));
break;
case TagDataSourceSql:
dataWarehouse.DataSources.Add(LoadDataSourceSql(dataWarehouse, nodeML));
break;
case TagDimension:
dataWarehouse.Dimensions.Add(LoadDimension(nodeML, dataWarehouse));
break;
case TagReport:
dataWarehouse.Reports.Add(LoadReport(nodeML, dataWarehouse));
break;
}
}
}
}
}
}
// Devuelve los datos del almacén de datos
return(dataWarehouse);
}
/// <summary>
/// Crea los registros de informes
/// </summary>
private void CreateReports(DataWarehouseModel dataWarehouse)
{
int reportId = 1, relationId = 1;
// Crea los registros
foreach (ReportModel report in dataWarehouse.Reports.EnumerateValues())
{
// Guarda el Id
DataBaseIds.Add(("Report", report.Id, reportId, null));
// Inserta el registro
Builder.AppendLine($@"INSERT INTO Reports (ReportId, Name, Description)
VALUES ({reportId}, {Convert(report.Id)}, {Convert(report.Description)});" );
// Incrementa el Id
reportId++;
}
// Inserta las relaciones
foreach (ReportModel report in dataWarehouse.Reports.EnumerateValues())
{
// Obtiene el Id del informe
reportId = GetDataBaseId("Report", report.Id);
// Guarda las relaciones del informe
foreach (ReportDataSourceModel reportDataSource in report.ReportDataSources)
{
int dataSourceId = GetDataBaseId("DataSource", reportDataSource.DataSource.Id);
foreach (DimensionRelationModel dimensionRelation in reportDataSource.Relations)
{
int targetDimensionId = GetDataBaseId("Dimension", dimensionRelation.Dimension.Id);
// Graba las tablas foráneas
foreach (RelationForeignKey foreignKey in dimensionRelation.ForeignKeys)
{
// Inserta el registro
Builder.AppendLine($@"INSERT INTO ReportRelations (RelationId, ReportId, SourceDataSourceId, SourceColumnId, TargetDimensionId, TargetColumnId)
VALUES ({relationId}, {reportId}, {dataSourceId},
{GetDataBaseId("Column", foreignKey.ColumnId, reportDataSource.DataSource.Id)},
{targetDimensionId},
{GetDataBaseId("Column", foreignKey.TargetColumnId, dimensionRelation.Dimension.DataSource.Id)});" );
// Incrementa el Id
relationId++;
}
}
}
}
}
/// <summary>
/// Carga los datos de un <see cref="ReportModel"/>
/// </summary>
private ReportModel LoadReport(MLNode rootML, DataWarehouseModel dataWarehouse)
{
ReportModel report = new ReportModel(dataWarehouse);
// Carga el informe
report.Id = rootML.Attributes[TagId].Value.TrimIgnoreNull();
report.Description = rootML.Nodes[TagDescription].Value.TrimIgnoreNull();
// Carga los datos
foreach (MLNode nodeML in rootML.Nodes)
{
switch (nodeML.Name)
{
case TagDataSource:
report.ReportDataSources.Add(LoadReportDataSource(nodeML, report));
break;
}
}
// Devuelve el objeto
return(report);
}
/// <summary>
/// Crea las líneas de origen de datos
/// </summary>
private void CreateDataSources(DataWarehouseModel dataWarehouse)
{
int dataSourceId = 1, columnId = 1, parameterId = 1;
// Inserta los orígenes de datos
foreach (BaseDataSourceModel dataSource in dataWarehouse.DataSources.EnumerateValues())
{
// Inserta los registros
if (dataSource is DataSourceTableModel dataSourceTable)
{
CreateDataSource(dataSourceId, dataSourceTable, ref columnId);
}
else if (dataSource is DataSourceSqlModel dataSourceSql)
{
CreateDataSource(dataSourceId, dataSourceSql, ref columnId, ref parameterId);
}
// Incrementa el id
dataSourceId++;
}
}
/// <summary>
/// Obtiene un origen de datos para una tabla
/// </summary>
private DataSourceTableModel LoadDataSourceTable(DataWarehouseModel dataWarehouse, MLNode rootML)
{
DataSourceTableModel dataSource = new DataSourceTableModel(dataWarehouse);
// Asigna el esquema y la tabla
dataSource.Schema = rootML.Attributes[TagSchema].Value.TrimIgnoreNull();
dataSource.Table = rootML.Attributes[TagTable].Value.TrimIgnoreNull();
// El Id del origen de datos es el nombre completo de la tabla
dataSource.Id = dataSource.FullName;
// Carga las columnas
foreach (MLNode nodeML in rootML.Nodes)
{
if (nodeML.Name == TagColumn)
{
dataSource.Columns.Add(LoadColumn(dataSource, nodeML));
}
}
// Devuelve el origen de datos
return(dataSource);
}
/// <summary>
/// Carga los datos de una dimension
/// </summary>
private DimensionModel LoadDimension(MLNode rootML, DataWarehouseModel dataWarehouse)
{
DimensionModel dimension = new DimensionModel(dataWarehouse);
// Carga las propiedades básicas
dimension.Id = rootML.Attributes[TagId].Value.TrimIgnoreNull();
dimension.Description = rootML.Nodes[TagDescription].Value.TrimIgnoreNull();
// Carga los datos de la dimensión
dimension.DataSource = dataWarehouse.DataSources[rootML.Attributes[TagSourceId].Value.TrimIgnoreNull()];
// Carga las dimensiones hija
foreach (MLNode nodeML in rootML.Nodes)
{
if (nodeML.Name == TagRelation)
{
dimension.Relations.Add(LoadRelatedDimension(nodeML, dataWarehouse));
}
}
// Devuelve la dimensión
return(dimension);
}
/// <summary>
/// Convierte un archivo de esquema de base de datos en un <see cref="DataWarehouseModel"/>
/// </summary>
internal DataWarehouseModel Convert(ReportingSchemaModel schema, string name, string fileName)
{
SchemaDbModel schemaDb = new LibDbSchema.Repository.Xml.SchemaXmlManager().Load(fileName);
DataWarehouseModel dataWarehouse = new DataWarehouseModel(schema);
// Asigna las propiedades
dataWarehouse.Name = name;
// Genera los orígenes de datos de las tablas
foreach (TableDbModel table in schemaDb.Tables)
{
dataWarehouse.DataSources.Add(ConvertDataSource(dataWarehouse, table));
}
// Genera los orígenes de datos de las vistas
foreach (ViewDbModel view in schemaDb.Views)
{
dataWarehouse.DataSources.Add(ConvertDataSource(dataWarehouse, view));
}
// Devuelve el objeto
return(dataWarehouse);
}
/// <summary>
/// Carga los datos de una dimension relacionada
/// </summary>
private DimensionRelationModel LoadRelatedDimension(MLNode rootML, DataWarehouseModel dataWarehouse)
{
DimensionRelationModel relation = new DimensionRelationModel(dataWarehouse);
// Carga los datos de la dimensión
relation.DimensionId = rootML.Attributes[TagSourceId].Value.TrimIgnoreNull();
// Carga las columnas
foreach (MLNode nodeML in rootML.Nodes)
{
if (nodeML.Name == TagForeignKey)
{
relation.ForeignKeys.Add(new RelationForeignKey
{
ColumnId = nodeML.Attributes[TagColumn].Value.TrimIgnoreNull(),
TargetColumnId = nodeML.Attributes[TagDimensionColumn].Value.TrimIgnoreNull()
}
);
}
}
// Devuelve la relación
return(relation);
}
/// <summary>
/// Convierte una tabla de base de datos en un esquema
/// </summary>
private DataSourceTableModel ConvertDataSource(DataWarehouseModel dataWarehouse, BaseTableDbModel table)
{
DataSourceTableModel dataSource = new DataSourceTableModel(dataWarehouse);
// Asigna los datos
dataSource.Schema = table.Schema;
dataSource.Table = table.Name;
// Asigna las columnas
foreach (FieldDbModel field in table.Fields)
{
DataSourceColumnModel column = new DataSourceColumnModel(dataSource);
// Asigna las propiedades
column.Id = field.Name;
column.IsPrimaryKey = field.IsKey;
column.Type = Convert(field.Type);
column.Required = field.IsRequired;
// Añade la columna
dataSource.Columns.Add(column);
}
// Devuelve el origen de datos
return(dataSource);
}
/// <summary>
/// Crea los registros de dimensiones
/// </summary>
private void CreateDimensions(DataWarehouseModel dataWarehouse)
{
int dimensionId = 1, relationId = 1;
// Crea los registros
foreach (DimensionModel dimension in dataWarehouse.Dimensions.EnumerateValues())
{
// Guarda el Id
DataBaseIds.Add(("Dimension", dimension.Id, dimensionId, null));
// Inserta el registro
Builder.AppendLine($@"INSERT INTO Dimensions (DimensionId, Name, DataSourceId)
VALUES ({dimensionId}, {Convert(dimension.Id)}, {GetDataBaseId("DataSource", dimension.DataSource.Id)});" );
// Incrementa el Id
dimensionId++;
}
// Inserta las relaciones
foreach (DimensionModel dimension in dataWarehouse.Dimensions.EnumerateValues())
{
int sourceDimensionId = GetDataBaseId("Dimension", dimension.Id);
foreach (DimensionRelationModel relation in dimension.Relations)
{
int targetDimensionId = GetDataBaseId("Dimension", relation.Dimension.Id);
// Graba las tablas foráneas
foreach (RelationForeignKey foreignKey in relation.ForeignKeys)
{
// Inserta el registro
Builder.AppendLine($@"INSERT INTO DimensionRelations (RelationId, SourceDimensionId, SourceColumnId, TargetDimensionId, TargetColumnId)
VALUES ({relationId}, {sourceDimensionId}, {GetDataBaseId("Column", foreignKey.ColumnId, dimension.DataSource.Id)},
{targetDimensionId}, {GetDataBaseId("Column", foreignKey.TargetColumnId, relation.Dimension.DataSource.Id)});" );
// Incrementa el Id
relationId++;
}
}
}
}
/// <summary>
/// Graba los datos de un <see cref="DataWarehouseModel"/>
/// </summary>
internal void Save(DataWarehouseModel dataWarehouse, string fileName)
{
MLFile fileML = new MLFile();
MLNode rootML = fileML.Nodes.Add(TagRoot);
// Añade las propiedades básicas
rootML.Attributes.Add(TagId, dataWarehouse.Id);
rootML.Nodes.Add(TagName, dataWarehouse.Name);
rootML.Nodes.Add(TagDescription, dataWarehouse.Description);
// Añade los nodos de orígenes de datos
foreach (BaseDataSourceModel baseDataSource in dataWarehouse.DataSources.EnumerateValues())
{
switch (baseDataSource)
{
case DataSourceTableModel dataSource:
rootML.Nodes.Add(GetNodeDataSourceTable(dataSource));
break;
case DataSourceSqlModel dataSource:
rootML.Nodes.Add(GetNodeDataSourceSql(dataSource));
break;
}
}
// Añade los nodos de dimensión
foreach (DimensionModel dimension in dataWarehouse.Dimensions.EnumerateValues())
{
rootML.Nodes.Add(GetNodeDimension(dimension));
}
// Añade los informes
foreach (ReportModel report in dataWarehouse.Reports.EnumerateValues())
{
rootML.Nodes.Add(GetNodeReport(report));
}
// Graba el archivo
new LibMarkupLanguage.Services.XML.XMLWriter().Save(fileName, fileML);
}
public NodeDataWarehouseViewModel(BaseTreeViewModel trvTree, IHierarchicalViewModel parent, DataWarehouseModel dataWarehouse) :
base(trvTree, parent, dataWarehouse.Name, TreeReportingViewModel.NodeType.DataWarehouse.ToString(), TreeReportingViewModel.IconType.Connection.ToString(),
dataWarehouse, true, true, MvvmColor.Red)
{
DataWarehouse = dataWarehouse;
}
public DataSourceTableModel(DataWarehouseModel dataWarehouse) : base(dataWarehouse)
{
}
public DimensionModel(DataWarehouseModel dataWarehouse)
{
DataWarehouse = dataWarehouse;
}
protected BaseDataSourceModel(DataWarehouseModel dataWarehouse)
{
DataWarehouse = dataWarehouse;
}
/// <summary>
/// Graba los datos de un <see cref="DataWarehouseModel"/> en un archivo
/// </summary>
public void SaveDataWarehouse(DataWarehouseModel dataWarehouse, string fileName)
{
new Repositories.DataWarehouseRepository().Save(dataWarehouse, fileName);
}
public ReportModel(DataWarehouseModel dataWarehouse)
{
DataWarehouse = dataWarehouse;
}
