public DashboardComplex ConvertToDALEntity(ApiDashboard businessEntity)
{
var result1 = new DalDashboard(businessEntity.Id, businessEntity.User.Id, businessEntity.Name, businessEntity.IsVisible, businessEntity.Order);
result1.IsDirty = businessEntity.IsDirty;
result1.IsMarkForDeletion = businessEntity.IsMarkForDeletion;
var result2 = new List <DalDashboardFilterRelation>();
for (int i = 0; i < businessEntity.Relations.Count; i++)
{
ApiDashboardFilterRelation relation = businessEntity.Relations[i];
if (relation.Filter != null && relation.Filter is ApiFilter)
{
var tmp = new DalDashboardFilterRelation(relation.Id, businessEntity.Id, (relation.Filter as ApiFilter).Id, null, relation.IsVisible, relation.Order);
tmp.IsDirty = relation.IsDirty;
tmp.IsMarkForDeletion = relation.IsMarkForDeletion;
result2.Add(tmp);
}
if (relation.Filter != null && relation.Filter is ApiDashboard)
{
var tmp = new DalDashboardFilterRelation(relation.Id, businessEntity.Id, null, (relation.Filter as ApiDashboard).Id, relation.IsVisible, relation.Order);
tmp.IsDirty = relation.IsDirty;
tmp.IsMarkForDeletion = relation.IsMarkForDeletion;
result2.Add(tmp);
}
}
return(new DashboardComplex(result1, result2));
}
public ApiDashboard ConvertToApiEntity(DalDashboard dataEntity)
{
var result = new ApiDashboard(dataEntity.Id, _user, dataEntity.Name, dataEntity.IsVisible, dataEntity.Order);
result.IsDirty = dataEntity.IsDirty;
result.IsMarkForDeletion = dataEntity.IsMarkForDeletion;
return(result);
}
private void DeleteDashboard(ApiDashboard dashboard)
{
var tmp = DashboardMapper.ConvertToDALEntity(dashboard);
foreach (var relation in tmp.Relations)
{
DashboardFilterRelationAdapter.Delete(relation.Id);
}
DashboardAdapter.Delete(tmp.Dashboard.Id);
}
private IDashboardOutput GenerateDashboardOutput(ApiDashboard dashboard, List <IApiOperation> iOperations)
{
var root = new DashboardOutput();
root.Name = dashboard.Name;
var generator = new DashboardOutputGenerator();
generator.Generate(ref root, dashboard, iOperations);
return(root);
}
public IActionResult Dashboard([FromQuery] ApiDashboardSearchParams dashParams)
{
// get all variable outgoings
var now = DateTime.UtcNow;
var from = now;
switch (dashParams.Range)
{
case DashboardRange.SevenDays:
from = now.AddDays(-7);
break;
case DashboardRange.OneMonth:
from = now.AddMonths(-1);
break;
case DashboardRange.ThreeMonths:
from = now.AddMonths(-3);
break;
case DashboardRange.OneYear:
from = now.AddYears(-1);
break;
default:
from = now.AddDays(-7);
break;
}
var dates = Enumerable.Range(0, (int)(now - from).TotalDays).Select(x => DateTime.UtcNow.AddDays(-x)).OrderBy(x => x);
var model = new ApiDashboard
{
Labels = dates.Select(x => x.ToString("dd/MM/yyyy")).ToList()
};
var transactions = _uow.Transactions.GetAll()
.Where(t => t.UserId == Token.UserId)
.Where(t => t.Category.Type != CategoryType.Income)
.Where(t => t.Date >= from)
.Where(t => t.Date <= now)
.GroupBy(t => t.CategoryId)
.ToList();
model.Datasets = transactions.Select(ts =>
{
return(GetDataset(dates, ts));
})
.ToList();
return(new JsonResult(model));
}
private void InsertDashboard(ref ApiDashboard dashboard)
{
var tmp = DashboardMapper.ConvertToDALEntity(dashboard);
var idx = DashboardAdapter.Insert(tmp.Dashboard);
dashboard.UpdateId(idx);
foreach (var relation in tmp.Relations)
{
relation.UpdateDashboardId(idx);
DashboardFilterRelationAdapter.Insert(relation);
}
}
public void UpdateDashboardComplex(ref ApiDashboard dashboard)
{
if (dashboard.IsMarkForDeletion)
{
DeleteDashboard(dashboard);
}
else if (dashboard.IsDirty && dashboard.Id == null)
{
InsertDashboard(ref dashboard);
}
else if (dashboard.IsDirty)
{
UpdateDashboard(dashboard);
}
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
var jsonObject = JObject.Load(reader);
IApiFilter iFilter;
if (jsonObject["Relations"] != null)
{
iFilter = new ApiDashboard();
}
else
{
iFilter = new ApiFilter();
}
serializer.Populate(jsonObject.CreateReader(), iFilter);
return(iFilter);
}
public void Generate(ref DashboardOutput input, ApiDashboard dashboard, List <IApiOperation> operations)
{
foreach (var relation in dashboard.Relations)
{
if (relation.Filter is ApiFilter)
{
var filter = relation.Filter as ApiFilter;
var tmp = new DashboardOutputLeaf();
tmp.Name = filter.Name;
tmp.Result = _analyzer.Run(filter, operations);
input.Children.Add(tmp);
}
else
{
var innerDashboard = relation.Filter as ApiDashboard;
var tmp = new DashboardOutput();
tmp.Name = innerDashboard.Name;
input.Children.Add(tmp);
Generate(ref tmp, innerDashboard, operations);
}
}
}
public DalDashboardFilterRelation ConvertToDALEntity(ApiDashboardFilterRelation businessEntity, ApiDashboard source, ApiDashboardFilterRelation next)
{
int?filterId = null;
int?dashboardId = null;
if (businessEntity.Filter is ApiFilter)
{
filterId = (businessEntity.Filter as ApiFilter).Id;
}
else
{
dashboardId = (businessEntity.Filter as ApiDashboard).Id;
}
var result = new DalDashboardFilterRelation(businessEntity.Id, source.Id, filterId, dashboardId, businessEntity.IsVisible, businessEntity.Order);
result.IsDirty = businessEntity.IsDirty;
result.IsMarkForDeletion = businessEntity.IsMarkForDeletion;
return(result);
}
public IEnumerable <DalDashboardFilterRelation> ConvertToDALEntitiesCollection(IEnumerable <ApiDashboardFilterRelation> dataEntities, ApiDashboard source)
{
var result = new List <DalDashboardFilterRelation>();
for (var i = 0; i < dataEntities.Count(); ++i)
{
var item = dataEntities.ElementAt(i);
var next = (i + 1) < dataEntities.Count()?dataEntities.ElementAt(i + 1):null;
result.Add(ConvertToDALEntity(item, source, next));
}
return(result);
}
private void UpdateDashboard(ref ApiDashboard dashboard)
{
_apiAdapter.UpdateDashboardComplex(ref dashboard);
}
