// --------------------------------------------------------------------------------------------------------------------
// PollutantReleasesTimeSeries Filter
// --------------------------------------------------------------------------------------------------------------------
#region PollutantReleasesTimeSeriesFilter
public static string SerializeToUrl(PollutantReleasesTimeSeriesFilter filter)
{
string result = String.Empty;
if (filter != null)
{
// Area
result += SerializeToUrl(filter.AreaFilter);
// Year
result += SerializeToUrl(filter.PeriodFilter);
// Pollutant
result += SerializeToUrl(filter.PollutantFilter);
// Medium
result += SerializeToUrl(filter.MediumFilter);
// Activity
result += SerializeToUrl(filter.ActivityFilter);
}
result = result.Remove(result.Length - 1);
return(result);
}
private static PollutantReleasesTimeSeriesFilter createConfidentialFilter(PollutantReleasesTimeSeriesFilter filter)
{
PollutantReleasesTimeSeriesFilter filterConf = filter.Clone() as PollutantReleasesTimeSeriesFilter;
filterConf.PollutantFilter.PollutantID = filter.PollutantFilter.PollutantGroupID;
return(filterConf);
}
/// <summary>
/// Populate charts. Selected year in compare dropdown will be searchyear
/// </summary>
public void Populate(PollutantReleasesTimeSeriesFilter filter, int?searchYear)
{
SearchFilter = filter;
SearchYear = searchYear;
initializeContentLinks();
//Only determine once and store in viewstate
ConfidentialityAffected = PollutantReleaseTrend.IsAffectedByConfidentiality(filter);
// show timeseries as default
showContent(Sheets.TimeSeries.TimeSeries.ToString());
}
/// <summary>
/// return true if confidentiality might effect result
/// </summary>
public static bool IsAffectedByConfidentiality(PollutantReleasesTimeSeriesFilter filter, MediumFilter.Medium medium)
{
//create new filter with confidential within group instead of pollutant itself
PollutantReleasesTimeSeriesFilter filterConf = createConfidentialFilter(filter);
Expression <Func <POLLUTANTRELEASE, bool> > lambda = getLambdaExpression(filterConf, medium);
DataClassesPollutantReleaseDataContext db = getDataContext();
return(db.POLLUTANTRELEASEs.Any(lambda));
}
/// <summary>
/// Search
/// </summary>
protected void btnSearch_Click(object sender, EventArgs e)
{
if (InvokeSearch != null)
{
PollutantReleasesTimeSeriesFilter filter = PopulateFilter();
// start the search
InvokeSearch.Invoke(filter, e);
}
}
/// <summary>
/// load completed, perserve scroll
/// </summary>
protected override void OnLoadComplete(EventArgs e)
{
base.OnLoadComplete(e);
if (!IsPostBack)
{
//if filter is in request, search will be invoked from the start
if (LinkSearchBuilder.HasPollutantReleasesTimeSeriesFilter(Request))
{
PollutantReleasesTimeSeriesFilter filter = this.ucSearchOptions.PopulateFilter();
doSearch(filter, EventArgs.Empty);
}
}
}
/// <summary>
/// query data to be displayed in the facility resul listview
/// </summary>
private void doSearch(object sender, EventArgs e)
{
((MasterSearchPage)this.Master).UpdateMode(true);
((MasterSearchPage)this.Master).ShowResultArea();
PollutantReleasesTimeSeriesFilter filter = sender as PollutantReleasesTimeSeriesFilter;
if (filter != null)
{
this.ucTsPollutantReleasesSheet.Populate(filter);
updateJavaScriptMap(filter);
}
}
/// <summary>
/// returns a dictionary with sheet headers <key, value> for pollutant releases time series search
/// </summary>
public static Dictionary <string, string> GetTsPollutantReleasesSearchHeader(
PollutantReleasesTimeSeriesFilter filter,
MediumFilter.Medium currentMedium,
bool confidentialityAffected)
{
Dictionary <string, string> header = makeHeader();
addArea(header, filter.AreaFilter);
addActivity(header, filter.ActivityFilter);
addPollutant(header, filter.PollutantFilter);
addMedium(header, currentMedium);
addConfidentiality(header, confidentialityAffected);
return(header);
}
// ---------------------------------------------------------------------------------------------------
// Map filter
// ---------------------------------------------------------------------------------------------------
#region Map
/// <summary>
/// returns the MapFilter (sql and layers) corresponding to the filter.
/// </summary>
public static MapFilter GetMapFilter(PollutantReleasesTimeSeriesFilter filter)
{
//parameter must be "p" to match map config file
ParameterExpression param = Expression.Parameter(typeof(POLLUTANTRELEASE), "p");
Expression exp = LinqExpressionBuilder.GetLinqExpressionPollutantReleases(filter, param);
Expression <Func <POLLUTANTRELEASE, bool> > lambda = Expression.Lambda <Func <POLLUTANTRELEASE, bool> >(exp, param);
// create sql and sectors to map. Do not remove parameter prefix.
MapFilter mapFilter = new MapFilter();
mapFilter.SqlWhere = LinqExpressionBuilder.GetSQL(lambda.Body, null);
mapFilter.SetLayers(filter.ActivityFilter);
return(mapFilter);
}
private void showContent(PollutantReleasesTimeSeriesFilter filter, MediumFilter.Medium medium)
{
CurrentMedium = medium;
//examine if there exists any confidential data for the medium given
bool hasConfidentialInformationMedium = PollutantReleaseTrend.IsAffectedByConfidentiality(filter, medium);
this.divConfidentialityInformation.Visible = hasConfidentialInformationMedium;
this.divNoConfidentialityInformation.Visible = !hasConfidentialInformationMedium;
if (hasConfidentialInformationMedium)
{
this.lvConfidentiality.DataSource = PollutantReleaseTrend.GetConfidentialTimeSeries(filter, medium);
this.lvConfidentiality.DataBind();
}
}
public void Populate(PollutantReleasesTimeSeriesFilter filter, MediumFilter.Medium medium)
{
SearchFilter = filter;
var counts = PollutantReleaseTrend.GetFacilityCounts(filter);
this.ucMediumSelector.PopulateMediumRadioButtonList(filter.MediumFilter, medium, counts);
// check that any relases are selected
if (!filter.MediumFilter.ReleasesToAir &&
!filter.MediumFilter.ReleasesToSoil &&
!filter.MediumFilter.ReleasesToWater)
{
dataFound(false);
return;
}
}
public PollutantReleasesTimeSeriesFilter PopulateFilter()
{
PollutantReleasesTimeSeriesFilter filter = new PollutantReleasesTimeSeriesFilter();
filter.PeriodFilter = new PeriodFilter();
filter.PeriodFilter.StartYear = 2007; //EPER years are not included.
filter.AreaFilter = this.ucAreaSearchOption.PopulateFilter();
filter.PollutantFilter = this.ucPollutantSearchOption.PopulateFilter();
filter.MediumFilter = this.ucMediumSearchOption.PopulateFilter();
filter.ActivityFilter = this.ucAdvancedActivitySearchOption.PopulateFilter();
// store settings in cookies
CookieStorage.SetFilter(Response, filter.AreaFilter);
return(filter);
}
private void toggleTimeseries(ListViewCommandEventArgs e, int rowindex)
{
ucTsPollutantReleasesSheet control = (ucTsPollutantReleasesSheet)this.lvPollutantReleasesArea.Items[rowindex].FindControl("ucTsPollutantReleasesSheet");
closeAllSubSheets(); // only allow 1 sheet open
control.Visible = !control.Visible;
Control div = this.lvPollutantReleasesArea.Items[rowindex].FindControl("subsheet");
div.Visible = !div.Visible;
if (control.Visible)
{
// create search filter and change area filter
PollutantReleasesTimeSeriesFilter filter = FilterConverter.ConvertToPollutantReleasesTimeSeriesFilter(SearchFilter);
filter.AreaFilter = getAreaFilter(e);
control.Populate(filter, SearchFilter.YearFilter.Year);
}
}
// ---------------------------------------------------------------------------------------------------
// Facility couting
// ---------------------------------------------------------------------------------------------------
#region Facility counting
/// <summary>
/// Returns the number of facilities for each medium type.
/// </summary>
public static PollutantReleases.FacilityCountObject GetFacilityCounts(PollutantReleasesTimeSeriesFilter tsFilter)
{
// removes all year span information
var filter = FilterConverter.ConvertToPollutantReleaseSearchFilter(tsFilter);
ParameterExpression param = Expression.Parameter(typeof(POLLUTANTRELEASE), "POLLUTANTRELEASE");
Expression exp = LinqExpressionBuilder.GetLinqExpressionPollutantReleases(filter, param);
// Exclude EPER reporting years
Expression prop = Expression.Property(param, "ReportingYear");
Expression val = Expression.Constant(2007);
Expression yearExp = Expression.GreaterThanOrEqual(prop, val);
exp = Expression.AndAlso(yearExp, exp);
Expression <Func <POLLUTANTRELEASE, bool> > lambda = Expression.Lambda <Func <POLLUTANTRELEASE, bool> >(exp, param);
return(PollutantReleases.GetFacilityCounts(lambda, filter.MediumFilter));
}
/// <summary>
/// Get confidential data for timeseries on aggregated level. If no confidentiality claims is found the list will be empty.
/// </summary>
public static List <TimeSeriesClasses.ConfidentialityPollutant> GetConfidentialTimeSeries(PollutantReleasesTimeSeriesFilter filter, MediumFilter.Medium medium)
{
//Find data for confidential in the group of the pollutant
PollutantReleasesTimeSeriesFilter filterConf = filter.Clone() as PollutantReleasesTimeSeriesFilter;
filterConf.PollutantFilter.PollutantID = filter.PollutantFilter.PollutantGroupID;
List <TimeSeriesClasses.PollutantReleases> confidentialData = GetTimeSeries(filterConf, medium);
if (confidentialData.Count() > 0)
{
//Find data for pollutant
List <TimeSeriesClasses.PollutantReleases> pollutantData = GetTimeSeries(filter, medium);
//merge the two lists and return.
return(mergeList(pollutantData, confidentialData));
}
return(new List <TimeSeriesClasses.ConfidentialityPollutant>());
}
//public static string CODE_TNE = EnumUtil.GetStringValue(QuantityUnit.Tonnes);
// ---------------------------------------------------------------------------------------------------
// Time series
// ---------------------------------------------------------------------------------------------------
#region timeseries
/// <summary>
/// Get timeseries on aggregated level
/// </summary>
public static List <TimeSeriesClasses.PollutantReleases> GetTimeSeries(PollutantReleasesTimeSeriesFilter filter, MediumFilter.Medium medium)
{
// apply filter
Expression <Func <POLLUTANTRELEASE, bool> > lambda = getLambdaExpression(filter, medium);
DataClassesPollutantReleaseDataContext db = getDataContext();
// get data and group by year (which get assigned to x.Key by link)
IQueryable <IGrouping <int, POLLUTANTRELEASE> > group = db.POLLUTANTRELEASEs.Where(lambda).GroupBy(p => p.ReportingYear).OrderBy(p => p.Key);
// lookup medium
IEnumerable <TimeSeriesClasses.PollutantReleases> data = null;
switch (medium)
{
case MediumFilter.Medium.Air:
data = group.Select(x => new TimeSeriesClasses.PollutantReleases(x.Key, x.Count(), x.Sum(p => p.QuantityAir), x.Sum(p => p.QuantityAccidentalAir)));
break;
case MediumFilter.Medium.Soil:
data = group.Select(x => new TimeSeriesClasses.PollutantReleases(x.Key, x.Count(), x.Sum(p => p.QuantitySoil), x.Sum(p => p.QuantityAccidentalSoil)));
break;
case MediumFilter.Medium.Water:
data = group.Select(x => new TimeSeriesClasses.PollutantReleases(x.Key, x.Count(), x.Sum(p => p.QuantityWater), x.Sum(p => p.QuantityAccidentalWater)));
break;
default:
throw new ArgumentOutOfRangeException("medium", String.Format("Illegal medium: {0}", medium.ToString()));
}
IEnumerable <Facility.ReportingCountries> years = Facility.GetReportingCountries(filter.AreaFilter).ToList();
IEnumerable <TimeSeriesClasses.PollutantReleases> res = from l in data.ToList()
join r in years on l.Year equals r.Year
select new TimeSeriesClasses.PollutantReleases(l.Year, l.Facilities, l.Quantity, l.QuantityAccidental, r.Countries);
return(res.OrderBy(p => p.Year).ToList());
}
public void Populate(PollutantReleasesTimeSeriesFilter filter, bool hasConfidentialInformation, MediumFilter.Medium medium)
{
SearchFilter = filter;
LOV_POLLUTANT pollutant = ListOfValues.GetPollutant(filter.PollutantFilter.PollutantID);
PollutantCode = pollutant != null ? pollutant.Code : null;
//set parentcode
ParentCode = null;
if (pollutant != null && pollutant.ParentID != null)
{
LOV_POLLUTANT pollutantGroup = ListOfValues.GetPollutant(pollutant.ParentID.Value);
ParentCode = pollutantGroup != null ? pollutantGroup.Code : null;
}
this.ucMediumSelector.Visible = hasConfidentialInformation;
if (hasConfidentialInformation)
{
var count = PollutantReleaseTrend.GetFacilityCounts(filter);
this.ucMediumSelector.PopulateMediumRadioButtonList(filter.MediumFilter, medium, count);
}
}
/// <summary>
/// returns a dictionary with sheet headers for time series pollutant release search
/// </summary>
public static Dictionary <string, string> GetTimeSeriesPollutantReleaseHeader(PollutantReleasesTimeSeriesFilter filter)
{
Dictionary <string, string> header = new Dictionary <string, string>();
addArea(header, filter.AreaFilter);
addActivity(header, filter.ActivityFilter);
addPollutant(header, filter.PollutantFilter);
addMedium(header, filter.MediumFilter);
return(header);
}
// ---------------------------------------------------------------------------------------------------
// 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);
}
/// <summary>
/// update flash map
/// </summary>
/* private void updateFlashMap(PollutantReleasesTimeSeriesFilter filter)
* {
* MapFilter mapfilter = QueryLayer.PollutantReleaseTrend.GetMapFilter(filter);
* string header = MapPrintDetails.Build(SheetHeaderBuilder.GetTimeSeriesPollutantReleaseHeader(filter));
* MapUtils.UpdateSmallMap(MasterSearchPage.MAPID, this, this.ClientID, mapfilter, header, Request.ApplicationPath);
* ((MasterSearchPage)this.Master).UpdateExpandedScript(mapfilter, header);
* }*/
private void updateJavaScriptMap(PollutantReleasesTimeSeriesFilter filter)
{
MapFilter mapfilter = QueryLayer.PollutantReleaseTrend.GetMapJavascriptFilter(filter);
MapJavaScriptUtils.UpdateJavaScriptMap(mapfilter, Page);
}
private static Expression <Func <POLLUTANTRELEASE, bool> > getLambdaExpression(PollutantReleasesTimeSeriesFilter filter)
{
ParameterExpression param = Expression.Parameter(typeof(POLLUTANTRELEASE), "p");
Expression exp = LinqExpressionBuilder.GetLinqExpressionPollutantReleases(filter, param);
Expression <Func <POLLUTANTRELEASE, bool> > lambda = Expression.Lambda <Func <POLLUTANTRELEASE, bool> >(exp, param);
return(lambda);
}
/// <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);
}
}
private static Expression <Func <POLLUTANTRELEASE, bool> > getLambdaExpression(PollutantReleasesTimeSeriesFilter filter, MediumFilter.Medium medium)
{
// apply filter
ParameterExpression param = Expression.Parameter(typeof(POLLUTANTRELEASE), "p");
Expression exp = LinqExpressionBuilder.GetLinqExpressionPollutantReleases(filter, param);
//apply medium condition
Expression expMedium = LinqExpressionBuilder.GetLinqExpressionMediumRelease(medium, param);
exp = LinqExpressionBuilder.CombineAnd(exp, expMedium);
Expression <Func <POLLUTANTRELEASE, bool> > lambda = Expression.Lambda <Func <POLLUTANTRELEASE, bool> >(exp, param);
return(lambda);
}
/// <summary>
/// updateTimeSeries
/// </summary>
private void updateTimeSeries(PollutantReleasesTimeSeriesFilter filter, MediumFilter.Medium medium)
{
CurrentMedium = medium;
// assume data is found
dataFound(true);
// result from qyerylayer
List <TimeSeriesClasses.PollutantReleases> data = PollutantReleaseTrend.GetTimeSeries(filter, medium);;
if (data == null || data.Count == 0)
{
dataFound(false); return;
}
// set report data to table
this.lvTimeSeriesTable.DataSource = data;
this.lvTimeSeriesTable.DataBind();
Color[] colors = new Color[] {};
string[] legendTexts = new string[] { Resources.GetGlobal("Common", "Accidental"), Resources.GetGlobal("Common", "Controlled") };
// init chart. Must be done after table databinding, because missing years are added.
if (medium.Equals(MediumFilter.Medium.Air))
{
colors = new Color[] { Global.ColorAirAccidental, Global.ColorAirTotal };
}
else if (medium.Equals(MediumFilter.Medium.Water))
{
colors = new Color[] { Global.ColorWaterAccidental, Global.ColorWaterTotal };
}
else if (medium.Equals(MediumFilter.Medium.Soil))
{
colors = new Color[] { Global.ColorSoilAccidental, Global.ColorSoilTotal };
}
ChartHatchStyle[] hatchStyles = new ChartHatchStyle[] { ChartHatchStyle.None, ChartHatchStyle.None };
this.ucStackColumnTime.Initialize(colors.Length, StackColumnType.TimeSeries, PollutantReleaseTrend.CODE_KG, colors, hatchStyles, legendTexts);
//this.ucStackColumnTime.Initialize(colors.Length, StackColumnType.TimeSeries, PollutantReleaseTrend.CODE_TNE, colors, legendTexts);
List <TimeSeriesUtils.BarData> bars = new List <TimeSeriesUtils.BarData>();
foreach (var v in data)
{
string[] tip = new string[] { String.Format("{0}: {1}", Resources.GetGlobal("Common", "Year"), v.Year),
String.Format("{0}: {1}", Resources.GetGlobal("Common", "Facilities"), v.Facilities),
String.Format("{0}: {1}", Resources.GetGlobal("Pollutant", "ReleasesTotal"), QuantityFormat.Format(v.Quantity, v.QuantityUnit)),
String.Format("{0}: {1}", Resources.GetGlobal("Pollutant", "ReleasesAccidentalReleases"), QuantityFormat.Format(v.QuantityAccidental, v.QuantityAccidentalUnit)),
(v.AccidentalPercent > 0.0) ? String.Format("{0}: {1:F5}%", Resources.GetGlobal("Pollutant", "ReleasesAccidentalPercentValue"), v.AccidentalPercent) : String.Format("{0}: 0%", Resources.GetGlobal("Pollutant", "ReleasesAccidentalPercentValue")) };
TimeSeriesUtils.BarData cd = new TimeSeriesUtils.BarData
{
Year = v.Year,
Values = new double?[] { TimeSeriesUtils.RangeValue(v.QuantityAccidental), TimeSeriesUtils.RangeValue(v.Quantity) - TimeSeriesUtils.RangeValue(v.QuantityAccidental) },
ToolTip = ToolTipFormatter.FormatLines(tip)
};
bars.Add(cd);
}
this.ucStackColumnTime.Add(TimeSeriesUtils.InsertMissingYearsTimeSeries(bars, false));
}
/// <summary>
/// populate. Selected year in compare dropdown will be the last report year
/// </summary>
public void Populate(PollutantReleasesTimeSeriesFilter filter)
{
Populate(filter, null);
}
