public void Process(CSET_Context db, int aggregationID, LineChart response, string Type)
{
var results = db.usp_GetTop5Areas(aggregationID);
HashSet <int> labels = new HashSet <int>();
Dictionary <string, ChartDataSet> datasets = new Dictionary <string, ChartDataSet>();
foreach (usp_GetTop5Areas_result r in results.Where(x => x.TopBottomType == Type))
{
ChartDataSet ds1;
if (!datasets.TryGetValue(r.Question_Group_Heading, out ds1))
{
var ds = new ChartDataSet();
ds.label = r.Question_Group_Heading;
response.datasets.Add(ds);
datasets.Add(r.Question_Group_Heading, ds);
ds.data.Add((float)r.percentage);
}
else
{
ds1.data.Add((float)r.percentage);
}
if (!labels.Contains(r.Assessment_Id))
{
response.labels.Add(r.Assessment_Date.ToString("d-MMM-yyyy"));
labels.Add(r.Assessment_Id);
}
}
}
public JsonResult GetTicketStatusChartData()
{
var colorList = new List <string>();
colorList.Add("#D3D3D3");
colorList.Add("#ffa1a1");
colorList.Add("#F2f3f7");
colorList.Add("#6c757d");
colorList.Add("#232323");
var rand = new Random();
var barChartVM = new ChartVM();
var chartDataSet = new ChartDataSet();
var statuses = db.TicketStatuses.ToList();
var dataKey = 0;
foreach (var status in statuses)
{
var count = db.Tickets.Where(t => t.TicketStatusId == status.Id).Count();
//barChartVM.Datasets.Add(new KeyValuePair<int, string>(count, colorList[dataKey]));
chartDataSet.data.Add(count);
chartDataSet.backgroundColor.Add(colorList[dataKey]);
barChartVM.labels.Add(status.Name);
dataKey++;
}
barChartVM.datasets.Add(chartDataSet);
return(Json(barChartVM, JsonRequestBehavior.AllowGet));
}
// GET: GetCurrentBalancChart
public JsonResult AccountBalanceChartData()
{
var hhId = User.Identity.GetHouseholdId();
var colorList = new List <string>();
colorList.Add("#4f98c3");
colorList.Add("#d2d6de");
colorList.Add("#232323");
colorList.Add("#FFFF00");
colorList.Add("#000000");
var rand = new Random();
var chartVM = new ChartVM();
var chartDataSet = new ChartDataSet();
var bankaccounts = db.BankAccounts.Where(b => b.HouseholdId == hhId).ToList();
var dataKey = 0;
//chartVM.Datasets.Insert(dataKey, "");
foreach (var accountbalance in bankaccounts)
{
//barChartVM.Datasets.Add(new KeyValuePair<int, string>(count, colorList[dataKey]));
chartDataSet.data.Add(accountbalance.CurrentBalance);
chartDataSet.backgroundColor.Add(colorList[dataKey]);
chartVM.labels.Add(accountbalance.BankAccountType.Type);
dataKey++;
}
chartVM.datasets.Add(chartDataSet);
return(Json(chartVM, JsonRequestBehavior.AllowGet));
}
// GET: GetTicketPriorityChart
public JsonResult GetTicketPriorityChart()
{
var colorList = new List <string>();
colorList.Add("#D3D3D3");
colorList.Add("#ffa1a1");
colorList.Add("#232323");
colorList.Add("#FFFF00");
var rand = new Random();
var chartVM = new ChartVM();
var chartDataSet = new ChartDataSet();
var priorities = db.TicketPriorities.ToList();
var dataKey = 0;
//barChartVM.Datasets.Insert(dataKey, "Priorities");
foreach (var priority in priorities)
{
var count = db.Tickets.Where(t => t.TicketPriorityId == priority.Id).Count();
//barChartVM.Datasets.Add(new KeyValuePair<int, string>(count, colorList[dataKey]));
chartDataSet.data.Add(count);
chartDataSet.backgroundColor.Add(colorList[dataKey]);
chartVM.labels.Add(priority.Name);
dataKey++;
}
chartVM.datasets.Add(chartDataSet);
return(Json(chartVM, JsonRequestBehavior.AllowGet));
}
public HorizBarChart GetCategoryAverages()
{
TokenManager tm = new TokenManager();
var aggregationID = tm.PayloadInt("aggreg");
if (aggregationID == null)
{
return(null);
}
var dict = new Dictionary <string, List <decimal> >();
using (CSET_Context db = new CSET_Context())
{
var assessmentList = db.AGGREGATION_ASSESSMENT.Where(x => x.Aggregation_Id == aggregationID)
.Include(x => x.Assessment_).OrderBy(x => x.Assessment_.Assessment_Date)
.ToList();
foreach (var a in assessmentList)
{
db.LoadStoredProc("[usp_getStandardsResultsByCategory]")
.WithSqlParam("assessment_id", a.Assessment_Id)
.ExecuteStoredProc((handler) =>
{
// usp_getStandardsResultsByCategory 15
var procResults = (List <usp_getStandardsResultsByCategory>)handler.ReadToList <usp_getStandardsResultsByCategory>();
foreach (var procResult in procResults)
{
if (!dict.ContainsKey(procResult.Question_Group_Heading))
{
dict.Add(procResult.Question_Group_Heading, new List <decimal>());
}
if (procResult.Actualcr > 0)
{
dict[procResult.Question_Group_Heading].Add(procResult.prc);
}
}
});
}
}
var catList = dict.Keys.ToList();
catList.Sort();
var response = new HorizBarChart();
var ds = new ChartDataSet();
response.datasets.Add(ds);
response.labels.AddRange(catList);
foreach (string cat in catList)
{
ds.data.Add((float)dict[cat].DefaultIfEmpty(0).Average());
}
return(response);
}
public async Task <IActionResult> GetCharts(int deviceId)
{
if (deviceId == 0)
{
var valueList0 = new List <double?>()
{
0, 0, 0, 0, 0
};
var stringList0 = new List <string>()
{
"", "", "", "", ""
};
var dataSets0 = new ChartDataSet("Sensör Verileri", new ChartColor()
{
Red = 72, Green = 192, Blue = 192, Alpha = 0.4
}, valueList0, stringList0);
Charts = new List <Chart>()
{
GetChart(dataSets0)
};
return(View());
}
Charts = new List <Chart>();
var apiService = new ApiServices();
var accesstoken = await apiService.LoginAsync("*****@*****.**", "BioGuy2015");
var sensorDataList = await _apiService.SearchDevicesAsync(deviceId, accesstoken);
var sensorTypeList = await _apiService.GetSensorTypesAsync(accesstoken);
var colorClass = new ColorsSet();
var colorListForCharts = colorClass.Colors;
for (int i = 0; i < sensorTypeList.Count; i++)
{
var sensorName = sensorTypeList[i].Name;
var dataList = sensorDataList.Where(x => x.TypeId == sensorTypeList[i].Id);
var groupDataList = dataList.Skip(6).Select(x => new { sValue = x.Value, sTime = DateTime.Parse(x.Time) }).GroupBy(x => x.sTime.Day).ToList();
var valueList = groupDataList.Select(x => x.Average(z => z.sValue)).ToList();
var stringList = (groupDataList.Select(x => (x.First().sTime.Date.Date).ToString("dd.MM.yyyy"))).ToList();
var colorIndex = i % (colorListForCharts.Count());
var color = colorListForCharts[colorIndex];
var datasets = new ChartDataSet(sensorName, color, valueList, stringList);
var chart = GetChart(datasets);
Charts.Add(chart);
break;
}
return(View());
}
public async Task <AccountPeriodBalanceReportModel> GetAccountBalanceForPeriodRangeAsync(AccountBalancePeriodRangeModel accPeriodBal)
{
var returnVal = new AccountPeriodBalanceReportModel();
using (var uow = await _applicationDbFactory.BeginUnitOfWorkAsync())
{
var periodStartDate = uow.Periods.GetAll().First(i => i.PeriodId == accPeriodBal.StartPeriodId).PeriodDate;
var periodEndDate = uow.Periods.GetAll().First(i => i.PeriodId == accPeriodBal.EndPeriodId).PeriodDate;
var accounts = uow.Accounts.GetAll().Where(i => i.AccountId == accPeriodBal.AccountId || accPeriodBal.AccountId == 0)
.Select(i => new { AccountId = i.AccountId, AccountName = i.AccountName }).OrderBy(i => i.AccountName).ToList();
var periods = uow.Periods.GetAll().Where(i => i.PeriodDate >= periodStartDate && i.PeriodDate <= periodEndDate)
.Select(i => new { PeriodId = i.PeriodId, PeriodDate = i.PeriodDate, Discription = i.Discription }).
OrderBy(i => i.PeriodDate).ToList();
var accountPeriodBalance = uow.AccountPeriodBalances.GetAll()
.Where(i => accounts.Select(a => a.AccountId).Contains(i.AccountId) &&
periods.Select(p => p.PeriodId).Contains(i.PeriodId))
.Select(i => new { PeriodId = i.PeriodId, AccountId = i.AccountId, Balance = i.Balance }).ToList();
Random rnd = new Random();
returnVal.Period = periods.Select(i => i.Discription).ToList();
foreach (var account in accounts)
{
var accBal = new ChartDataSet
{
Data = new List <decimal>(),
BorderColor = "#" + Color.FromArgb(rnd.Next(256), rnd.Next(256), rnd.Next(256)).Name,
Label = account.AccountName
};
foreach (var period in periods)
{
var amount = accountPeriodBalance.FirstOrDefault(i => i.AccountId == account.AccountId && i.PeriodId == period.PeriodId);
if (amount == null)
{
accBal.Data.Add(0);
}
else
{
accBal.Data.Add(amount.Balance);
}
}
returnVal.DataSet.Add(accBal);
}
return(returnVal);
}
}
public static ChartData GetChartData(AnalyticsDataResponse apiResults)
{
// Get the amount of dimensions and metrics
int dimensions = apiResults.ColumnHeaders.Count(x => x.ColumnType == "DIMENSION");
int metrics = apiResults.ColumnHeaders.Count(x => x.ColumnType == "METRIC");
// Initialize the data object
ChartData cd = new ChartData
{
labels = apiResults.Rows.Select(row => row.Cells[0].Value).ToArray(),
datasets = new ChartDataSet[metrics]
};
// Add a dataset for each metric
for (int metric = 0; metric < metrics; metric++)
{
// Initialize the data object
ChartDataSet ds = cd.datasets[metric] = new ChartDataSet();
ds.fillColor = GetFillColor(metric);
ds.strokeColor = GetStrokeColor(metric);
ds.highlightFill = GetHighlightFillColor(metric);
ds.highlightStroke = GetHighlightStrokeColor(metric);
ds.data = new object[apiResults.Rows.Length];
for (int row = 0; row < apiResults.Rows.Length; row++)
{
// Get the value
string value = apiResults.Rows[row].Cells[dimensions + metric].Value;
// Set the value with the proper type
if (Regex.IsMatch(value, "^[0-9]+$"))
{
ds.data[row] = Int32.Parse(value);
}
else
{
ds.data[row] = value;
}
}
}
return(cd);
}
/// <summary>
/// Get Dashboard Data async
/// </summary>
/// <param name=""></param>
/// <param name=""></param>
/// <returns></returns>
public async Task <Response <List <DashboardResponse> > > GetDashboardDataAsync()
{
try
{
IEnumerable <Dashboard> dashboard = await _chatbotDataContext.Dashboard.FromSql("icb.usp_DashboardGetReportData").ToListAsync();
DashboardResponse dashboardResponse = new DashboardResponse();
IEnumerable <string> chartLabels = dashboard.Select(x => x.InterviewMonth).Distinct();
dashboardResponse.ChartLabel.AddRange(chartLabels);
foreach (string technologyStack in dashboard.Select(x => x.TechnologyStackDisplayName).Distinct())
{
ChartDataSet chartDataSet = new ChartDataSet
{
Label = technologyStack
};
foreach (string interviewMonth in dashboard.Select(x => x.InterviewMonth).Distinct())
{
chartDataSet.Data.AddRange
(
dashboard.Where(x => x.TechnologyStackDisplayName == technologyStack && x.InterviewMonth == interviewMonth)
.Select(x => x.MonthlyInterviewCount)
);
}
dashboardResponse.ChartDataSet.Add(chartDataSet);
}
return(Response.Ok(new List <DashboardResponse> {
dashboardResponse
}));
}
catch (Exception)
{
return(Response.Fail <List <DashboardResponse> >("Something went wrong", ResponseType.GenericError));
}
}
public ChartDataSet GetPlayerDetailsChartData(int id, byte interval, byte dataKind)
{
var result = new ChartDataSet();
var player = _dbContext.Player.SingleOrDefault(p => p.Id == id);
if (player == null)
{
return(result);
}
var startDate = ChartDataSet.GetStartDate(interval);
if (startDate == null)
{
return(result);
}
var relevantData = _dbContext.PlayerHistory.Where(ph => ph.PlayerId == id && ph.RecordedAt >= startDate)
.OrderBy(ph => ph.RecordedAt)
.AsEnumerable() // Flesh out the data before client-side grouping
.GroupBy(ph => ph.RecordedAt.Date)
.Select(g =>
new {
RecordedAt = g.Key,
HistoryEntry = g.OrderByDescending(ph => ph.RecordedAt).First()
}
);
switch (dataKind)
{
case (byte)ChartDataSet.DataKind.StatsTotal:
result.AddRange(
relevantData.Select(he => new ChartDataPoint {
t = he.RecordedAt, y = (double)he.HistoryEntry.StatTotal
})
);
break;
case (byte)ChartDataSet.DataKind.Credits:
result.AddRange(
relevantData.Select(he => new ChartDataPoint {
t = he.RecordedAt, y = (double)he.HistoryEntry.Bank
})
);
break;
case (byte)ChartDataSet.DataKind.Bonds:
result.AddRange(
relevantData.Select(he => new ChartDataPoint {
t = he.RecordedAt, y = (double)he.HistoryEntry.Bonds
})
);
break;
case (byte)ChartDataSet.DataKind.XP:
result.AddRange(
relevantData.Select(he => new ChartDataPoint {
t = he.RecordedAt, y = (double)he.HistoryEntry.Level
})
);
break;
default: // This means invalid input data
return(result);
}
return(result);
}
public HorizBarChart GetOverallComparison()
{
TokenManager tm = new TokenManager();
var aggregationID = tm.PayloadInt("aggreg");
if (aggregationID == null)
{
return(null);
}
var response = new HorizBarChart();
response.reportTitle = "Overall Comparison";
var statTypes = new List <string>()
{
"Overall", "Standards", "Components"
};
response.labels.AddRange(statTypes);
using (CSET_Context db = new CSET_Context())
{
var assessmentList = db.AGGREGATION_ASSESSMENT.Where(x => x.Aggregation_Id == aggregationID)
.Include(x => x.Assessment_).OrderBy(x => x.Assessment_.Assessment_Date)
.ToList();
foreach (var a in assessmentList)
{
db.LoadStoredProc("[GetCombinedOveralls]")
.WithSqlParam("assessment_id", a.Assessment_Id)
.ExecuteStoredProc((handler) =>
{
var result = handler.ReadToList <GetCombinedOveralls>();
var g = (List <GetCombinedOveralls>)result;
Dictionary <string, double> dict = new Dictionary <string, double>();
dict["Standards"] = 0;
foreach (GetCombinedOveralls row in g)
{
if (row.StatType == "Requirement" || row.StatType == "Questions")
{
dict["Standards"] += row.Value;
}
else
{
dict[row.StatType] = row.Value;
}
}
var ds = new ChartDataSet
{
label = a.Alias
};
response.datasets.Add(ds);
foreach (var statType in statTypes)
{
ds.data.Add((float)dict[statType]);
}
});
}
}
return(response);
}
public LineChart OverallComplianceScore()
{
TokenManager tm = new TokenManager();
var aggregationID = tm.PayloadInt("aggreg");
if (aggregationID == null)
{
return(null);
}
using (CSET_Context db = new CSET_Context())
{
var assessmentList = db.AGGREGATION_ASSESSMENT.Where(x => x.Aggregation_Id == aggregationID)
.Include(x => x.Assessment_)
.Include(x => x.Assessment_.STANDARD_SELECTION)
.OrderBy(x => x.Assessment_.Assessment_Date)
.ToList();
// build the empty response structure for the assessments we have
var response = new LineChart
{
reportType = "Trend Overall Compliance Score"
};
List <string> lineNames = new List <string>()
{
"Overall", "Components", "Standards"
};
foreach (string name in lineNames)
{
var ds = new ChartDataSet
{
label = name
};
response.datasets.Add(ds);
foreach (var a in assessmentList)
{
ds.data.Add(0);
}
}
// populate percentages in the structure
for (int i = 0; i < assessmentList.Count; i++)
{
var a = assessmentList[i];
response.labels.Add(a.Assessment_.Assessment_Date.ToString("d-MMM-yyyy"));
db.LoadStoredProc("[GetCombinedOveralls]")
.WithSqlParam("assessment_id", a.Assessment_Id)
.ExecuteStoredProc((handler) =>
{
var procResults = (List <GetCombinedOveralls>)handler.ReadToList <GetCombinedOveralls>();
foreach (var procResult in procResults)
{
var mode = a.Assessment_.STANDARD_SELECTION.Application_Mode;
string stat = procResult.StatType;
// funnel questions and requirements into 'standards' if assessment mode matches
if ((mode.StartsWith("Questions") && procResult.StatType == "Questions") ||
(mode.StartsWith("Requirement") && procResult.StatType == "Requirement"))
{
stat = "Standards";
}
var ds = response.datasets.Find(x => x.label == stat);
if (ds != null)
{
ds.data[i] = (float)procResult.Value;
}
}
});
}
return(response);
}
}
public HorizBarChart GetOverallAverages()
{
TokenManager tm = new TokenManager();
var aggregationID = tm.PayloadInt("aggreg");
if (aggregationID == null)
{
return(null);
}
var response = new HorizBarChart();
response.reportTitle = "Overall Average Summary";
Dictionary <string, List <double> > dict = new Dictionary <string, List <double> >
{
["Questions"] = new List <double>(),
["Requirement"] = new List <double>(),
["Overall"] = new List <double>(),
["Components"] = new List <double>()
};
using (CSET_Context db = new CSET_Context())
{
var assessmentList = db.AGGREGATION_ASSESSMENT.Where(x => x.Aggregation_Id == aggregationID)
.Include(x => x.Assessment_).OrderBy(x => x.Assessment_.Assessment_Date)
.ToList();
foreach (var a in assessmentList)
{
db.LoadStoredProc("[GetCombinedOveralls]")
.WithSqlParam("assessment_id", a.Assessment_Id)
.ExecuteStoredProc((handler) =>
{
var procResults = (List <GetCombinedOveralls>)handler.ReadToList <GetCombinedOveralls>();
foreach (var procResult in procResults)
{
if (dict.ContainsKey(procResult.StatType))
{
dict[procResult.StatType].Add(procResult.Value);
}
}
});
}
var ds = new ChartDataSet();
response.datasets.Add(ds);
response.labels.Add("Overall");
ds.data.Add((float)dict["Overall"].DefaultIfEmpty(0).Average());
response.labels.Add("Standards");
ds.data.Add(
(float)dict["Questions"].DefaultIfEmpty(0).Average()
+ (float)dict["Requirement"].DefaultIfEmpty(0).Average());
response.labels.Add("Components");
ds.data.Add((float)dict["Components"].DefaultIfEmpty(0).Average());
return(response);
}
}
public HorizBarChart CategoryPercentCompare()
{
TokenManager tm = new TokenManager();
var aggregationID = tm.PayloadInt("aggreg");
if (aggregationID == null)
{
return(null);
}
DataTable dt = new DataTable();
dt.Columns.Add("AssessmentId", typeof(int));
dt.Columns.Add("Alias");
using (CSET_Context db = new CSET_Context())
{
var assessmentList = db.AGGREGATION_ASSESSMENT.Where(x => x.Aggregation_Id == aggregationID)
.Include(x => x.Assessment_).OrderBy(x => x.Assessment_.Assessment_Date)
.ToList();
foreach (var a in assessmentList)
{
var row = dt.NewRow();
row["AssessmentId"] = a.Assessment_Id;
row["Alias"] = a.Alias;
dt.Rows.Add(row);
var percentages = GetCategoryPercentages(a.Assessment_Id, db);
foreach (usp_getStandardsResultsByCategory pct in percentages)
{
if (!dt.Columns.Contains(pct.Question_Group_Heading))
{
dt.Columns.Add(pct.Question_Group_Heading, typeof(float));
}
row[pct.Question_Group_Heading] = pct.prc;
}
}
// build the response
List <string> categories = dt.Columns.Cast <DataColumn>()
.OrderBy(x => x.ColumnName)
.Select(x => x.ColumnName)
.ToList();
categories.Remove("AssessmentId");
categories.Remove("Alias");
var response = new HorizBarChart();
response.reportTitle = "Category Percent Comparisons";
foreach (string category in categories)
{
response.labels.Add(category);
}
foreach (DataRow rowAssessment in dt.Rows)
{
var ds = new ChartDataSet();
response.datasets.Add(ds);
ds.label = rowAssessment["Alias"].ToString();
foreach (string category in categories)
{
ds.data.Add(rowAssessment[category] != DBNull.Value ? (float)rowAssessment[category] : 0f);
}
}
return(response);
}
}
public Chart GetChart(ChartDataSet chartDataSets)
{
Chart chart = new Chart();
chart.Type = Enums.ChartType.Line;
ChartJSCore.Models.Data data = new ChartJSCore.Models.Data();
data.Datasets = new List <Dataset>();
data.Labels = chartDataSets.XValues;
LineDataset dataset = new LineDataset()
{
Label = chartDataSets.Title,
Data = chartDataSets.YValues.Select(x => (double?)Math.Round(x.Value, 2)).ToList(),
Fill = "false",
LineTension = 0.1,
BackgroundColor = chartDataSets.Color,
BorderColor = chartDataSets.Color,
BorderCapStyle = "butt",
BorderDash = new List <int> {
},
BorderDashOffset = 0.0,
BorderJoinStyle = "miter",
PointBorderColor = new List <ChartColor> {
chartDataSets.Color
},
PointBackgroundColor = new List <ChartColor> {
ChartColor.FromHexString("#ffffff")
},
PointBorderWidth = new List <int> {
1
},
PointHoverRadius = new List <int> {
5
},
PointHoverBackgroundColor = new List <ChartColor> {
chartDataSets.Color
},
PointHoverBorderColor = new List <ChartColor> {
chartDataSets.Color
},
PointHoverBorderWidth = new List <int> {
2
},
PointRadius = new List <int> {
1
},
PointHitRadius = new List <int> {
10
},
SpanGaps = false
};
data.Datasets.Add(dataset);
chart.Data = data;
return(chart);
}
public ChartDataSet GetSyndicateHistoricalData(int syndicateId, byte interval, byte dataKind)
{
var result = new ChartDataSet();
var syndicate = _dbContext.Syndicate.SingleOrDefault(s => s.Id == syndicateId);
if (syndicate == null)
{
return(result);
}
var startDate = ChartDataSet.GetStartDate(interval);
if (startDate == null)
{
return(result);
}
var relevantData = _dbContext.SyndicateHistory.Where(sh => sh.SyndicateId == syndicateId && sh.RecordedAt >= startDate)
.OrderBy(sh => sh.RecordedAt)
.AsEnumerable() // Flesh out the data before client-side grouping
.GroupBy(sh => sh.RecordedAt.Date)
.Select(g =>
new {
RecordedAt = g.Key,
HistoryEntry = g.OrderByDescending(sh => sh.RecordedAt).First()
}
);
switch (dataKind)
{
case (byte)ChartDataSet.DataKind.MemberCount:
result.AddRange(
relevantData.Select(he => new ChartDataPoint {
t = he.RecordedAt, y = (double)he.HistoryEntry.MembersCount
})
);
break;
case (byte)ChartDataSet.DataKind.Credits:
result.AddRange(
relevantData.Select(he => new ChartDataPoint {
t = he.RecordedAt, y = (double)he.HistoryEntry.Credits
})
);
break;
case (byte)ChartDataSet.DataKind.Bonds:
result.AddRange(
relevantData.Select(he => new ChartDataPoint {
t = he.RecordedAt, y = (double)he.HistoryEntry.Bonds
})
);
break;
case (byte)ChartDataSet.DataKind.XP:
result.AddRange(
relevantData.Select(he => new ChartDataPoint {
t = he.RecordedAt, y = (double)he.HistoryEntry.Level
})
);
break;
default: // This means invalid input data
return(result);
}
return(result);
}
