/// <summary> /// update header /// </summary> /// <param name="filter"></param> private void updateHeader(PollutantTransfersSearchFilter filter, bool includeFacilityCount, string text) { Dictionary <string, string> header = SheetHeaderBuilder.GetPollutantTransferSearchHeader(filter, includeFacilityCount); this.ucSheetSubHeader.PopulateHeader(header); this.ucSheetSubHeader.Text = text; }
/// <summary> /// Search, fill data into summery /// </summary> public void Populate(PollutantTransfersSearchFilter filter) { SearchFilter = filter; ConfidentialityAffected = PollutantTransfers.IsAffectedByConfidentiality(filter); //Only determine once and store in viewstate // always show summery showContent(Sheets.PollutantTransfers.Summary.ToString()); }
/// <summary> /// return total list confidential reasons /// </summary> public static IEnumerable <TransfersConfidentialRow> GetConfidentialReason(PollutantTransfersSearchFilter filter) { DataClassesPollutantTransferDataContext db = getPollutantTransferDataContext(); // apply filter for confidential, do not include the pollutant itself ParameterExpression param = Expression.Parameter(typeof(POLLUTANTTRANSFER), "s"); Expression exp = LinqExpressionBuilder.GetLinqExpressionPollutantTransfersConfidential(filter, param, false); Expression <Func <POLLUTANTTRANSFER, bool> > lambda = Expression.Lambda <Func <POLLUTANTTRANSFER, bool> >(exp, param); var reason0 = db.POLLUTANTTRANSFERs.Where(lambda); var reason1 = from p in reason0 group p by new { p.ConfidentialCode }; var reason2 = from p in reason1 select new { code = p.Select(x => x.ConfidentialCode).First(), count = p.Count() }; // build result List <TransfersConfidentialRow> result = new List <TransfersConfidentialRow>(); foreach (var v in reason2) { result.Add(new TransfersConfidentialRow(v.code, v.count)); } return(result.OrderBy(x => x.Code)); }
/// <summary> /// GetAreaComparison /// </summary> public static List <AreaComparison> GetAreaComparison(PollutantTransfersSearchFilter filter) { DataClassesPollutantTransferDataContext db = getPollutantTransferDataContext(); // apply filter ParameterExpression param = Expression.Parameter(typeof(POLLUTANTTRANSFER), "s"); Expression exp = LinqExpressionBuilder.GetLinqExpressionPollutantTransfers(filter, param); Expression <Func <POLLUTANTTRANSFER, bool> > lambda = Expression.Lambda <Func <POLLUTANTTRANSFER, bool> >(exp, param); AreaFilter areaFilter = filter.AreaFilter; IEnumerable <AreaComparison> data = db.POLLUTANTTRANSFERs.Where(lambda) .GroupBy(areaFilter) .Select(x => new AreaComparison( x.Key.Code, x.Sum(p => p.Quantity), x.Count())); //Make sure sql is executed now and ordered by size List <AreaComparison> result = data.OrderBy(p => p.Quantity).ToList(); //Calculate percentages double tot = result.Sum(p => p.Quantity); if (tot > 0) { foreach (AreaComparison ac in result) { ac.Percent = (ac.Quantity / tot) * 100.0; } } return(result); }
/// <summary> /// Return all subactivities (level 2) that fullfill search criteria. /// If activityCodes are null, all activities will be returned. If activityCodes is empty no activities will be returned. /// Notice that this will include one subactivity "Not specified on this level" for each activity, even if the activity do not have any subactivities at all! /// </summary> public static IEnumerable <ActivityTreeListRow> GetSubActivities(PollutantTransfersSearchFilter filter, List <string> activityCodes) { if (activityCodes != null && activityCodes.Count() == 0) { return(new List <ActivityTreeListRow>()); } DataClassesPollutantTransferDataContext db = getPollutantTransferDataContext(); Expression <Func <POLLUTANTTRANSFER, bool> > lambda = getActivityAreaLambda(filter); //add activities to expression if (activityCodes != null) { ParameterExpression param = lambda.Parameters[0]; Expression activityExp = LinqExpressionBuilder.GetInExpr(param, "IAActivityCode", activityCodes); Expression exp = LinqExpressionBuilder.CombineAnd(lambda.Body, activityExp); lambda = Expression.Lambda <Func <POLLUTANTTRANSFER, bool> >(exp, param); } //find data for sub-activity level, this level never has children. IEnumerable <ActivityTreeListRow> subactivities = db.POLLUTANTTRANSFERs.Where(lambda) .GroupBy(p => new { SectorCode = p.IASectorCode, ActivityCode = p.IAActivityCode, SubActivityCode = p.IASubActivityCode, PollutantCode = p.PollutantCode }) .Select(x => new ActivityTreeListRow( x.Key.SectorCode, x.Key.ActivityCode, !x.Key.SubActivityCode.Equals(null) ? x.Key.SubActivityCode : ActivityTreeListRow.CODE_UNSPECIFIED, x.Key.PollutantCode, x.Count(), x.Sum(p => p.Quantity), false)); return(subactivities); }
/// <summary> /// return all activities (level 1) that fullfill search criteria within the sectorCodes given. /// If sectorCodes are null, all activities will be returned. If sectorCodes is empty no activities will be returned. /// </summary> public static IEnumerable <ActivityTreeListRow> GetActivities(PollutantTransfersSearchFilter filter, List <string> sectorCodes) { if (sectorCodes != null && sectorCodes.Count() == 0) { return(new List <ActivityTreeListRow>()); } DataClassesPollutantTransferDataContext db = getPollutantTransferDataContext(); Expression <Func <POLLUTANTTRANSFER, bool> > lambda = getActivityAreaLambda(filter); if (sectorCodes != null) { ParameterExpression param = lambda.Parameters[0]; Expression sectorExp = LinqExpressionBuilder.GetInExpr(param, "IASectorCode", sectorCodes); Expression exp = LinqExpressionBuilder.CombineAnd(lambda.Body, sectorExp); lambda = Expression.Lambda <Func <POLLUTANTTRANSFER, bool> >(exp, param); } //find data for activity level IEnumerable <ActivityTreeListRow> activities = db.POLLUTANTTRANSFERs.Where(lambda) .GroupBy(p => new { SectorCode = p.IASectorCode, ActivityCode = p.IAActivityCode, PollutantCode = p.PollutantCode }) .Select(x => new ActivityTreeListRow( x.Key.SectorCode, x.Key.ActivityCode, null, x.Key.PollutantCode, x.Count(), x.Sum(p => p.Quantity), x.First(p => !p.IASubActivityCode.Equals(null)) != null)); return(activities); }
/// <summary> /// return all countries that fullfill search criteria /// </summary> public static IEnumerable <AreaTreeListRow> GetCountries(PollutantTransfersSearchFilter filter) { DataClassesPollutantTransferDataContext db = getPollutantTransferDataContext(); Expression <Func <POLLUTANTTRANSFER, bool> > lambda = getActivityAreaLambda(filter); //find data for country level. Country level always has children. IEnumerable <AreaTreeListRow> countries = db.POLLUTANTTRANSFERs.Where(lambda) .GroupBy(p => new { CountryCode = p.CountryCode, PollutantCode = p.PollutantCode }) .Select(x => new AreaTreeListRow( x.Key.CountryCode, null, filter.AreaFilter.TypeRegion, x.Key.PollutantCode, x.Count(), x.Sum(p => p.Quantity), true)); List <AreaTreeListRow> result = countries.ToList(); //make sure sql is executed now to do it only once List <AreaTreeListRow> totals = result.GroupBy(p => new { PollutantCode = p.PollutantCode }) .Select(x => new AreaTreeListRow( AreaTreeListRow.CODE_TOTAL, null, filter.AreaFilter.TypeRegion, x.Key.PollutantCode, x.Sum(p => p.Facilities), x.Sum(p => p.Quantity), false)).ToList(); //only add total to result if more than one sector. if (result.Select(r => r.CountryCode).Distinct().Count() > 1) { result.AddRange(totals); } //find facility count int facilityCount = 0; if (result.Count == 1) { facilityCount = result.Single().Facilities; } else if (totals.Count == 1) { facilityCount = totals.Single().Facilities; } else { facilityCount = GetFacilityCount(filter); } filter.Count = facilityCount; return(result); }
public static Dictionary <string, string> GetPollutantTransferSearchHeader( PollutantTransfersSearchFilter filter, bool confidentialityAffected) { var header = GetPollutantTransferSearchHeader(filter); addConfidentiality(header, confidentialityAffected); return(header); }
/// <summary> /// get lambda for confidential pollutant transfers /// </summary> private static Expression <Func <POLLUTANTTRANSFER, bool> > getPollutantTransfersConfidentialLambda(DataClassesPollutantTransferDataContext db, IndustrialActivitySearchFilter filter, bool includePollutant) { ParameterExpression param = Expression.Parameter(typeof(POLLUTANTTRANSFER), "s"); PollutantTransfersSearchFilter filterTransfers = FilterConverter.ConvertToPollutantTransfersSearchFilter(filter); Expression exp = LinqExpressionBuilder.GetLinqExpressionPollutantTransfersConfidential(filterTransfers, param, includePollutant); Expression <Func <POLLUTANTTRANSFER, bool> > lambda = Expression.Lambda <Func <POLLUTANTTRANSFER, bool> >(exp, param); return(lambda); }
/// <summary> /// returns a dictionary with csv headers <key, value> for pollutant transfer search /// </summary> public static Dictionary <string, string> GetPollutantTransferSearchHeader(PollutantTransfersSearchFilter filter) { Dictionary <string, string> header = makeHeader(); addPollutant(header, filter.PollutantFilter); addYear(header, filter.YearFilter); addArea(header, filter.AreaFilter); return(header); }
/// <summary> /// Search /// </summary> protected void btnSearch_Click(object sender, EventArgs e) { if (InvokeSearch != null) { PollutantTransfersSearchFilter filter = PopulateFilter(); // start the search InvokeSearch.Invoke(filter, e); } }
/// <summary> /// Find all reported pollutant codes fullfilling the filter /// </summary> public static List <string> GetPollutantCodes(PollutantTransfersSearchFilter filter) { DataClassesPollutantTransferDataContext db = getPollutantTransferDataContext(); Expression <Func <POLLUTANTTRANSFER, bool> > lambda = getActivityAreaLambda(filter); //distinct pollutants List <string> codes = db.POLLUTANTTRANSFERs.Where(lambda) .Select(r => r.PollutantCode).Distinct().ToList(); return(codes); }
/// <summary> /// Fill table according to filter /// </summary> public void Populate(PollutantTransfersSearchFilter filter) { SearchFilter = filter; List <PollutantTransfers.AreaTreeListRow> data = QueryLayer.PollutantTransfers.GetCountries(filter).ToList(); sortResult(data); ViewState[RESULT] = data; this.lvPollutantTransfersAreas.DataSource = data; this.lvPollutantTransfersAreas.DataBind(); }
/// <summary> /// invoke pollutant search search for this row /// </summary> protected void onPollutantSearchClick(object sender, CommandEventArgs e) { // create pollutant search filter PollutantTransfersSearchFilter filter = FilterConverter.ConvertToPollutantTransfersSearchFilter(SearchFilter); // create pollutant filter filter.PollutantFilter = getPollutantFilter(e); // go to pollutant release LinkSearchRedirecter.ToPollutantTransfers(Response, filter); }
/// <summary> /// return true if confidentiality might effect result /// </summary> public static bool IsAffectedByConfidentiality(PollutantTransfersSearchFilter filter) { DataClassesPollutantTransferDataContext db = getPollutantTransferDataContext(); // apply filter for confidential, do not include the pollutant itself ParameterExpression param = Expression.Parameter(typeof(POLLUTANTTRANSFER), "s"); Expression exp = LinqExpressionBuilder.GetLinqExpressionPollutantTransfersConfidential(filter, param, false); Expression <Func <POLLUTANTTRANSFER, bool> > lambda = Expression.Lambda <Func <POLLUTANTTRANSFER, bool> >(exp, param); return(db.POLLUTANTTRANSFERs.Any(lambda)); }
/// <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(); PollutantTransfersSearchFilter filter = sender as PollutantTransfersSearchFilter; if (filter != null) { updateJavaScriptMap(filter); this.ucPollutantTransfersSheet.Populate(filter); } }
/// <summary> /// returns a dictionary with sheet headers <key, value> for pollutant transfer search /// </summary> public static Dictionary <string, string> GetPollutantTransferSearchHeader(PollutantTransfersSearchFilter filter, bool includeFacilityCount) { Dictionary <string, string> header = new Dictionary <string, string>(); addPollutant(header, filter.PollutantFilter); addYear(header, filter.YearFilter); addArea(header, filter.AreaFilter); if (includeFacilityCount) { addCount(header, filter.Count); } return(header); }
// ---------------------------------------------------------------------------------- // Map filters // ---------------------------------------------------------------------------------- #region Map /// <summary> /// returns the MapFilter (sql and layers) corresponding to the filter. /// </summary> public static MapFilter GetMapFilter(PollutantTransfersSearchFilter filter) { ParameterExpression param = Expression.Parameter(typeof(POLLUTANTTRANSFER), "s"); Expression exp = LinqExpressionBuilder.GetLinqExpressionPollutantTransfers(filter, param); Expression <Func <POLLUTANTTRANSFER, bool> > lambda = Expression.Lambda <Func <POLLUTANTTRANSFER, bool> >(exp, param); // create sql and sectors to map MapFilter mapFilter = new MapFilter(); mapFilter.SqlWhere = LinqExpressionBuilder.GetSQL(exp, param); mapFilter.SetLayers(filter.ActivityFilter); return(mapFilter); }
public static MapFilter GetMapJavascriptFilter(PollutantTransfersSearchFilter filter) { ParameterExpression param = Expression.Parameter(typeof(POLLUTANTTRANSFER), "s"); Expression exp = LinqExpressionBuilder.GetLinqExpressionPollutantTransfers(filter, param); Expression <Func <POLLUTANTTRANSFER, bool> > lambda = Expression.Lambda <Func <POLLUTANTTRANSFER, bool> >(exp, param); // create sql and sectors to map MapFilter mapFilter = new MapFilter(); mapFilter.SqlWhere = LinqExpressionBuilder.GetSQLJavascript(exp, param); mapFilter.SqlWhere = "FacilityReportID IN (select FacilityReportID from dbo.POLLUTANTTRANSFER where " + mapFilter.SqlWhere + ")"; return(mapFilter); }
/// <summary> /// Generates facility list for Pollutant Transfer search results /// </summary> /// <param name="filter">Holds the search criteria</param> /// <param name="sortColumn">Specifies the column used for sorting</param> /// <param name="descending">Indicate whether sorting is descending</param> /// <param name="startRowIndex">Starting index for paging</param> /// <param name="p"></param> /// <returns></returns> public static object FacilityList(PollutantTransfersSearchFilter filter, string sortColumn, bool descending, int startRowIndex, int pagingSize) { // add rows (pageing) List <PollutantTransfers.ResultFacility> result = new List <PollutantTransfers.ResultFacility>(); for (int i = 0; i < startRowIndex; i++) { result.Add(null); } // create expression DataClassesPollutantTransferDataContext db = getPollutantTransferDataContext(); ParameterExpression param = Expression.Parameter(typeof(POLLUTANTTRANSFER), "s"); Expression exp = LinqExpressionBuilder.GetLinqExpressionPollutantTransfers(filter, param); Expression <Func <POLLUTANTTRANSFER, bool> > lambda = Expression.Lambda <Func <POLLUTANTTRANSFER, bool> >(exp, param); // apply lambda IEnumerable <POLLUTANTTRANSFER> data = db.POLLUTANTTRANSFERs.Where(lambda).orderBy(sortColumn, descending); // set the number of found rows for this filter filter.Count = data.Count(); data = data.Skip(startRowIndex).Take(pagingSize); // default unit for Pollutant Transfers foreach (var v in data) { QuantityUnit unit = (v.UnitCode == QuantityUnit.Tonnes.ToString()) ? QuantityUnit.Tonnes : QuantityUnit.Kilo; result.Add(new PollutantTransfers.ResultFacility( v.IAActivityCode, v.FacilityName, v.Quantity, v.CountryCode, v.FacilityReportID, unit, v.ConfidentialIndicatorFacility, v.ConfidentialIndicator, v.FacilityID)); } // add rows (pageing) int addcount = result.Count; for (int i = 0; i < filter.Count - addcount; i++) { result.Add(null); } return(result); }
/// <summary> /// return full area tree with all rows expanded /// </summary> public static IEnumerable <AreaTreeListRow> GetAreaTree(PollutantTransfersSearchFilter filter) { IEnumerable <AreaTreeListRow> countries = GetCountries(filter).ToList(); List <string> countryCodes = countries.Where(p => p.HasChildren).Select(p => p.CountryCode).ToList(); IEnumerable <AreaTreeListRow> subareas = GetSubAreas(filter, countryCodes).ToList(); IEnumerable <AreaTreeListRow> result = countries.Union(subareas) .OrderBy(x => AreaTreeListRow.CODE_TOTAL.Equals(x.CountryCode)) .ThenBy(x => x.CountryCode) .ThenBy(x => AreaTreeListRow.CODE_UNKNOWN.Equals(x.RegionCode)) .ThenBy(x => x.RegionCode); return(result); }
public PollutantTransfersSearchFilter PopulateFilter() { PollutantTransfersSearchFilter filter = new PollutantTransfersSearchFilter(); filter.YearFilter = this.ucYearSearchOption.PopulateFilter(); filter.AreaFilter = this.ucAreaSearchOption.PopulateFilter(); filter.PollutantFilter = this.ucPollutantSearchOption.PopulateFilter(); filter.ActivityFilter = this.ucAdvancedActivitySearchOption.PopulateFilter(); // store settings in cookies CookieStorage.SetFilter(Response, filter.AreaFilter); CookieStorage.SetFilter(Response, filter.YearFilter); return(filter); }
/// <summary> /// Returns the number of facilities corresponding to the filter. Always use POLLUTANTTRANSFER table, since it has the fewest records. /// </summary> public static int GetFacilityCount(PollutantTransfersSearchFilter filter) { DataClassesPollutantTransferDataContext db = getPollutantTransferDataContext(); ParameterExpression param = Expression.Parameter(typeof(POLLUTANTTRANSFER), "s"); Expression exp = LinqExpressionBuilder.GetLinqExpressionPollutantTransfers(filter, param); Expression <Func <POLLUTANTTRANSFER, bool> > lambda = Expression.Lambda <Func <POLLUTANTTRANSFER, bool> >(exp, param); //find total no. of facilities. int count = db.POLLUTANTTRANSFERs .Where(lambda) .Select <POLLUTANTTRANSFER, int>(d => (int)d.FacilityReportID).Distinct() .Count(); return(count); }
/// <summary> /// populate and sort /// </summary> private void populateList(PollutantTransfersSearchFilter filter, string sortColumn) { int startRowIndex = PageIndex; bool descending = ViewState[sortColumn] != null && (bool)ViewState[sortColumn]; this.lvFacilityResult.DataSource = QueryLayer.PollutantTransfers.FacilityList(filter, sortColumn, descending, startRowIndex, getPageSize()); this.lvFacilityResult.DataBind(); // save current sort column (to be used in pageing) ViewState["sortcolumn"] = sortColumn; if (ContentChanged != null) { ContentChanged.Invoke(null, EventArgs.Empty); } }
/// <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.HasPollutantTransferSearchFilter(Request)) { PollutantTransfersSearchFilter filter = this.ucSearchOptions.PopulateFilter(); doSearch(filter, EventArgs.Empty); } } // When load completed, perserve scroll position ScriptManager.RegisterStartupScript(Page, typeof(string), this.UniqueID, "Sys.WebForms.PageRequestManager.getInstance().add_endRequest(SetScroll);", true); }
/// <summary> /// return full activity tree with all rows expanded /// </summary> public static IEnumerable <ActivityTreeListRow> GetActivityTree(PollutantTransfersSearchFilter filter) { IEnumerable <ActivityTreeListRow> sectors = GetSectors(filter).ToList(); List <string> sectorCodes = sectors.Where(p => p.HasChildren).Select(p => p.SectorCode).ToList(); IEnumerable <ActivityTreeListRow> activities = GetActivities(filter, sectorCodes).ToList(); List <string> activityCodes = activities.Where(p => p.HasChildren).Select(p => p.ActivityCode).ToList(); IEnumerable <ActivityTreeListRow> subactivities = GetSubActivities(filter, activityCodes).ToList(); //create result with full tree IEnumerable <ActivityTreeListRow> result = sectors.Union(activities).Union(subactivities) .OrderBy(s => s.SectorCode) .ThenBy(s => s.ActivityCode) .ThenBy(s => s.SubactivityCode); return(result); }
public void DoSaveCSV(object sender, EventArgs e) { try { CultureInfo csvCulture = CultureResolver.ResolveCsvCulture(Request); CSVFormatter csvformat = new CSVFormatter(csvCulture); // Create Header PollutantTransfersSearchFilter filter = SearchFilter; bool isConfidentialityAffected = PollutantTransfers.IsAffectedByConfidentiality(filter); Dictionary <string, string> header = EPRTR.HeaderBuilders.CsvHeaderBuilder.GetPollutantTransferSearchHeader( filter, isConfidentialityAffected); // Create Body var facilities = PollutantTransfers.GetFacilityListCSV(filter); // dump to file string topheader = csvformat.CreateHeader(header); string facilityHeader = csvformat.GetPollutantTranfersFacilityHeader(); string url = Request.Url.AbsoluteUri; url = url.Substring(0, url.LastIndexOf("/") + 1); Response.WriteUtf8FileHeader("EPRTR_Pollutant_Transfers_Facility_List"); Response.Write(topheader + facilityHeader); foreach (var item in facilities) { item.Url = String.Format("{0}/PopupFacilityDetails.aspx?FacilityReportId={1}", url, item.FacilityReportId); string row = csvformat.GetPollutantTransfersFacilityRow(item); Response.Write(row); } Response.End(); } catch { } }
public static IEnumerable <IATransfersTreeListRow> GetPollutantTransfers(IndustrialActivitySearchFilter filter) { DataClassesPollutantTransferDataContext db = getPollutantTransferDataContext(); ParameterExpression param = Expression.Parameter(typeof(POLLUTANTTRANSFER), "s"); PollutantTransfersSearchFilter filterTransfer = FilterConverter.ConvertToPollutantTransfersSearchFilter(filter); filterTransfer.ActivityFilter = filter.ActivityFilter; filterTransfer.AreaFilter = filter.AreaFilter; filterTransfer.YearFilter = filter.YearFilter; Expression exp = LinqExpressionBuilder.GetLinqExpressionPollutantTransfers(filterTransfer, param); Expression <Func <POLLUTANTTRANSFER, bool> > lambda = Expression.Lambda <Func <POLLUTANTTRANSFER, bool> >(exp, param); int facilitiesCount = 0; List <IATransfersTreeListRow> pollutants = getTransfers(db, lambda, out facilitiesCount).ToList <IATransfersTreeListRow>(); filter.Count = facilitiesCount; return(pollutants); }
// ---------------------------------------------------------------------------------- // Summery // ---------------------------------------------------------------------------------- #region summery /// <summary> /// Summery /// </summary> public static List <Summary.Quantity> Summery(PollutantTransfersSearchFilter filter) { DataClassesPollutantTransferDataContext db = getPollutantTransferDataContext(); // apply filter ParameterExpression param = Expression.Parameter(typeof(POLLUTANTTRANSFER), "s"); Expression exp = LinqExpressionBuilder.GetLinqExpressionPollutantTransfers(filter, param); Expression <Func <POLLUTANTTRANSFER, bool> > lambda = Expression.Lambda <Func <POLLUTANTTRANSFER, bool> >(exp, param); var summeryFiltered = db.POLLUTANTTRANSFERs.Where(lambda); var summery0 = from s in summeryFiltered select new { s.IAActivityCode, s.Quantity }; var summery1 = from s in summery0 group s by new { s.IAActivityCode }; var summery2 = from s in summery1 select new { code = s.Select(x => x.IAActivityCode).First(), count = s.Count(), sumQuantity = s.Sum(x => x.Quantity) }; double total = 0; filter.Count = 0; List <Summary.Quantity> final = new List <Summary.Quantity>(); foreach (var v in summery2) { if (v.sumQuantity > 0) { final.Add(new Summary.Quantity(v.code, v.sumQuantity)); total += v.sumQuantity; filter.Count += v.count; } } // Get top 10 list, sorted by quantity final = Summary.GetTop10(final, total); return(final); }
public void Populate(PollutantTransfersSearchFilter filter) { List <PollutantTransfers.AreaComparison> compareList = PollutantTransfers.GetAreaComparison(filter); string title = string.Empty; // Translate area codes translateArea(filter.AreaFilter, compareList); // update flash int compareListCount = compareList.Count; if (compareListCount != 0) { string swfFile = EPRTR.Charts.ChartsUtils.PolluntantTransferAreaComparisonChart; EPRTR.Charts.ChartsUtils.ChartClientScript(swfFile, title, compareList, this.compareChartPanel, this.UniqueID.ToString(), EPRTR.Charts.ChartsUtils.AreaType.Air, compareListCount); } else { //show no data control this.NoDataReturned.Visible = true; } }