/// <summary>
/// Añade un nodo de dimensión (y sus hijos)
/// </summary>
private void AddDimensionNodes(NodeColumnViewModel root, DimensionModel dimension)
{
NodeColumnViewModel node = new NodeColumnViewModel(this, root, NodeColumnViewModel.NodeColumnType.Dimension,
dimension.Id, null);
BaseReportingDictionaryModel <DimensionModel> childs = new BaseReportingDictionaryModel <DimensionModel>();
// Asigna el código de dimensión
node.DimensionId = dimension.Id;
// Añade los campos de la dimensión
AddColumnNodes(node, dimension.DataSource.Columns, NodeColumnViewModel.NodeColumnType.DimensionColumn, dimension.Id, string.Empty);
// Crea la colección de dimensiones hija a partir de las relaciones
foreach (DimensionRelationModel relation in dimension.Relations)
{
if (relation.Dimension != null)
{
childs.Add(relation.Dimension);
}
}
// Añade los nodos de dimensión hija
foreach (DimensionModel child in childs.EnumerateValuesSorted())
{
AddDimensionNodes(node, child);
}
// Añade el nodo a la raíz
root.Children.Add(node);
}
/// <summary>
/// Obtiene la consulta de una dimensión
/// </summary>
private QueryModel GetChildQuery(DimensionRequestModel dimensionRequest)
{
DimensionModel dimension = GetDimension(dimensionRequest);
QueryModel query = new QueryModel(dimensionRequest.DimensionId, QueryModel.QueryType.Dimension, dimension.Id);
// Prepara la consulta
query.Prepare(dimension.DataSource);
// Añade los campos clave
foreach (DataSourceColumnModel column in dimension.DataSource.Columns.EnumerateValues())
{
if (column.IsPrimaryKey)
{
query.AddPrimaryKey(dimensionRequest.GetRequestColumn(column.Id), column.Id, CheckIsColumnAtColumnRequested(column, dimensionRequest.Columns));
}
}
// Asigna los campos
foreach (DimensionColumnRequestModel columnRequest in dimensionRequest.Columns)
{
DataSourceColumnModel column = dimension.DataSource.Columns[columnRequest.ColumnId];
if (column != null && !column.IsPrimaryKey)
{
query.AddColumn(columnRequest.ColumnId, columnRequest);
}
}
// Devuelve la consulta
return(query);
}
public ListItemForeignKeyViewModel(DataSourceColumnModel sourceColumn, DimensionModel targetDimension, string targetColumnId)
{
// Asigna las propiedades
SourceColumn = sourceColumn;
TargetDimension = targetDimension;
TargetColumnId = targetColumnId;
// Inicializa el ViewModel
InitViewModel();
}
public int Edit(int id, DimensionModel ObjDimensionModel)
{
try
{
if (id > 0)
{
if (ObjDimensionModel != null)
{
Dimension ObjDimension = DBContext.Dimensions.Where(a => a.Dimension_ID == id).FirstOrDefault();
if (ObjDimension != null)
{
//DimensionModel Edit Properties mapping here.
//ObjDimension.Profile_Name = ObjDimensionModel.Profile_Name;
//ObjDimension.Password = ObjDimensionModel.Password;
//ObjDimension.First_Name = ObjDimensionModel.First_Name;
//ObjDimension.Middle_Name = ObjDimensionModel.Middle_Name;
//ObjDimension.Last_Name = ObjDimensionModel.Last_Name;
//ObjDimension.Email_Address = ObjDimensionModel.Email_Address;
//ObjDimension.Contact_Number = ObjDimensionModel.Contact_Number;
//ObjDimension.Cell_Number = ObjDimensionModel.Cell_Number;
//ObjDimension.Location_ID = ObjDimensionModel.Location_ID;
//ObjDimension.PickUp_Address = ObjDimensionModel.PickUp_Address;
//ObjDimension.Drop_Address = ObjDimensionModel.Drop_Address;
//ObjDimension.QR_Code = ObjDimensionModel.QR_Code;
//ObjDimension.Rating = ObjDimensionModel.Rating;
//ObjDimension.Created_DateTime = ObjDimensionModel.Created_DateTime;
//ObjDimension.Created_By = ObjDimensionModel.Created_By;
//ObjDimension.Modified_DateTime = ObjDimensionModel.Modified_DateTime;
//ObjDimension.Modified_By = ObjDimensionModel.Modified_By;
//ObjDimension.Deleted = ObjDimensionModel.Deleted;
DBContext.SubmitChanges();
return(ObjDimension.Dimension_ID);
}
else
{
return(WebApiResponse.NoRecordFound);
}
}
else
{
return(WebApiResponse.InputObjectIsNull);
}
}
else
{
return(WebApiResponse.InputIdInvalid);
}
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// Obtiene la dimensión
/// </summary>
protected DimensionModel GetDimension(DimensionRequestModel dimensionRequest)
{
DimensionModel dimension = Generator.Report.DataWarehouse.Dimensions[dimensionRequest.DimensionId];
// Devuelve la dimensión localizada o lanza una excepción
if (dimension == null)
{
throw new LibReporting.Models.Exceptions.ReportingException($"Cant find the dimension {dimensionRequest.DimensionId}");
}
else
{
return(dimension);
}
}
/// <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 Edit(int id, DimensionModel ObjInputDimensionModel)
{
//Customized try catch block by Imran Khan. CodeSnippet
try
{
string JsonString = string.Empty;
string ApiURL = OTS.GlobalSettings.WebAPIURL + this.GetType().Name.Replace("Controller", string.Empty) + "/" + System.Reflection.MethodBase.GetCurrentMethod().Name + "/" + id;
int UpdatedDimensionId = 0;
UpdatedDimensionId = (int)iWebServiceConsumer.ConsumeJsonWebService(ApiURL, ObjInputDimensionModel, UpdatedDimensionId, OTS.GlobalSettings.WebAPITimeout, out JsonString);
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
ViewBag.Error = ex.ToString();
return(View("Error"));
}
}
public async void SaveDimensions()
{
DimensionModel dimensionModel = new DimensionModel()
{
Density = this.Density,
Length = this.Length,
Weight = this.Weight,
Width = this.Width,
Thickness = this.Thickness
};
string requestUrl = "http://10.6.0.133/api/Test";
ServiceHandler serviceHandler = new ServiceHandler();
string jsonContent = JsonConvert.SerializeObject(dimensionModel);
string result = await serviceHandler.PostRequest(requestUrl, jsonContent);
//BaseResponse addGroupResponse = (BaseResponse)JsonConvert.DeserializeObject(result, typeof(BaseResponse));
}
public DimensionViewModel(ReportingSolutionViewModel reportingSolutionViewModel, DimensionModel dimension, bool isNew)
{
// Inicializa los objetos
ReportingSolutionViewModel = reportingSolutionViewModel;
Dimension = dimension;
// Inicializa las variables
_isNew = isNew;
// Inicializa las propiedades
InitViewModel();
// Asigna los manejadores de eventos
ListRelationsViewModel.PropertyChanged += (sender, args) => {
if (args.PropertyName.Equals(nameof(ListRelationsViewModel.IsUpdated)))
{
IsUpdated |= ListRelationsViewModel.IsUpdated;
}
};
}
/// <summary>
/// Obtiene la consulta para una dimensión del informe
/// </summary>
internal QueryModel GetQuery(DimensionRequestModel dimensionRequest)
{
List <QueryModel> childsQueries = new List <QueryModel>();
DimensionModel dimension = GetDimension(dimensionRequest);
QueryModel query = GetChildQuery(dimensionRequest);
// Obtiene las consultas de las dimensiones hija: si hay algún campo solicitado de alguna dimensión hija,
// necesitaremos también la consulta de esta dimensión para poder hacer el JOIN posterior, por eso las
// calculamos antes que la consulta de esta dimensión
foreach (DimensionRequestModel childDimension in dimensionRequest.Childs)
{
QueryModel childQuery = GetQuery(childDimension);
// Añade la query si realmente hay algo que añadir
if (childQuery != null)
{
childsQueries.Add(childQuery);
}
}
// Añade las consultas con las dimensiones hija
if (childsQueries.Count > 0)
{
foreach (QueryModel childQuery in childsQueries)
{
QueryJoinModel join = new QueryJoinModel(QueryJoinModel.JoinType.Inner, childQuery, $"child_{childQuery.Alias}");
// Asigna las relaciones
foreach (DimensionRelationModel relation in dimension.Relations)
{
if (relation.Dimension.Id.Equals(childQuery.SourceId, StringComparison.CurrentCultureIgnoreCase))
{
foreach (RelationForeignKey foreignKey in relation.ForeignKeys)
{
join.Relations.Add(new QueryRelationModel(foreignKey.ColumnId, childQuery.FromAlias, foreignKey.TargetColumnId));
}
}
}
// Añade la unión
query.Joins.Add(join);
}
}
// Devuelve la consulta
return(query);
}
/// <summary>
/// Obtiene el nodo de una dimensión
/// </summary>
private MLNode GetNodeDimension(DimensionModel dimension)
{
MLNode nodeML = new MLNode(TagDimension);
// Asigna las propiedades
nodeML.Attributes.Add(TagId, dimension.Id);
nodeML.Nodes.Add(TagDescription, dimension.Description);
nodeML.Attributes.Add(TagSourceId, dimension.DataSource.Id);
// Añade las relaciones hija
foreach (DimensionRelationModel relation in dimension.Relations)
{
if (relation.Dimension != null)
{
nodeML.Nodes.Add(GetNodeRelation(relation));
}
}
// Devuelve el nodo
return(nodeML);
}
/// <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);
}
public async void LoadCost(int id)
{
string requestUrl = "http://10.6.0.133/api/Test?id=" + id;
ServiceHandler serviceHandler = new ServiceHandler();
string result = await serviceHandler.RequestData(requestUrl);
//DimensionModel dimensionModel = (DimensionModel)JsonConvert.DeserializeObject(result, typeof(DimensionModel));
DimensionModel dimensionModel = new DimensionModel()
{
Density = 100,
Length = 123,
Weight = 12,
Width = 33,
Thickness = 3
};
this.Density = dimensionModel.Density;
this.Length = dimensionModel.Length;
this.Weight = dimensionModel.Weight;
this.Width = dimensionModel.Width;
this.Thickness = dimensionModel.Thickness;
}
public int Delete(int id, DimensionModel ObjInputDimensionModel)
{
try
{
//Just keep ObjInputDimensionModel as parameter for Deleted Log.
Dimension ObjDimension = DBContext.Dimensions.Where(a => a.Dimension_ID == id).FirstOrDefault();
if (ObjDimension != null)
{
DBContext.Dimensions.DeleteOnSubmit(ObjDimension);
DBContext.SubmitChanges();
return(ObjDimension.Dimension_ID);
}
else
{
return(0);
}
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// Crea un JOIN con una dimensión
/// </summary>
private QueryJoinModel CreateJoin(DimensionModel dimension, DimensionRelationModel relation, List <QueryModel> dimensionQueries)
{
QueryModel query = new QueryModel(dimension.Id, QueryModel.QueryType.Dimension, dimension.Id);
QueryJoinModel join = new QueryJoinModel(QueryJoinModel.JoinType.Inner, query, dimension.Id);
QueryModel relatedQuery = dimensionQueries.FirstOrDefault(item => item.SourceId.Equals(dimension.Id, StringComparison.CurrentCultureIgnoreCase));
// Asigna los datos apropiados a la consulta (sólo necesitamos los nombres de tabla)
query.Prepare(dimension.Id, dimension.Id);
// Añade las relaciones
if (relatedQuery != null)
{
foreach (RelationForeignKey column in relation.ForeignKeys)
{
QueryFieldModel relatedField = relatedQuery.Fields.FirstOrDefault(item => item.Field.Equals(column.TargetColumnId, StringComparison.CurrentCultureIgnoreCase));
if (relatedField != null)
{
join.Relations.Add(new QueryRelationModel(column.ColumnId, relatedQuery.Alias, relatedField.Alias));
}
}
}
// Devuelve el join
return(join);
}
public NodeDimensionViewModel(BaseTreeViewModel trvTree, BaseTreeNodeViewModel parent, DimensionModel dimension) :
base(trvTree, parent, dimension.Id, TreeReportingViewModel.NodeType.Dimension.ToString(), TreeReportingViewModel.IconType.Dimension.ToString(),
dimension, true, true, BauMvvm.ViewModels.Media.MvvmColor.Navy)
{
Dimension = dimension;
}
internal QueryForeignKeyFieldModel(DimensionModel dimension, string columnDimension, string columnRelated)
{
Dimension = dimension;
ColumnDimension = columnDimension;
ColumnRelated = columnRelated;
}
