/// <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; }