/// <summary>
/// Search, fill data into summery
/// </summary>
public void Populate(FacilitySearchFilter filter)
{
SearchFilter = filter;
ConfidentialityAffected = Facility.IsAffectedByConfidentiality(filter); //Only determine once and store in viewstate
showContent(Sheets.FacilitySearch.Facilities.ToString());
}
public static List <FacilityCSV> GetFacilityListCSV(FacilitySearchFilter filter)
{
if (filter == null)
{
return(null);
}
// db handler
DataClassesFacilityDataContext db = getDataContext();
// Create basic expression
Expression <Func <FACILITYSEARCH_ALL, bool> > lambda = getLambdaExpression(filter);
//get data for correct type
IQueryable <FACILITYSEARCH_MAINACTIVITY> distinctFacilities = getDistinctFacilities(db, lambda);
IEnumerable <FacilityCSV> dataDistinct = distinctFacilities.orderBy("FacilityName", false).Select <FACILITYSEARCH_MAINACTIVITY, FacilityCSV>(v =>
new FacilityCSV(v.ReportingYear,
v.FacilityReportID,
v.NationalID,
v.FacilityID,
v.FacilityName,
v.ParentCompanyName,
v.PostalCode,
v.Address,
v.City,
v.IAActivityCode,
v.CountryCode,
v.RiverBasinDistrictCode,
v.NUTSLevel2RegionCode,
v.ConfidentialIndicator));
return(dataDistinct.ToList());
}
public FacilitySearchFilter PopulateFilter()
{
// Assign search parameters to filter (avoid use of session, request from EPRTR)
// create new filter instance
FacilitySearchFilter filter = new FacilitySearchFilter();
filter.AreaFilter = this.ucAreaSearchOptionEPER.PopulateFilter();
filter.YearFilter = this.ucYearSearchOptionEPER.PopulateFilter();
filter.FacilityLocationFilter = this.ucFacilityLocationSearchOption.PopulateFilter();
filter.ActivityFilter = this.ucAdvancedActivitySearchOptionEPER.PopulateFilter();
//pollutant filters
PollutantFilter pollutantFilter;
MediumFilter mediumFilter;
this.ucAdvancedPollutantSearchOptionEPER.PopulateFilters(out pollutantFilter, out mediumFilter);
filter.PollutantFilter = pollutantFilter;
filter.MediumFilter = mediumFilter;
// store settings in cookies
CookieStorage.SetFilter(Response, filter.AreaFilter);
CookieStorage.SetFilter(Response, filter.YearFilter);
return(filter);
}
private void showContent(string command)
{
hideSubControls();
this.ucSheetLinks.HighLight(command);
string txt = string.Empty;
string alert = string.Empty;
FacilitySearchFilter filter = SearchFilter;
bool conf = ConfidentialityAffected;
if (command.Equals(Sheets.FacilitySearch.Facilities.ToString()))
{
this.litHeadline.Text = Resources.GetGlobal("Facility", "FacilityListResult");
this.ucFacilityListResultEPER.Visible = true;
this.ucFacilityListResultEPER.Populate(filter);
alert = conf ? Resources.GetGlobal("Common", "ConfidentialityAlertLink") : String.Empty;
// activate download and print button
this.ucDownloadPrint.Visible = true;
this.ucDownloadPrint.Show(true, true);
this.ucDownloadPrint.SetPrintControl(this);
Sheet = Sheets.FacilitySearch.Facilities;
}
updateHeader(txt);
updateAlert(alert);
}
/// <summary>
/// new search on facility click
/// </summary>
protected void onFacilitySearchClick(object sender, CommandEventArgs e)
{
// create facility search filter from activity search criteria
FacilitySearchFilter filter = FilterConverter.ConvertToFacilitySearchFilter(SearchFilter);
// create new activity filter
filter.ActivityFilter = getActivityFilter(e);
LinkSearchRedirecter.ToFacilitySearch(Response, filter);
}
private void updateFlashMap(FacilitySearchFilter filter)
{
// update flash map
MapFilter mapfilter = QueryLayer.Facility.GetMapFilter(filter);
string header = MapPrintDetails.Build(SheetHeaderBuilder.GetFacilitySearchHeader(filter, false));
MapUtils.UpdateSmallMap(MasterSearchPageEPER.MAPID, Page, this.UniqueID, mapfilter, header, Request.ApplicationPath);
((MasterSearchPageEPER)this.Master).UpdateExpandedScript(mapfilter, header);
}
private void updateHeader(string text)
{
FacilitySearchFilter filter = SearchFilter;
// populate header
Dictionary <string, string> header = SheetHeaderBuilder.GetFacilitySearchHeader(filter, true);
this.ucSheetSubHeader.PopulateHeaderEPER(header);
this.ucSheetSubHeader.Text = text;
}
/// <summary>
/// Save
/// </summary>
///
public void DoSaveCSV(object sender, EventArgs e)
{
try
{
CultureInfo csvCulture = CultureResolver.ResolveCsvCulture(Request);
CSVFormatter csvformat = new CSVFormatter(csvCulture);
// Create Header
FacilitySearchFilter filter = SearchFilter;
bool isConfidentialityAffected = Facility.IsAffectedByConfidentiality(filter);
Dictionary <string, string> header = CsvHeaderBuilder.GetFacilitySearchHeader(
filter,
isConfidentialityAffected);
// Create Body
List <Facility.FacilityCSV> facilities = Facility.GetFacilityListCSV(filter);
// dump to file
string topheader = csvformat.CreateHeader(header).Replace("E-PRTR", "EPER");
string facilityHeader = csvformat.GetFacilityHeader();
string url = Request.Url.AbsoluteUri;
url = url.Substring(0, url.LastIndexOf("/") + 1);
Response.WriteUtf8FileHeader("EPER_Facility_List");
Response.Write(topheader + facilityHeader);
foreach (var v in facilities)
{
// translate codes
v.ActivityName = LOVResources.AnnexIActivityName(v.ActivityCode);
v.CountryName = LOVResources.CountryName(v.CountryCode);
v.NutsRegionName = LOVResources.NutsRegionName(v.NutsRegionCode);
v.RiverBasinName = LOVResources.RiverBasinDistrictName(v.RiverBasinCode);
v.FacilityName = ConfidentialFormat.Format(v.FacilityName, v.Confidential);
v.PostalCode = ConfidentialFormat.Format(v.PostalCode, v.Confidential);
v.Address = ConfidentialFormat.Format(v.Address, v.Confidential);
v.City = ConfidentialFormat.Format(v.City, v.Confidential);
v.URL = String.Format("{0}/PopupFacilityDetails.aspx?FacilityReportId={1}", url, v.FacilityReportID);
string row = csvformat.GetFacilityRow(v);
Response.Write(row);
}
Response.End();
}
catch
{
}
}
/// <summary>
/// new search on facility click
/// </summary>
protected void onFacilitySearchClick(object sender, CommandEventArgs e)
{
string code = e.CommandArgument.ToString().ToUpper();
// create facility search filter from activity search criteria
FacilitySearchFilter filter = FilterConverter.ConvertToFacilitySearchFilter(SearchFilter);
// Change activity filter
filter.ActivityFilter = getActivityFilter(e);
LinkSearchRedirecter.ToFacilitySearch(Response, filter);
}
/// <summary>
/// new search on facility click
/// </summary>
protected void onNewSearchClick(object sender, CommandEventArgs e)
{
// create facility search filter from activity search criteria
FacilitySearchFilter filter = FilterConverter.ConvertToFacilitySearchFilter(SearchFilter);
// Search for country according to code
filter.AreaFilter = getAreaFilter(e);
// go to facility levels page
LinkSearchRedirecter.ToFacilitySearch(Response, filter);
}
/// <summary>
/// Facility search button
/// </summary>
protected void btnSearch_Click(object sender, EventArgs e)
{
if (InvokeSearch != null)
{
FacilitySearchFilter filter = PopulateFilter();
// Give filter to facility-result usercontrol component
// This will invoke the search
InvokeSearch.Invoke(filter, e);
}
}
/// <summary>
/// returns the MapFilter (sql and layers) corresponding to the filter.
/// </summary>
public static MapFilter GetMapFilter(FacilitySearchFilter filter)
{
Expression <Func <FACILITYSEARCH_ALL, bool> > lambda = getLambdaExpression(filter);
// create sql and sectors to map
MapFilter mapFilter = new MapFilter();
mapFilter.SqlWhere = LinqExpressionBuilder.GetSQL(lambda, lambda.Parameters[0]);
mapFilter.SetLayers(filter.ActivityFilter);
return(mapFilter);
}
/// <summary>
/// Paging changed
/// </summary>
protected void OnPageChanging(object sender, PagePropertiesChangingEventArgs e)
{
ViewState[PAGEINDEX] = e.StartRowIndex;
this.datapager.SetPageProperties(e.StartRowIndex, e.MaximumRows, false);
// column to sort by
string sortColumn = ViewState[SORTCOLUMN].ToString();
FacilitySearchFilter currentfilter = SearchFilter;
// redo the populate
populateList(currentfilter, sortColumn);
}
public static MapFilter GetMapJavascriptFilter(FacilitySearchFilter filter)
{
Expression <Func <FACILITYSEARCH_ALL, bool> > lambda = getLambdaExpression(filter);
// create sql and sectors to map
MapFilter mapFilter = new MapFilter();
mapFilter.SqlWhere = LinqExpressionBuilder.GetSQLJavascript(lambda, lambda.Parameters[0]);
mapFilter.SqlWhere = "FacilityReportID IN (select FacilityReportID from FACILITYSEARCH_ALL where " + mapFilter.SqlWhere + ")";
return(mapFilter);
}
// ----------------------------------------------------------------------------------
// Confidentiality
// ----------------------------------------------------------------------------------
#region Confidentiality
public static bool IsAffectedByConfidentiality(FacilitySearchFilter filter)
{
DataClassesFacilityDataContext db = getDataContext();
ParameterExpression param = Expression.Parameter(typeof(FACILITYSEARCH_ALL), "s");
Expression exp = LinqExpressionBuilder.GetLinqExpressionFacilitySearchConfidential(filter, param);
// create lambda according to filters
Expression <Func <FACILITYSEARCH_ALL, bool> > lambda = Expression.Lambda <Func <FACILITYSEARCH_ALL, bool> >(exp, param);
// return true if found any
return(getDistinctFacilityReportIds(db, lambda).Any());
}
// ----------------------------------------------------------------------------------
// FacilityList
// ----------------------------------------------------------------------------------
#region FacilityList
/// <summary>
/// Return facility list
/// </summary>
public static List <FacilityRow> FacilityList(FacilitySearchFilter filter, string column, bool descending, int startRowIndex, int maxRows)
{
// Create basic expression
Expression <Func <FACILITYSEARCH_ALL, bool> > lambda = getLambdaExpression(filter);
// get number of distinct facilities for this search
DataClassesFacilityDataContext db = getDataContext();
filter.Count = getDistinctFacilityReportIds(db, lambda).Count();
IEnumerable <FacilityRow> dataDistinct = null;
if (filter.Count > 0)
{
//get data of correct type
IQueryable <FACILITYSEARCH_MAINACTIVITY> distinctFacilities = getDistinctFacilities(db, lambda);
dataDistinct = distinctFacilities.orderBy(column, descending)
.Skip(startRowIndex).Take(maxRows)
.Select <FACILITYSEARCH_MAINACTIVITY, FacilityRow>(v => new FacilityRow(v.FacilityID,
v.FacilityReportID,
v.FacilityName,
v.PostalCode,
v.Address,
v.City,
v.IAActivityCode,
v.CountryCode,
v.ConfidentialIndicator,
v.ReportingYear));
}
//add rows to result. Speedup paging by adding empty rows at the start and end of list.
List <FacilityRow> result = new List <FacilityRow>();
for (int i = 0; i < startRowIndex; i++)
{
result.Add(null);
}
if (dataDistinct != null)
{
result.AddRange(dataDistinct);
}
int addcount = result.Count;
for (int i = 0; i < filter.Count - addcount; i++)
{
result.Add(null);
}
return(result);
}
/// <summary>
/// returns a dictionary with sheet headers <key, value> for facility search
/// </summary>
public static Dictionary <string, string> GetFacilitySearchHeader(FacilitySearchFilter filter, bool includeFacilityCount)
{
Dictionary <string, string> header = new Dictionary <string, string>();
addArea(header, filter.AreaFilter);
addYear(header, filter.YearFilter);
if (includeFacilityCount)
{
addCount(header, filter.Count);
}
return(header);
}
/// <summary>
/// new search on facility click
/// </summary>
protected void onFacilitySearchClick(object sender, CommandEventArgs e)
{
// create facility search filter from activity search criteria
FacilitySearchFilter filter = FilterConverter.ConvertToFacilitySearchFilter(SearchFilter);
// create pollutant filter
filter.PollutantFilter = getPollutantFilter(e);
// set medium filter
filter.MediumFilter = LinkSearchBuilder.GetMediumFilter(false, false, false, true);
// go to facility levels page
LinkSearchRedirecter.ToFacilitySearch(Response, filter);
}
/// <summary>
/// new search on facility click
/// </summary>
protected void onFacilitySearchClick(object sender, CommandEventArgs e)
{
string code = e.CommandArgument.ToString();
// create facility search filter from activity search criteria
FacilitySearchFilter filter = FilterConverter.ConvertToFacilitySearchFilter(SearchFilter);
// create waste type filter according to command argument
filter.WasteTypeFilter = LinkSearchBuilder.GetWasteTypeFilter(code);
// go to facility levels page
LinkSearchRedirecter.ToFacilitySearch(Response, filter);
}
/// <summary>
/// new search on facility click
/// alternative Server.Transfer("FacilityLevels.aspx");
/// </summary>
protected void onNewSearchClick(object sender, CommandEventArgs e)
{
string code = e.CommandArgument.ToString().ToUpper();
// create facility search filter from activity search criteria
FacilitySearchFilter filter = FilterConverter.ConvertToFacilitySearchFilter(SearchFilter);
// create new area filter
filter.AreaFilter = getAreaFilter(e);
// go to facility search page with new filter
LinkSearchRedirecter.ToFacilitySearch(Response, filter);
}
/// <summary>
/// query data to be displayed in the facility resul listview
/// </summary>
private void doSearch(object sender, EventArgs e)
{
((MasterSearchPage)this.Master).ShowResultArea();
FacilitySearchFilter filter = sender as FacilitySearchFilter;
if (filter != null)
{
// call javascript map_small
updateJavaScriptMap(filter);
this.ucFacilityListSheet.Populate(filter);
}
}
/// <summary>
/// query data to be displayed in the facility resul listview
/// </summary>
private void doSearch(object sender, EventArgs e)
{
((MasterSearchPageEPER)this.Master).ShowResultArea();
FacilitySearchFilter filter = sender as FacilitySearchFilter;
if (filter != null)
{
updateJavaScriptMap(filter);
// update expanded map first
this.ucFacilityListSheetEPER.Populate(filter);
//updateFlashMap(filter);
}
}
/// <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.HasFacilitySearchFilter(Request))
{
FacilitySearchFilter filter = this.ucSearchOptions.PopulateFilter();
doSearch(filter, EventArgs.Empty);
}
}
}
/// <summary>
/// Basic populate, order by facility as default
/// </summary>
public void Populate(FacilitySearchFilter filter)
{
Control prop = this.Parent;
// assign current view states
SearchFilter = filter;
ViewState[PAGEINDEX] = 0;
// always start on page 1 when populate
this.datapager.SetPageProperties(0, getPageSize(), false);
this.datapager.Visible = (filter.Count > getPageSize());
// fill listview
populateList(filter, "FacilityName");
this.datapager.Visible = (filter.Count > getPageSize());
}
/// <summary>
/// new search on facility click
/// </summary>
protected void onNewSearchClick(object sender, CommandEventArgs e)
{
string code = e.CommandArgument.ToString().ToUpper();
// create facility search filter from activity search criteria
FacilitySearchFilter filter = FilterConverter.ConvertToFacilitySearchFilter(SearchFilter);
if (!code.Equals("TOTAL_KEY"))
{
// create new elements of waste filter
filter.WasteReceiverFilter = new WasteReceiverFilter();
filter.WasteReceiverFilter.CountryID = QueryLayer.ListOfValues.GetCountry(code).LOV_CountryID;
}
// go to facility search page with new filter
LinkSearchRedirecter.ToFacilitySearch(Response, filter);
}
/// <summary>
/// populate and sort
/// </summary>
private void sort(string sortColumn)
{
// when sorting according to column, jump to pageindex 0 (requirement)
ViewState[PAGEINDEX] = 0;
this.datapager.SetPageProperties(0, getPageSize(), false);
// set descending state
bool descending = ViewState[sortColumn] != null && (bool)ViewState[sortColumn];
ViewState[sortColumn] = !descending;
// get filter
FacilitySearchFilter currentfilter = SearchFilter;
// redo the populate according to the sorting
populateList(currentfilter, sortColumn);
}
/// <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.HasFacilitySearchFilter(Request))
{
FacilitySearchFilter filter = this.ucSearchOptionsEPER.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>
/// new search on facility click
/// </summary>
protected void onFacilitySearchClick(object sender, CommandEventArgs e)
{
string[] args = e.CommandArgument.ToString().Split('¤');
if (args == null || args.Length != 2)
{
return; // safe check
}
string facilityName = args[0];
string treatment = args[1].ToUpper().Trim();
// create facility search filter
FacilitySearchFilter filter = FilterConverter.ConvertToFacilitySearchFilter(SearchFilter);
// wastetype
filter.WasteTypeFilter = new WasteTypeFilter();
filter.WasteTypeFilter.NonHazardousWaste = false;
filter.WasteTypeFilter.HazardousWasteCountry = false;
filter.WasteTypeFilter.HazardousWasteTransboundary = true;
// receiver
filter.WasteReceiverFilter = new WasteReceiverFilter();
filter.WasteReceiverFilter.CountryID = QueryLayer.ListOfValues.GetCountry(CountryCode).LOV_CountryID;
// location
filter.FacilityLocationFilter = new FacilityLocationFilter();
filter.FacilityLocationFilter.FacilityName = facilityName;
filter.FacilityLocationFilter.CityName = String.Empty;
// treatmentSafe check, make sure a treatment is present in order to get result
bool unspec = treatment.Equals("U"), rec = treatment.Equals("R"), disp = treatment.Equals("D");
if (!disp && !rec && !unspec)
{
// safe check, make sure a treatment is present in order to get result
filter.WasteTreatmentFilter = LinkSearchBuilder.GetWasteTreatmentFilter(true, true, true);
}
else
{
filter.WasteTreatmentFilter = LinkSearchBuilder.GetWasteTreatmentFilter(unspec, rec, disp);
}
// create new facility search
LinkSearchRedirecter.ToFacilitySearch(Response, filter);
}
/// <summary>
/// invoke facility search for this row
/// </summary>
protected void onFacilitySearchClick(object sender, CommandEventArgs e)
{
string arg = e.CommandArgument.ToString();
string[] codeAndLevel = arg.Split('&');
if (codeAndLevel.Length < 2)
{
return; //safe check, must have min two value
}
// create facility search filter from activity search criteria
FacilitySearchFilter filter = FilterConverter.ConvertToFacilitySearchFilter(SearchFilter);
// create pollutant and medium filter
filter.PollutantFilter = getPollutantFilter(e);
filter.MediumFilter = getMediumFilter(e);
// go to facility levels page
LinkSearchRedirecter.ToFacilitySearch(Response, filter);
}
/// <summary>
/// returns a dictionary with csv headers <key, value> for facility search
/// </summary>
public static Dictionary <string, string> GetFacilitySearchHeader(
FacilitySearchFilter filter,
bool confidentialityAffected)
{
Dictionary <string, string> header = makeHeader();
addYear(header, filter.YearFilter);
addArea(header, filter.AreaFilter);
addFacilityLocation(header, filter.FacilityLocationFilter);
addActivity(header, filter.ActivityFilter);
addPollutant(header, filter.PollutantFilter);
addMedium(header, filter.MediumFilter);
addAccidental(header, filter.AccidentalFilter);
addWasteType(header, filter.WasteTypeFilter);
addWasteTreatment(header, filter.WasteTreatmentFilter);
addWasteReceiver(header, filter.WasteReceiverFilter);
addConfidentiality(header, confidentialityAffected);
return(header);
}
