/// <summary>
/// updateTimeSeries
/// </summary>
private void updateCompareChart(WasteTransferTimeSeriesFilter filter, WasteTypeFilter.Type wasteType)
{
CurrentWasteType = wasteType;
// view everything, user may select other years to compare
dataFound(true);
// init year combo boxes
int year1 = this.ucYearCompare.Year1;
int year2 = this.ucYearCompare.Year2;
// get compare result compare char
TimeSeriesClasses.ComparisonWasteTransfer result = WasteTransferTrend.GetComparisonTimeSeries(filter, year1, year2, wasteType);
bool foundData = (result.TotalFrom != null || result.TotalTo != null);
if (foundData)
{
dataFound(true);
Color[] colors = new Color[] { Global.ColorWasteTotal, Global.ColorWasteTotal };
ChartHatchStyle[] hatchStyles = new ChartHatchStyle[] { Global.HatchStyleBothYears, Global.HatchStyleTotal };
string[] legendTexts = new string[] { Resources.GetGlobal("Common", "FacilitiesBothYears"), Resources.GetGlobal("Common", "AllFacilities") };
this.ucStackColumnCompare.Initialize(colors.Length, StackColumnType.Comparison, CODE_TNE, colors, hatchStyles, legendTexts);
// from and to bar
TimeSeriesUtils.BarData dataFrom = new TimeSeriesUtils.BarData
{
Year = result.YearFrom,
Values = new double?[] { TimeSeriesUtils.RangeValue(result.BothTotalFrom), TimeSeriesUtils.RangeValue(result.TotalFrom) - TimeSeriesUtils.RangeValue(result.BothTotalFrom) },
};
TimeSeriesUtils.BarData dataTo = new TimeSeriesUtils.BarData
{
Year = result.YearTo,
Values = new double?[] { TimeSeriesUtils.RangeValue(result.BothTotalTo), TimeSeriesUtils.RangeValue(result.TotalTo) - TimeSeriesUtils.RangeValue(result.BothTotalTo) },
};
// from and to bar
this.ucStackColumnCompare.Add(new List <TimeSeriesUtils.BarData>()
{
dataFrom, dataTo
});
// update sinle table
updateTable(result);
}
else
{
dataFound(false);
}
}
/// <summary>
/// updateTableReportFacilities
/// </summary>
private void updateTable(TimeSeriesClasses.ComparisonWasteTransfer data)
{
this.grdCompareDetailsAll.Visible = true;
this.grdCompareDetailsBothYears.Visible = true;
//all facilities
List <CompareDetailElement> elementsAll = new List <CompareDetailElement>();
elementsAll.Add(new CompareDetailElement(Resources.GetGlobal("Common", "Total"),
data != null ? QuantityFormat.Format(data.TotalFrom, CODE_TNE) : String.Empty,
data != null ? QuantityFormat.Format(data.TotalTo, CODE_TNE) : String.Empty));
elementsAll.Add(new CompareDetailElement(Resources.GetGlobal("Common", "Recovery"),
data != null ? QuantityFormat.Format(data.RecoveryFrom, CODE_TNE) : String.Empty,
data != null ? QuantityFormat.Format(data.RecoveryTo, CODE_TNE) : String.Empty));
elementsAll.Add(new CompareDetailElement(Resources.GetGlobal("Common", "Disposal"),
data != null ? QuantityFormat.Format(data.DisposalFrom, CODE_TNE) : String.Empty,
data != null ? QuantityFormat.Format(data.DisposalTo, CODE_TNE) : String.Empty));
elementsAll.Add(new CompareDetailElement(Resources.GetGlobal("Common", "Unspecified"),
data != null ? QuantityFormat.Format(data.UnspecFrom, CODE_TNE) : String.Empty,
data != null ? QuantityFormat.Format(data.UnspecTo, CODE_TNE) : String.Empty));
elementsAll.Add(new CompareDetailElement(Resources.GetGlobal("Common", "Facilities"),
data != null ? NumberFormat.Format(data.FacilitiesFrom) : String.Empty,
data != null ? NumberFormat.Format(data.FacilitiesTo) : String.Empty));
//facilites in both years
List <CompareDetailElement> elementsBothYears = new List <CompareDetailElement>();
elementsBothYears.Add(new CompareDetailElement(Resources.GetGlobal("Common", "Total"),
data != null ? QuantityFormat.Format(data.BothTotalFrom, CODE_TNE) : String.Empty,
data != null ? QuantityFormat.Format(data.BothTotalTo, CODE_TNE) : String.Empty));
elementsBothYears.Add(new CompareDetailElement(Resources.GetGlobal("Common", "Recovery"),
data != null ? QuantityFormat.Format(data.BothRecoveryFrom, CODE_TNE) : String.Empty,
data != null ? QuantityFormat.Format(data.BothRecoveryTo, CODE_TNE) : String.Empty));
elementsBothYears.Add(new CompareDetailElement(Resources.GetGlobal("Common", "Disposal"),
data != null ? QuantityFormat.Format(data.BothDisposalFrom, CODE_TNE) : String.Empty,
data != null ? QuantityFormat.Format(data.BothDisposalTo, CODE_TNE) : String.Empty));
elementsBothYears.Add(new CompareDetailElement(Resources.GetGlobal("Common", "Unspecified"),
data != null ? QuantityFormat.Format(data.BothUnspecFrom, CODE_TNE) : String.Empty,
data != null ? QuantityFormat.Format(data.BothUnspecTo, CODE_TNE) : String.Empty));
elementsBothYears.Add(new CompareDetailElement(Resources.GetGlobal("Common", "Facilities"),
data != null ? NumberFormat.Format(data.BothFacilities) : String.Empty,
data != null ? NumberFormat.Format(data.BothFacilities) : String.Empty));
// data binding
this.grdCompareDetailsAll.DataSource = elementsAll;
grdCompareDetailsAll.DataBind();
this.grdCompareDetailsBothYears.DataSource = elementsBothYears;
grdCompareDetailsBothYears.DataBind();
}
// ---------------------------------------------------------------------------------------------------
// Comparison
// ---------------------------------------------------------------------------------------------------
#region comparison
/// <summary>
/// GetComparisonTimeSeries
/// </summary>
public static TimeSeriesClasses.ComparisonWasteTransfer GetComparisonTimeSeries(WasteTransferTimeSeriesFilter filter, int yearFrom, int yearTo, WasteTypeFilter.Type wasteType)
{
// Create lambda with pollutant release filter
Expression <Func <WASTETRANSFER, bool> > lambda = getLambdaExpression(filter, wasteType);
DataClassesWasteTransferDataContext db = new DataClassesWasteTransferDataContext();
// group by reporting year, get from and to data
IQueryable <IGrouping <int, WASTETRANSFER> > groupFrom = db.WASTETRANSFERs.Where(lambda).Where(p => p.ReportingYear == yearFrom).GroupBy(p => p.ReportingYear);
IQueryable <IGrouping <int, WASTETRANSFER> > groupTo = db.WASTETRANSFERs.Where(lambda).Where(p => p.ReportingYear == yearTo).GroupBy(p => p.ReportingYear);
// Facility IDs when year is 'yearTo'
var vTo = db.WASTETRANSFERs.Where(lambda).Where(p => p.ReportingYear == yearTo).Select(p => p.FacilityID).Distinct();
IQueryable <IGrouping <int, WASTETRANSFER> > groupDataFromBoth = db.WASTETRANSFERs.Where(lambda).Where(p => p.ReportingYear == yearFrom && vTo.Contains(p.FacilityID)).GroupBy(p => p.ReportingYear);
// Facility IDs when year is 'yearFrom'
var vFrom = db.WASTETRANSFERs.Where(lambda).Where(p => p.ReportingYear == yearFrom).Select(p => p.FacilityID).Distinct();
IQueryable <IGrouping <int, WASTETRANSFER> > groupDataToBoth = db.WASTETRANSFERs.Where(lambda).Where(p => p.ReportingYear == yearTo && vFrom.Contains(p.FacilityID)).GroupBy(p => p.ReportingYear);
// result lists
IEnumerable <TimeSeriesClasses.TsWasteCompare> dataFrom = null, dataTo = null;
IEnumerable <TimeSeriesClasses.TsWasteCompare> dataFromBoth = null, dataToBoth = null;
switch (wasteType)
{
case WasteTypeFilter.Type.HazardousCountry:
dataFrom = groupFrom.Select(x => new TimeSeriesClasses.TsWasteCompare(x.Count(), x.Sum(p => p.QuantityTotalHWIC), x.Sum(p => p.QuantityRecoveryHWIC), x.Sum(p => p.QuantityDisposalHWIC), x.Sum(p => p.QuantityUnspecHWIC)));
dataTo = groupTo.Select(x => new TimeSeriesClasses.TsWasteCompare(x.Count(), x.Sum(p => p.QuantityTotalHWIC), x.Sum(p => p.QuantityRecoveryHWIC), x.Sum(p => p.QuantityDisposalHWIC), x.Sum(p => p.QuantityUnspecHWIC)));
dataFromBoth = groupDataFromBoth.Select(x => new TimeSeriesClasses.TsWasteCompare(x.Count(), x.Sum(p => p.QuantityTotalHWIC), x.Sum(p => p.QuantityRecoveryHWIC), x.Sum(p => p.QuantityDisposalHWIC), x.Sum(p => p.QuantityUnspecHWIC)));
dataToBoth = groupDataToBoth.Select(x => new TimeSeriesClasses.TsWasteCompare(x.Count(), x.Sum(p => p.QuantityTotalHWIC), x.Sum(p => p.QuantityRecoveryHWIC), x.Sum(p => p.QuantityDisposalHWIC), x.Sum(p => p.QuantityUnspecHWIC)));
break;
case WasteTypeFilter.Type.HazardousTransboundary:
dataFrom = groupFrom.Select(x => new TimeSeriesClasses.TsWasteCompare(x.Count(), x.Sum(p => p.QuantityTotalHWOC), x.Sum(p => p.QuantityRecoveryHWOC), x.Sum(p => p.QuantityDisposalHWOC), x.Sum(p => p.QuantityUnspecHWOC)));
dataTo = groupTo.Select(x => new TimeSeriesClasses.TsWasteCompare(x.Count(), x.Sum(p => p.QuantityTotalHWOC), x.Sum(p => p.QuantityRecoveryHWOC), x.Sum(p => p.QuantityDisposalHWOC), x.Sum(p => p.QuantityUnspecHWOC)));
dataFromBoth = groupDataFromBoth.Select(x => new TimeSeriesClasses.TsWasteCompare(x.Count(), x.Sum(p => p.QuantityTotalHWOC), x.Sum(p => p.QuantityRecoveryHWOC), x.Sum(p => p.QuantityDisposalHWOC), x.Sum(p => p.QuantityUnspecHWOC)));
dataToBoth = groupDataToBoth.Select(x => new TimeSeriesClasses.TsWasteCompare(x.Count(), x.Sum(p => p.QuantityTotalHWOC), x.Sum(p => p.QuantityRecoveryHWOC), x.Sum(p => p.QuantityDisposalHWOC), x.Sum(p => p.QuantityUnspecHWOC)));
break;
case WasteTypeFilter.Type.NonHazardous:
dataFrom = groupFrom.Select(x => new TimeSeriesClasses.TsWasteCompare(x.Count(), x.Sum(p => p.QuantityTotalNONHW), x.Sum(p => p.QuantityRecoveryNONHW), x.Sum(p => p.QuantityDisposalNONHW), x.Sum(p => p.QuantityUnspecNONHW)));
dataTo = groupTo.Select(x => new TimeSeriesClasses.TsWasteCompare(x.Count(), x.Sum(p => p.QuantityTotalNONHW), x.Sum(p => p.QuantityRecoveryNONHW), x.Sum(p => p.QuantityDisposalNONHW), x.Sum(p => p.QuantityUnspecNONHW)));
dataFromBoth = groupDataFromBoth.Select(x => new TimeSeriesClasses.TsWasteCompare(x.Count(), x.Sum(p => p.QuantityTotalNONHW), x.Sum(p => p.QuantityRecoveryNONHW), x.Sum(p => p.QuantityDisposalNONHW), x.Sum(p => p.QuantityUnspecNONHW)));
dataToBoth = groupDataToBoth.Select(x => new TimeSeriesClasses.TsWasteCompare(x.Count(), x.Sum(p => p.QuantityTotalNONHW), x.Sum(p => p.QuantityRecoveryNONHW), x.Sum(p => p.QuantityDisposalNONHW), x.Sum(p => p.QuantityUnspecNONHW)));
break;
default: return(null);
}
TimeSeriesClasses.ComparisonWasteTransfer result = new TimeSeriesClasses.ComparisonWasteTransfer(yearFrom, yearTo);
var res = dataFrom.SingleOrDefault();
if (res != null)
{
result.SetFrom(res.Count, res.Quantity, res.Recovery, res.Disposal, res.Unspecified);
}
res = dataTo.SingleOrDefault();
if (res != null)
{
result.SetTo(res.Count, res.Quantity, res.Recovery, res.Disposal, res.Unspecified);
}
res = dataFromBoth.SingleOrDefault();
if (res != null)
{
result.SetBothFrom(res.Count, res.Quantity, res.Recovery, res.Disposal, res.Unspecified);
}
res = dataToBoth.SingleOrDefault();
if (res != null)
{
result.SetBothTo(res.Count, res.Quantity, res.Recovery, res.Disposal, res.Unspecified);
}
return(result);
}
