/// <summary>
/// Ritorna la granularità con cui mostrare i dati di trend
/// </summary>
/// <param name="StartDate">Date</param>
/// <param name="EndDate">Week</param>
/// <returns>Tipo del periodo</returns>
public static enAggregation GetAggregationType(DateTime StartDate, DateTime EndDate)
{
enAggregation granularity = enAggregation.Day;
int diffDays = (EndDate - StartDate).Days;
int diffMonth = EndDate.MonthDifference(StartDate);
int diffYear = EndDate.Year - StartDate.Year;
if (diffDays >= 0 && diffDays < 7)
{
granularity = enAggregation.Day;
}
else if (diffDays >= 7 && diffMonth <= 1)
{
granularity = enAggregation.Week;
}
else if (diffMonth > 1 && diffMonth < 7)
{
granularity = enAggregation.Month;
}
else if (diffMonth >= 7)
{
granularity = enAggregation.Quarter;
}
else if (diffYear > 1)
{
granularity = enAggregation.Year;
}
return(granularity);
}
/// <summary>
/// Convert period value to Datetime
/// </summary>
/// <param name="period"></param>
/// <param name="typePeriod"></param>
/// <returns></returns>
public static DateTime?PeriodToDate(this int period, enAggregation typePeriod)
{
DateTime?result = null;
int day = 0;
int month = 0;
int year = 0;
switch (typePeriod)
{
case enAggregation.Day:
Math.DivRem(period, 10000, out year);
Math.DivRem(period % 10000, 100, out month);
day = period % 100;
result = new DateTime(year, month, day);
break;
case enAggregation.Week:
Math.DivRem(period, 100, out year);
result = Common.StartOfWeek(year, period % 100, DayOfWeek.Monday);
break;
case enAggregation.Month:
Math.DivRem(period, 100, out year);
month = period % 100;
day = 1;
result = new DateTime(year, month, day);
break;
}
return(result);
}
public static string GetTimeCategory(DateTime day, enAggregation granularity)
{
string category = "";
switch (granularity)
{
case enAggregation.Day:
category = day.ToString("dd/MM");
break;
case enAggregation.Week:
category = $"w{day.GetWeekNumber()}";
break;
case enAggregation.Month:
category = day.ToString("MMM", CultureInfo.InvariantCulture);
break;
case enAggregation.Quarter:
category = $"Q{day.GetQuarter()}/{day.ToString("yyyy", CultureInfo.InvariantCulture)}";
break;
case enAggregation.Year:
category = day.ToString("yyyy", CultureInfo.InvariantCulture);
break;
default:
break;
}
return(category);
}
public static List <string> GetTimeCategories(List <DateTime> days, enAggregation granularity)
{
List <string> categories = new List <string>();
switch (granularity)
{
case enAggregation.Day:
categories = days.Select(s => s.ToString("dd/MM")).ToList();
break;
case enAggregation.Week:
categories = days.Select(s => $"w{s.GetWeekNumber()}").Distinct().ToList();
break;
case enAggregation.Month:
categories = days.Select(s => s.ToString("MMM", CultureInfo.InvariantCulture)).Distinct().ToList();
break;
case enAggregation.Quarter:
categories = days.Select(s => $"Q{s.GetQuarter()}/{s.ToString("yyyy", CultureInfo.InvariantCulture)}").Distinct().ToList();
break;
case enAggregation.Year:
categories = days.Select(s => s.ToString("yyyy", CultureInfo.InvariantCulture)).Distinct().ToList();
break;
default:
break;
}
return(categories);
}
public static PeriodModel GetPeriodModel(DateTime start, DateTime end, enAggregation type)
{
PeriodModel result = new PeriodModel();
try
{
result.StartDate = start;
result.EndDate = end;
result.Aggregation = type;
DataUpdateModel dataUpdate = new DataUpdateModel();
dataUpdate.DateTime = end;
result.LastUpdate = dataUpdate;
}
catch (Exception ex)
{
LogService.WriteLog(ex.GetStringLog(), LogService.TypeLevel.Error, ex);
}
return(result);
}
/// <summary>
/// Ritorna la data inziale del trend sula base della data di fine e la granularità
/// </summary>
/// <param name="EndDate">EndDate</param>
/// <param name="Granularity">Granularity</param>
/// <returns>Data di inizio</returns>
public static DateTime GetStartDateTrend(DateTime EndDate, DateTime StartDate, enAggregation Granularity)
{
var daysDiff = (EndDate - StartDate).Days;
if (daysDiff < 6)
{
return(EndDate.AddDays(-6).Date);
}
else
{
return(StartDate);
}
}
private List <long> GetDataGroup(List <HistoryStateModel> data, List <DateTime> days, enAggregation granularity, enState state)
{
List <long> lista = new List <long>();
switch (granularity)
{
case enAggregation.Day:
lista = days.Select(d =>
data.Where(w => w.enState == state && w.Day.Value == d)
.Select(s => s.ElapsedTime ?? 0).DefaultIfEmpty(0).First()).ToList();
break;
case enAggregation.Week:
var weeks = data.Where(w => w.enState == state).GroupBy(a => a.Day.Value.GetWeekNumber())
.Select(n => new { week = n.Key, somma = n.Sum(o => o.ElapsedTime ?? 0) }).ToList();
lista = days.Select(s => s.GetWeekNumber()).Distinct().ToList()
.Select(d => weeks.Where(l => l.week == d).FirstOrDefault()?.somma ?? 0).ToList();
break;
case enAggregation.Month:
var months = data.Where(w => w.enState == state).GroupBy(a => a.Day.Value.Month)
.Select(n => new { month = n.Key, somma = n.Sum(o => o.ElapsedTime ?? 0) }).ToList();
lista = days.Select(s => s.Month).Distinct().ToList()
.Select(d => months.Where(l => l.month == d).FirstOrDefault()?.somma ?? 0).ToList();
break;
case enAggregation.Quarter:
var quarters = data.Where(w => w.enState == state).GroupBy(a => a.Day.Value.GetQuarter() + (a.Day.Value.Year * 10))
.Select(n => new { quarter = n.Key, somma = n.Sum(o => o.ElapsedTime ?? 0) }).ToList();
lista = days.Select(s => s.GetQuarter() + (s.Year * 10)).Distinct().ToList()
.Select(d => quarters.Where(l => l.quarter == d).FirstOrDefault()?.somma ?? 0).ToList();
break;
case enAggregation.Year:
var years = data.Where(w => w.enState == state).GroupBy(a => a.Day.Value.Year)
.Select(n => new { year = n.Key, somma = n.Sum(o => o.ElapsedTime ?? 0) }).ToList();
lista = days.Select(s => s.Year).Distinct().ToList()
.Select(d => years.Where(l => l.year == d).FirstOrDefault()?.somma ?? 0).ToList();
break;
default:
break;
}
return(lista);
}
