public ActionResult Edit(ReportDataSourceModel model)
{
using (Muse db = new Muse())
{
int flag = db.Update(model, true);
if (flag > 0)
{
return(RedirectToAction("Index"));
}
else
{
return(View());
}
}
//try
//{
// // TODO: Add update logic here
// return RedirectToAction("Index");
//}
//catch
//{
// return View();
//}
}
public ActionResult Create(ReportDataSourceModel model)
{
using (Muse db = new Muse())
{
model.Id = Guid.NewGuid();
model.CreateUser = User.Identity.Name;
int flag = db.Add(model, true);
if (flag > 0)
{
return(RedirectToAction("Index"));
}
else
{
return(View());
}
}
//try
//{
// // TODO: Add insert logic here
// return RedirectToAction("Index");
//}
//catch
//{
// return View();
//}
}
/// <summary>
/// Obtiene el origen de datos del informe con sus relaciones
/// </summary>
internal ReportDataSourceModel GetReportDataSource()
{
ReportDataSourceModel dataSource = new ReportDataSourceModel(Report)
{
DataSource = GetDataSource()
};
// Añade las relaciones
dataSource.Relations.AddRange(ListRelationsViewModel.GetRelations());
// Devuelve el origen de datos del informe
return(dataSource);
}
/// <summary>
/// Obtiene los campos de dimensión por los que se va a agrupar (no se recojen directamente de las dimensiones solicitadas porque el
/// orden de solicitud importa): estos campos de dimensión son los campos clave
/// </summary>
private void ComputeFieldsGroupBy(QueryModel query, ReportDataSourceModel dataSource, List <QueryModel> dimensionQueries)
{
foreach (DimensionRequestModel dimensionRequest in Generator.Request.Dimensions)
{
DimensionModel dimension = GetDimension(dimensionRequest);
// Añade las relaciones
foreach (DimensionRelationModel relation in dataSource.Relations)
{
if (relation.Dimension.Id.Equals(dimension.Id, StringComparison.CurrentCultureIgnoreCase))
{
query.Joins.Add(CreateJoin(dimension, relation, dimensionQueries));
}
}
}
}
public ActionResult Delete(Guid id, ReportDataSourceModel model)
{
using (Muse db = new Muse())
{
var record = db.Get <ReportDataSourceModel>(x => x.Id == id, null);
int flag = db.Del(record, true);
if (flag > 0)
{
return(RedirectToAction("Index"));
}
else
{
return(View());
}
}
}
/// <summary>
/// Carga los nodos de relaciones con dimensiones del informe
/// </summary>
private void LoadNodesRelations(NodeRootViewModel parentDataSource, ReportDataSourceModel expression)
{
foreach (DimensionRelationModel relation in expression.Relations)
{
NodeRootViewModel parentDimension = new NodeRootViewModel(TreeViewModel, parentDataSource, TreeReportingViewModel.NodeType.DimensionsRoot, relation.Dimension.Id, false,
true, BauMvvm.ViewModels.Media.MvvmColor.Navy);
// Añade el campo raíz al árbol
parentDataSource.Children.Add(parentDimension);
// Añade los campos de la relación
foreach (RelationForeignKey column in relation.ForeignKeys)
{
parentDimension.Children.Add(new NodeRootViewModel(TreeViewModel, parentDimension, TreeReportingViewModel.NodeType.File,
$"{column.ColumnId} -> {column.TargetColumnId}", false,
false, BauMvvm.ViewModels.Media.MvvmColor.Black));
}
}
}
/// <summary>
/// Obtiene la consulta de las expresiones
/// </summary>
internal QueryModel GetQuery(List <QueryModel> dimensionQueries)
{
//TODO En realidad, un informe puede tener varios orígenes de datos, cuál de los orígenes de datos se escoge, depende de ciertas condiciones como las dimensiones
//TODO escogidas en la solicitud, para las primeras pruebas, cogemos directamente la primera solicitud
ReportDataSourceModel reportDataSource = Generator.Report.ReportDataSources[0];
BaseDataSourceModel baseDataSource = reportDataSource.DataSource;
QueryModel query = new QueryModel(baseDataSource.Id, QueryModel.QueryType.Expressions, GetDataSourceAlias(baseDataSource));
// Prepara la consulta
query.Prepare(baseDataSource);
// Añade los campos que vienen de otras dimensiones
ComputeDimensionFields(query, dimensionQueries);
// Obtiene los campos por los que vamos a agrupar y los añade a la colección de claves de dimensión de la consulta
ComputeFieldsGroupBy(query, reportDataSource, dimensionQueries);
// Obtiene los campos agrupados
ComputeFieldsGrouped(query, Generator.Request, baseDataSource);
// Devuelve la consulta
return(query);
}
public ReportDataSourceViewModel(ReportingSolutionViewModel reportingSolutionViewModel, ReportModel report, ReportDataSourceModel reportDataSource)
{
// Inicializa los objetos
ReportingSolutionViewModel = reportingSolutionViewModel;
Report = report;
ReportDataSource = reportDataSource;
// Inicializa las propiedades
InitViewModel();
// Inicializa el manejador de eventos sobre el combo
ComboDataSources.PropertyChanged += (sender, args) => {
if (args.PropertyName.Equals(nameof(ComboDataSources.SelectedItem)))
{
// Carga las relaciones
LoadRelations();
// Indica que se ha hecho alguna modificación
IsUpdated = true;
}
};
}
/// <summary>
/// Carga un origen de datos de un informe
/// </summary>
private ReportDataSourceModel LoadReportDataSource(MLNode rootML, ReportModel report)
{
ReportDataSourceModel dataSource = new ReportDataSourceModel(report);
// Asigna las propiedades
dataSource.DataSource = report.DataWarehouse.DataSources[rootML.Attributes[TagSourceId].Value.TrimIgnoreNull()];
// Carga las expresiones
foreach (MLNode childML in rootML.Nodes)
{
switch (childML.Name)
{
case TagRelation:
dataSource.Relations.Add(LoadRelatedDimension(childML, report.DataWarehouse));
break;
}
}
// Devuelve el origen de datos
return(dataSource);
}
