public static string GetAreaName(this TreeListRow row, AreaFilter areaFilter)
{
switch (row.Level)
{
case 0: //country
return(LOVResources.CountryName(row.Code));
case 1: //River absin district or NUTS
{
AreaFilter.RegionType type = areaFilter.TypeRegion;
if (type == AreaFilter.RegionType.RiverBasinDistrict)
{
return(LOVResources.RiverBasinDistrictName(row.Code));
}
else
{
return(LOVResources.NutsRegionName(row.Code));
}
}
default:
return(string.Empty);
}
}
public List <AreaList> List(AreaFilter pFilter)
{
List <AreaList> List = new List <AreaList>();
using (SqlConnection con = _connection.DBPLANILLA())
{
using (SqlCommand cmd = new SqlCommand("usp_tbl_Area_List", con))
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.Add("@com_codigo", SqlDbType.VarChar).Value = pFilter.com_codigo;
if (con.State != ConnectionState.Open)
{
con.Open();
}
using (var dr = cmd.ExecuteReader())
{
while (dr.Read())
{
List.Add(new AreaList
{
are_codigo = DataReader.GetStringValue(dr, "ARE_CODIGO"),
are_descripcion = DataReader.GetStringValue(dr, "ARE_DESCRIPCION"),
});
}
}
}
if (con.State == ConnectionState.Open)
{
con.Close();
}
}
return(List);
}
/// <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);
}
public FilterInformation()
{
Sort = string.Empty;
Area = new AreaFilter();
Module = new ModuleFilter();
Action = new ActionFilter();
User = new UserFilter();
}
public async Task <ApiResult> GetAreasAsync(AreaFilter areaFilter)
{
var areasPagedResult = await areaRepository.GetAreasAsync(areaFilter);
var areasModelPagedResult = new PagedResult <AreaDto>();
Mapper.Map(areasPagedResult, areasModelPagedResult);
return(new ApiResult(MessageType.Success, areasModelPagedResult));
}
public AreaFilter PopulateFilter()
{
AreaFilter filter = new AreaFilter();
filter.AreaGroupID = SelectedAreaGroupID();
filter.CountryID = SelectedCountryId();
filter.RegionID = SelectedRegionID();
filter.TypeRegion = SelectedRegionType();
return(filter);
}
/// <summary>
///
/// </summary>
public static void SetFilter(HttpResponse response, AreaFilter filter)
{
if (response != null)
{
response.Cookies[HAS_AREAFILTER].Value = "1";
response.Cookies[AREAGROUP].Value = filter.AreaGroupID.ToString();
response.Cookies[COUNTRY].Value = filter.CountryID.ToString();
response.Cookies[REGION].Value = filter.RegionID.ToString();
response.Cookies[REGIONTYPE].Value = filter.TypeRegion.ToString();
}
}
public static AreaFilter GetAreaFilter(AreaFilter searchAreaFilter, string areaCode, string parentCode)
{
//for total-rows the activityfilter corresponds to the filter from the search
if (TreeListRow.CODE_TOTAL.Equals(areaCode))
{
return(searchAreaFilter == null ? null : searchAreaFilter.Clone() as AreaFilter);
}
AreaFilter areaFilter = new AreaFilter();
areaFilter.TypeRegion = searchAreaFilter.TypeRegion;
// Search for country according to code
REPORTINGCOUNTRY country = ListOfValues.GetReportingCountry(areaCode);
if (country != null)
{
//country level
areaFilter.CountryID = country.LOV_CountryID;
areaFilter.RegionID = AreaFilter.AllRegionsInCountryID;
}
else
{
country = ListOfValues.GetReportingCountry(parentCode);
areaFilter.CountryID = country.LOV_CountryID;
//NUTS or RBD level
if (areaFilter.TypeRegion.Equals(AreaFilter.RegionType.RiverBasinDistrict))
{
LOV_RIVERBASINDISTRICT rbd = ListOfValues.GetRiverBasinDistrict(areaCode);
if (rbd != null)
{
areaFilter.RegionID = rbd.LOV_RiverBasinDistrictID;
}
}
else if (areaFilter.TypeRegion.Equals(AreaFilter.RegionType.NUTSregion))
{
LOV_NUTSREGION nuts = ListOfValues.GetNutsRegion(areaCode);
if (nuts != null && !TreeListRow.CODE_UNKNOWN.Equals(areaCode))
{
areaFilter.RegionID = nuts.LOV_NUTSRegionID;
}
else
{
areaFilter.RegionID = null;
}
}
}
return(areaFilter);
}
public static AreaFilter GetAreaFilter(HttpRequest request)
{
if (HasAreaFilter(request))
{
AreaFilter filter = new AreaFilter();
filter.AreaGroupID = toIntNullable(request.QueryString[AREAGROUP]);
filter.CountryID = toIntNullable(request.QueryString[COUNTRY]);
filter.RegionID = toIntNullable(request.QueryString[REGION]);
filter.TypeRegion = toEnum <AreaFilter.RegionType>(request.QueryString[REGIONTYPE]);
return(filter);
}
return(null);
}
private Expression <Func <Area, bool> > GetAreaExpression(AreaFilter filter)
{
Expression <Func <Area, bool> > expression = null;
if (filter.Id > 0)
{
expression = expression.AddOrAssign(area => area.Id == filter.Id);
}
if (!filter.Name.IsNullOrEmpty())
{
expression = expression.AddOrAssign(area => area.Name == filter.Name);
}
return(expression);
}
// --------------------------------------------------------------------------------------------------------------------
// Area filter
// --------------------------------------------------------------------------------------------------------------------
#region AreaFilter
//will include trailing &
private static string SerializeToUrl(AreaFilter filter)
{
string result = String.Empty;
if (filter != null)
{
// Area
result += addParameter(AREAGROUP, filter.AreaGroupID);
result += addParameter(COUNTRY, filter.CountryID);
result += addParameter(REGION, filter.RegionID);
result += addParameter(REGIONTYPE, filter.TypeRegion.ToString());
}
return(result);
}
public Task <AreaFilter> CreateAsync(AreaFilter entity, string areaId)
{
var area = _zoneService.GetZoneById(areaId, x => x.Include(z => z.Settings));
if (area == null)
{
return(null);
}
entity.ZoneSettingsId = area.Settings.Id;
var newFilter = _areaFilterRepository.Add(entity);
return(Task.FromResult(newFilter));
}
//creates header for Area and adds to dictionary
protected static void addArea(Dictionary <string, string> header, AreaFilter filter)
{
if (filter != null)
{
string key = Resources.GetGlobal("Common", "Area");
string value = string.Empty;
AreaFilter.Level level = filter.SearchLevel();
if (level == AreaFilter.Level.AreaGroup)
{
string code = ListOfValues.GetAreaGroup((int)filter.AreaGroupID).Code;
value = LOVResources.AreaGroupName(code);
}
else if (level == AreaFilter.Level.Country)
{
string code = ListOfValues.GetCountry((int)filter.CountryID).Code;
value = LOVResources.CountryName(code);
}
else if (level == AreaFilter.Level.Region)
{
if (filter.TypeRegion == AreaFilter.RegionType.RiverBasinDistrict)
{
string code = ListOfValues.GetRiverBasinDistrict((int)filter.RegionID).Code;
value = LOVResources.RiverBasinDistrictName(code);
}
else if (filter.TypeRegion == AreaFilter.RegionType.NUTSregion)
{
if (filter.RegionID != null)
{
string code = ListOfValues.GetNUTSRegion((int)filter.RegionID).Code;
value = LOVResources.NutsRegionName(code);
}
else
{
value = LOVResources.NutsRegionName(TreeListRow.CODE_UNKNOWN);
}
}
else
{
throw new InvalidOperationException(string.Format("Illgegal RegionType {0}", filter.TypeRegion));
}
}
header.Add(key, value);
}
}
protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
// Look for filter from link search
Filter = LinkSearchBuilder.GetAreaFilter(Request);
// Only if we have nothing from the links search, look into the cookies
if (Filter == null)
{
Filter = CookieStorage.GetAreaFilter(Request);
}
// Populate
PopulateRegionType();
populateAreaCountry();
}
}
// Translate if specific country selected
private void translateArea(AreaFilter filter, List <PollutantTransfers.AreaComparison> compareList)
{
//dont translate countries, only regions (NUTS or RBD)
if (filter.SearchLevel() != AreaFilter.Level.AreaGroup)
{
foreach (PollutantTransfers.AreaComparison cl in compareList)
{
if (filter.TypeRegion == AreaFilter.RegionType.RiverBasinDistrict)
{
cl.Area = LOVResources.RiverBasinDistrictName(cl.Area); //RiverBasinDistrictCode
}
else if (filter.TypeRegion == AreaFilter.RegionType.NUTSregion)
{
cl.Area = LOVResources.NutsRegionName(cl.Area); //NUTS code
}
}
}
}
/// <summary>
/// Return the number of countries having reported per year for the area filter given
/// </summary>
/// <param name="areaFilter"></param>
/// <returns></returns>
public static IEnumerable <ReportingCountries> GetReportingCountries(AreaFilter areaFilter)
{
DataClassesFacilityDataContext db = getDataContext();
ParameterExpression param = Expression.Parameter(typeof(FACILITYSEARCH_MAINACTIVITY), "s");
Expression exp = LinqExpressionBuilder.GetLinqExpressionArea(areaFilter, param);
// create lambda according to filters
Expression <Func <FACILITYSEARCH_MAINACTIVITY, bool> > lambda = Expression.Lambda <Func <FACILITYSEARCH_MAINACTIVITY, bool> >(exp, param);
IEnumerable <ReportingCountries> years = db.FACILITYSEARCH_MAINACTIVITies.Where(lambda)
.GroupBy(f => f.ReportingYear)
.Select(s => new ReportingCountries(
s.Key,
s.Select(x => x.CountryCode).Distinct().Count()));
return(years);
}
/// <summary>
///
/// </summary>
public static AreaFilter GetAreaFilter(HttpRequest request)
{
// check if browser supports cookies
AreaFilter filter = null;
if (request.Browser.Cookies)
{
if (hasFilter(request, HAS_AREAFILTER))
{
filter = new AreaFilter();
filter.AreaGroupID = Global.ToIntNullable(request.Cookies[AREAGROUP].Value);
filter.CountryID = Global.ToIntNullable(request.Cookies[COUNTRY].Value);
filter.RegionID = Global.ToIntNullable(request.Cookies[REGION].Value);
filter.TypeRegion = Global.ToEnum <AreaFilter.RegionType>(request.Cookies[REGIONTYPE].Value);
}
}
return(filter);
}
public Result Execute(ExternalCommandData commandData, ref string message, ElementSet elements)
{
UIApplication uiapp = commandData.Application;
UIDocument uidoc = uiapp.ActiveUIDocument;
Application app = uiapp.Application;
Document doc = uidoc.Document;
ElementCategoryFilter roomFilter = new ElementCategoryFilter(BuiltInCategory.OST_Rooms);
var rooms = new FilteredElementCollector(doc, uidoc.ActiveView.Id)
.WherePasses(roomFilter)
.WhereElementIsNotElementType()
.Cast <SpatialElement>();
AreaFilter areaFilter = new AreaFilter();
var areaObjects = new FilteredElementCollector(doc, uidoc.ActiveView.Id)
.WherePasses(areaFilter)
.WhereElementIsNotElementType()
.Cast <Area>()
.Select(x => new AreaObject(x));
StringBuilder sb = new StringBuilder();
foreach (AreaObject areaobject in areaObjects)
{
List <SpatialElement> roomObjects = new List <SpatialElement>();
foreach (SpatialElement roomElement in rooms)
{
LocationPoint lp = roomElement.Location as LocationPoint;
if (areaobject.Area.AreaContains(lp.Point))
{
roomObjects.Add(roomElement);
sb.AppendLine(areaobject.Area.Name + " ;" + roomElement.Name);
}
}
areaobject.Rooms = roomObjects;
sb.AppendLine(areaobject.Area.Name + " ; Room Count:" + areaobject.Rooms.Count);
}
TaskDialog.Show("Area Objects", sb.ToString());
return(Result.Succeeded);
}
public static List<AreaViewModel> AreaFiltered(AreaFilter areaFilter)
{
var context = new ASJDE();
return context.VideoAreas.Where(a => a.CompanyID == areaFilter.CompanyID &&
(areaFilter.StrategicBusinessUnitID != null ? a.StrategicBusinessUnitID == areaFilter.StrategicBusinessUnitID : a.StrategicBusinessUnitID == null) &&
(areaFilter.OperationalBusinessUnitID != null ? a.OperationalBusinessUnitID == areaFilter.OperationalBusinessUnitID : a.OperationalBusinessUnitID == null) &&
(areaFilter.BusinessUnitID != null ? a.BusinessUnitID == areaFilter.BusinessUnitID: a.BusinessUnitID == null) &&
(areaFilter.BranchID != null ? a.BranchID == areaFilter.BranchID : a.BranchID == null) &&
(areaFilter.DepotID != null ? a.DepotID == areaFilter.DepotID : a.DepotID == null))
.Select(a => new AreaViewModel
{
ID = a.ID,
CompanyID = a.CompanyID.Value,
StrategicBusinessUnitID = a.StrategicBusinessUnitID.Value,
OperationalBusinessUnitID = a.OperationalBusinessUnitID.Value,
BusinessUnitID = a.BusinessUnitID.Value,
BranchID = a.BranchID.Value,
DepotID = a.DepotID.Value,
Name = a.Name
}).ToList();
}
public static List <AreaViewModel> AreaFiltered(AreaFilter areaFilter)
{
var context = new ASJDE();
return(context.VideoAreas.Where(a => a.CompanyID == areaFilter.CompanyID &&
(areaFilter.StrategicBusinessUnitID != null ? a.StrategicBusinessUnitID == areaFilter.StrategicBusinessUnitID : a.StrategicBusinessUnitID == null) &&
(areaFilter.OperationalBusinessUnitID != null ? a.OperationalBusinessUnitID == areaFilter.OperationalBusinessUnitID : a.OperationalBusinessUnitID == null) &&
(areaFilter.BusinessUnitID != null ? a.BusinessUnitID == areaFilter.BusinessUnitID: a.BusinessUnitID == null) &&
(areaFilter.BranchID != null ? a.BranchID == areaFilter.BranchID : a.BranchID == null) &&
(areaFilter.DepotID != null ? a.DepotID == areaFilter.DepotID : a.DepotID == null))
.Select(a => new AreaViewModel
{
ID = a.ID,
CompanyID = a.CompanyID.Value,
StrategicBusinessUnitID = a.StrategicBusinessUnitID.Value,
OperationalBusinessUnitID = a.OperationalBusinessUnitID.Value,
BusinessUnitID = a.BusinessUnitID.Value,
BranchID = a.BranchID.Value,
DepotID = a.DepotID.Value,
Name = a.Name
}).ToList());
}
public async Task <PagedResult <Area> > GetAreasAsync(AreaFilter filter)
{
filter = filter ?? new AreaFilter();
var result = unitOfWork.Query(GetAreaExpression(filter), filter.PropertiesToInclude);
var complexQuery = unitOfWork.QueryLogs <Area>(includes: new List <string> {
"LogDetails"
});
List <Area> list = await result.OrderBy(filter.OrderBy)
.Skip((filter.Page - 1) * filter.Skip).Take(filter.Take)
.ToListAsync();
var pagedResult = new PagedResult <Area>
{
Data = list,
PageInfo = await GetPageInfo(x => x.Id, filter, GetAreaExpression(filter))
};
return(pagedResult);
}
public WasteTransferAreaTreeListRowComparer(AreaFilter areaFilter)
{
this.areaFilter = areaFilter;
}
public PollutantReleasesAreaTreeListRowComparer(AreaFilter areaFilter)
{
this.areaFilter = areaFilter;
}
public PollutantTransfersAreaTreeListRowComparer(AreaFilter areaFilter)
{
this.areaFilter = areaFilter;
}
public async Task <IActionResult> Update(AreaFilter entity)
{
var updated = await _areaFilterService.UpdateAsync(entity);
return(Json(updated));
}
public async Task <IHttpActionResult> GetAreas(AreaFilter filter)
{
var apiResult = await areaManager.GetAreasAsync(filter);
return(Ok(apiResult));
}
public JsonResult GetAreas(AreaFilter areaFilter)
{
return Json(AreaFiltered(areaFilter), JsonRequestBehavior.AllowGet);
}
public JsonResult GetAreas(AreaFilter areaFilter)
{
return(Json(AreaFiltered(areaFilter), JsonRequestBehavior.AllowGet));
}
public AreaTreeListRowComparer(AreaFilter areaFilter)
{
this.areaFilter = areaFilter;
}
/// <summary>
/// Group by Area depending on the Area filter
/// </summary>
public static IQueryable <IGrouping <TreeListRowGroupByKey, WASTETRANSFER> > GroupBy(this IQueryable <WASTETRANSFER> source, AreaFilter areaFilter)
{
if (areaFilter == null)
{
throw new ArgumentNullException();
}
if (areaFilter.SearchLevel() == AreaFilter.Level.AreaGroup)
{
//group by country
return(source.GroupBy(p => new TreeListRowGroupByKey {
Code = p.CountryCode, ParentCode = null
}));
}
else
{
//group by region
return(source.GroupBy(areaFilter.TypeRegion));
}
}
public Task <AreaFilter> UpdateAsync(AreaFilter entity)
{
var updatedFilter = _areaFilterRepository.Update(entity);
return(Task.FromResult(updatedFilter));
}
