/// <summary>
/// updateTableReportFacilities
/// </summary>
private void updateTable(TimeSeriesClasses.ComparisonPollutant data)
{
this.grdCompareDetailsAll.Visible = true;
this.grdCompareDetailsBothYears.Visible = true;
//all facilites
List <CompareDetailElement> elementsAll = new List <CompareDetailElement>();
elementsAll.Add(new CompareDetailElement(Resources.GetGlobal("Common", "Quantity"),
data != null ? QuantityFormat.Format(data.QuantityFrom, CODE_KG) : String.Empty,
data != null ? QuantityFormat.Format(data.QuantityTo, CODE_KG) : 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", "Quantity"),
data != null ? QuantityFormat.Format(data.BothQuantityFrom, CODE_KG) : String.Empty,
data != null ? QuantityFormat.Format(data.BothQuantityTo, CODE_KG) : 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();
}
// public static string CODE_TNE = EnumUtil.GetStringValue(QuantityUnit.Tonnes);
// ---------------------------------------------------------------------------------------------------
// Comparison
// ---------------------------------------------------------------------------------------------------
#region comparison
/// <summary>
/// Returns data for comparison of two years corresponding to the filter given.
/// </summary>
/// <param name="filter"></param>
/// <param name="yearFrom"></param>
/// <param name="yearTo"></param>
/// <returns></returns>
public static TimeSeriesClasses.ComparisonPollutant GetComparisonTimeSeries(PollutantTransferTimeSeriesFilter filter, int yearFrom, int yearTo)
{
TimeSeriesClasses.ComparisonPollutant result = new TimeSeriesClasses.ComparisonPollutant(yearFrom, yearTo);
// Create lambda with pollutant release filter
Expression <Func <POLLUTANTTRANSFER, bool> > lambda = getLambdaExpression(filter);
DataClassesPollutantTransferDataContext db = new DataClassesPollutantTransferDataContext();
// facilities
var dataFrom = db.POLLUTANTTRANSFERs.Where(lambda).Where(p => p.ReportingYear == yearFrom).GroupBy(p => p.ReportingYear)
.Select(p => new { count = p.Count(), quantity = p.Sum(x => x.Quantity) });
var dataTo = db.POLLUTANTTRANSFERs.Where(lambda).Where(p => p.ReportingYear == yearTo).GroupBy(p => p.ReportingYear)
.Select(p => new { count = p.Count(), quantity = p.Sum(x => x.Quantity) });
// reporting in both years
var vTo = db.POLLUTANTTRANSFERs.Where(lambda).Where(p => p.ReportingYear == yearTo).Select(p => p.FacilityID).Distinct();
var dataFromBoth = db.POLLUTANTTRANSFERs.Where(lambda)
.Where(p => p.ReportingYear == yearFrom && vTo.Contains(p.FacilityID)).GroupBy(p => p.ReportingYear)
.Select(p => new { count = p.Count(), quantity = p.Sum(x => x.Quantity) });
var vFrom = db.POLLUTANTTRANSFERs.Where(lambda).Where(p => p.ReportingYear == yearFrom).Select(p => p.FacilityID).Distinct();
var dataToBoth = db.POLLUTANTTRANSFERs.Where(lambda)
.Where(p => p.ReportingYear == yearTo && vFrom.Contains(p.FacilityID)).GroupBy(p => p.ReportingYear)
.Select(p => new { count = p.Count(), quantity = p.Sum(x => x.Quantity) });
var resFrom = dataFrom.SingleOrDefault();
if (resFrom != null)
{
result.FacilitiesFrom = resFrom.count;
result.QuantityFrom = resFrom.quantity;
}
var resTo = dataTo.SingleOrDefault();
if (resTo != null)
{
result.FacilitiesTo = resTo.count;
result.QuantityTo = resTo.quantity;
}
var resBothFrom = dataFromBoth.SingleOrDefault();
if (resBothFrom != null)
{
result.BothFacilities = resBothFrom.count;
result.BothQuantityFrom = resBothFrom.quantity;
}
var resBothTo = dataToBoth.SingleOrDefault();
if (resBothTo != null)
{
result.BothFacilities = resBothTo.count;
result.BothQuantityTo = resBothTo.quantity;
}
return(result);
}
/// <summary>
/// updateTimeSeries
/// </summary>
private void updateCompareChart(PollutantTransferTimeSeriesFilter filter)
{
dataFound(true);
// init year combo boxes
int year1 = this.ucYearCompare.Year1;
int year2 = this.ucYearCompare.Year2;
Color[] colors = new Color[] { Global.ColorWasteWater, Global.ColorWasteWater };
string[] legendTexts = new string[] { Resources.GetGlobal("Common", "FacilitiesBothYears"), Resources.GetGlobal("Common", "AllFacilities") };
ChartHatchStyle[] hatchStyles = new ChartHatchStyle[] { Global.HatchStyleBothYears, Global.HatchStyleTotal };
// same unit for all data
this.ucStackColumnCompare.Initialize(colors.Length, StackColumnType.Comparison, PollutantTransferTrend.CODE_KG, colors, hatchStyles, legendTexts);
// from and to bar
// get compare result compare char
TimeSeriesClasses.ComparisonPollutant result = PollutantTransferTrend.GetComparisonTimeSeries(filter, year1, year2);
bool foundData = (result.QuantityFrom != null || result.QuantityTo != null);
if (foundData)
{
TimeSeriesUtils.BarData dataFrom = new TimeSeriesUtils.BarData
{
Year = result.YearFrom,
Values = new double?[] { TimeSeriesUtils.RangeValue(result.BothQuantityFrom), TimeSeriesUtils.RangeValue(result.QuantityFrom) - TimeSeriesUtils.RangeValue(result.BothQuantityFrom) },
};
TimeSeriesUtils.BarData dataTo = new TimeSeriesUtils.BarData
{
Year = result.YearTo,
Values = new double?[] { TimeSeriesUtils.RangeValue(result.BothQuantityTo), TimeSeriesUtils.RangeValue(result.QuantityTo) - TimeSeriesUtils.RangeValue(result.BothQuantityTo) },
};
// from and to bar
this.ucStackColumnCompare.Add(new List <TimeSeriesUtils.BarData>()
{
dataFrom, dataTo
});
// update sinle table
updateTable(result);
}
else
{
dataFound(false);
}
}
/// <summary>
/// updateTimeSeries
/// </summary>
private void updateCompareChart(PollutantReleasesTimeSeriesFilter filter, MediumFilter.Medium medium)
{
CurrentMedium = medium;
// 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.ComparisonPollutant result = PollutantReleaseTrend.GetComparisonTimeSeries(filter, year1, year2, medium);
bool foundData = (result.QuantityFrom != null || result.QuantityTo != null);
if (foundData)
{
Color[] colors = new Color[] { };
// create compare chart and table
if (medium.Equals(MediumFilter.Medium.Air))
{
colors = new Color[] { Global.ColorAirTotal, Global.ColorAirTotal };
}
else if (medium.Equals(MediumFilter.Medium.Water))
{
// get report data
colors = new Color[] { Global.ColorWaterTotal, Global.ColorWaterTotal };
}
else if (medium.Equals(MediumFilter.Medium.Soil))
{
colors = new Color[] { Global.ColorSoilTotal, Global.ColorSoilTotal };
}
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, PollutantReleaseTrend.CODE_KG, colors, hatchStyles, legendTexts);
TimeSeriesUtils.BarData dataFrom = new TimeSeriesUtils.BarData
{
Year = result.YearFrom,
Values = new double?[] { TimeSeriesUtils.RangeValue(result.BothQuantityFrom), TimeSeriesUtils.RangeValue(result.QuantityFrom) - TimeSeriesUtils.RangeValue(result.BothQuantityFrom) },
};
TimeSeriesUtils.BarData dataTo = new TimeSeriesUtils.BarData
{
Year = result.YearTo,
Values = new double?[] { TimeSeriesUtils.RangeValue(result.BothQuantityTo), TimeSeriesUtils.RangeValue(result.QuantityTo) - TimeSeriesUtils.RangeValue(result.BothQuantityTo) },
};
// from and to bar
this.ucStackColumnCompare.Add(new List <TimeSeriesUtils.BarData>()
{
dataFrom, dataTo
});
// update sinle table
updateTable(result);
}
else
{
dataFound(false);
}
}
// ---------------------------------------------------------------------------------------------------
// Comparison
// ---------------------------------------------------------------------------------------------------
#region comparison
/// <summary>
/// GetComparisonTimeSeries
/// </summary>
public static TimeSeriesClasses.ComparisonPollutant GetComparisonTimeSeries(PollutantReleasesTimeSeriesFilter filter, int yearFrom, int yearTo, MediumFilter.Medium medium)
{
// Create lambda with pollutant release filter
DataClassesPollutantReleaseDataContext db = getDataContext();
ParameterExpression param = Expression.Parameter(typeof(POLLUTANTRELEASE), "s");
Expression exp = LinqExpressionBuilder.GetLinqExpressionPollutantReleases(filter, param);
// apply medium
Expression expMedium = LinqExpressionBuilder.GetLinqExpressionMediumRelease(medium, param);
if (exp != null && expMedium != null)
{
exp = Expression.And(exp, expMedium);
}
Expression <Func <POLLUTANTRELEASE, bool> > lambda = Expression.Lambda <Func <POLLUTANTRELEASE, bool> >(exp, param);
// group by reporting year, get from and to data
IQueryable <IGrouping <int, POLLUTANTRELEASE> > groupFrom = db.POLLUTANTRELEASEs.Where(lambda).Where(p => p.ReportingYear == yearFrom).GroupBy(p => p.ReportingYear);
IQueryable <IGrouping <int, POLLUTANTRELEASE> > groupTo = db.POLLUTANTRELEASEs.Where(lambda).Where(p => p.ReportingYear == yearTo).GroupBy(p => p.ReportingYear);
// Facility IDs when year is 'yearTo'
var vTo = db.POLLUTANTRELEASEs.Where(lambda).Where(p => p.ReportingYear == yearTo).Select(p => p.FacilityID).Distinct();
IQueryable <IGrouping <int, POLLUTANTRELEASE> > groupDataFromBoth = db.POLLUTANTRELEASEs.Where(lambda).Where(p => p.ReportingYear == yearFrom && vTo.Contains(p.FacilityID)).GroupBy(p => p.ReportingYear);
// Facility IDs when year is 'yearFrom'
var vFrom = db.POLLUTANTRELEASEs.Where(lambda).Where(p => p.ReportingYear == yearFrom).Select(p => p.FacilityID).Distinct();
IQueryable <IGrouping <int, POLLUTANTRELEASE> > groupDataToBoth = db.POLLUTANTRELEASEs.Where(lambda).Where(p => p.ReportingYear == yearTo && vFrom.Contains(p.FacilityID)).GroupBy(p => p.ReportingYear);
// result lists
IEnumerable <TimeSeriesClasses.TsPollutantCompare> dataFrom = null, dataTo = null;
IEnumerable <TimeSeriesClasses.TsPollutantCompare> dataFromBoth = null, dataToBoth = null;
switch (medium)
{
case MediumFilter.Medium.Air:
dataFrom = groupFrom.Select(x => new TimeSeriesClasses.TsPollutantCompare(x.Count(), x.Sum(p => p.QuantityAir), x.Sum(p => p.QuantityAccidentalAir)));
dataTo = groupTo.Select(x => new TimeSeriesClasses.TsPollutantCompare(x.Count(), x.Sum(p => p.QuantityAir), x.Sum(p => p.QuantityAccidentalAir)));
dataFromBoth = groupDataFromBoth.Select(x => new TimeSeriesClasses.TsPollutantCompare(x.Count(), x.Sum(p => p.QuantityAir), x.Sum(p => p.QuantityAccidentalAir)));
dataToBoth = groupDataToBoth.Select(x => new TimeSeriesClasses.TsPollutantCompare(x.Count(), x.Sum(p => p.QuantityAir), x.Sum(p => p.QuantityAccidentalAir)));
break;
case MediumFilter.Medium.Water:
dataFrom = groupFrom.Select(x => new TimeSeriesClasses.TsPollutantCompare(x.Count(), x.Sum(p => p.QuantityWater), x.Sum(p => p.QuantityAccidentalWater)));
dataTo = groupTo.Select(x => new TimeSeriesClasses.TsPollutantCompare(x.Count(), x.Sum(p => p.QuantityWater), x.Sum(p => p.QuantityAccidentalWater)));
dataFromBoth = groupDataFromBoth.Select(x => new TimeSeriesClasses.TsPollutantCompare(x.Count(), x.Sum(p => p.QuantityWater), x.Sum(p => p.QuantityAccidentalWater)));
dataToBoth = groupDataToBoth.Select(x => new TimeSeriesClasses.TsPollutantCompare(x.Count(), x.Sum(p => p.QuantityWater), x.Sum(p => p.QuantityAccidentalWater)));
break;
case MediumFilter.Medium.Soil:
dataFrom = groupFrom.Select(x => new TimeSeriesClasses.TsPollutantCompare(x.Count(), x.Sum(p => p.QuantitySoil), x.Sum(p => p.QuantityAccidentalSoil)));
dataTo = groupTo.Select(x => new TimeSeriesClasses.TsPollutantCompare(x.Count(), x.Sum(p => p.QuantitySoil), x.Sum(p => p.QuantityAccidentalSoil)));
dataFromBoth = groupDataFromBoth.Select(x => new TimeSeriesClasses.TsPollutantCompare(x.Count(), x.Sum(p => p.QuantitySoil), x.Sum(p => p.QuantityAccidentalSoil)));
dataToBoth = groupDataToBoth.Select(x => new TimeSeriesClasses.TsPollutantCompare(x.Count(), x.Sum(p => p.QuantitySoil), x.Sum(p => p.QuantityAccidentalSoil)));
break;
default: return(null);
}
TimeSeriesClasses.ComparisonPollutant result = new TimeSeriesClasses.ComparisonPollutant(yearFrom, yearTo);
var res = dataFrom.SingleOrDefault();
if (res != null)
{
result.SetFrom(res.Count, res.Quantity, res.Accidental);
}
res = dataTo.SingleOrDefault();
if (res != null)
{
result.SetTo(res.Count, res.Quantity, res.Accidental);
}
res = dataFromBoth.SingleOrDefault();
if (res != null)
{
result.SetBothFrom(res.Count, res.Quantity, res.Accidental);
}
res = dataToBoth.SingleOrDefault();
if (res != null)
{
result.SetBothTo(res.Count, res.Quantity, res.Accidental);
}
return(result);
}
