private PaginatedPropertyList GetPaginatedPropertyList(PropertyListRequest requestParams)
{
var query = PropertiesQuery(requestParams);
var totalItems = query.Count();
// if no limit for page size, then page size will be equal to total items so we return all results.
var pageSize = requestParams.PageSize != PropertyListRequest.NoLimitForPageSize ? requestParams.PageSize : totalItems;
query = query.Skip(requestParams.CurrentPage * pageSize).Take(pageSize);
var propertyDtoList = Mapper.Map <IQueryable <Entity.Models.Property>, List <Dto.Models.Property> >(query);
GenerateUserPhotoLinks(propertyDtoList);
// If requestParams is not empty, we should have received page info.
var paginatedList = new PaginatedPropertyList
{
Properties = propertyDtoList,
CurrentPage = requestParams.CurrentPage,
PageSize = pageSize,
TotalPages = (int)Math.Ceiling((double)totalItems / pageSize),
TotalItems = totalItems
};
return(paginatedList);
}
public async Task GetProperties()
{
CurrentPage = 0;
var requestParams = new PropertyListRequest
{
CurrentPage = CurrentPage,
PageSize = PageSize,
NameFilter = NameFilter,
CityFilter = CityFilter,
StateFilter = StateFilter,
SortColumn = SortColumn,
SortAscending = SortAscending,
UserIdListFilter = UserIdListFilter,
};
var result = await GetPropertiesAsync(requestParams);
if (result != null)
{
Properties.Clear();
foreach (var p in result.Properties)
{
Properties.Add(p);
}
LastResult = result;
TotalPages = LastResult.TotalPages;
OnPropertyListUpdated(result);
}
}
// #future: If we want to build on this query - make return type IQueryable<>
private IQueryable <Entity.Models.Property> PropertiesQuery(PropertyListRequest requestParams = null)
{
var query = db.Properties.Where(p => p.CompanyId == loggedInUser.CompanyId); /* loggedInUser.Properties.AsQueryable() */
if (requestParams != null)
{
if (requestParams.UserIdListFilter.Count > 0)
{
query = query.Where(p => p.Users.Count(u => requestParams.UserIdListFilter.Contains(u.Id)) > 0);
}
// First apply search filter
if (!String.IsNullOrEmpty(requestParams.StateFilter))
{
var stateFilter = requestParams.StateFilter.Trim().ToLower();
query = query.Where(p => (!String.IsNullOrEmpty(p.StateProvince) && p.StateProvince.ToLower().Contains(stateFilter)));
}
if (!String.IsNullOrEmpty(requestParams.CityFilter))
{
var cityFilter = requestParams.CityFilter.Trim().ToLower();
query = query.Where(p => (!String.IsNullOrEmpty(p.City) && p.City.ToLower().Contains(cityFilter)));
}
if (!String.IsNullOrEmpty(requestParams.NameFilter))
{
var nameFilter = requestParams.NameFilter.Trim().ToLower();
query = query.Where(p => (!String.IsNullOrEmpty(p.Name) && p.Name.ToLower().Contains(nameFilter)));
}
// Second apply sorting
if (!String.IsNullOrEmpty(requestParams.SortColumn))
{
bool asc = requestParams.SortAscending;
switch (requestParams.SortColumn)
{
case PropertyListRequest.NameColumn:
query = asc ? query.OrderBy(p => p.Name) : query.OrderByDescending(p => p.Name);
break;
case PropertyListRequest.CityColumn:
query = asc ? query.OrderBy(p => p.City) : query.OrderByDescending(p => p.City);
break;
case PropertyListRequest.StateColumn:
query = asc ? query.OrderBy(p => p.StateProvince) : query.OrderByDescending(p => p.StateProvince);
break;
}
}
else
{
// Skip Needs orderby clause
query = query.OrderBy(p => p.Name);
}
}
return(query);
}
private async Task <PaginatedPropertyList> GetPropertiesAsync(PropertyListRequest requestParams)
{
object response = null;
using (_dialogService.Loading("Getting properties..."))
response = await _propertyTrackerService.GetProperties(requestParams);
if (response is PaginatedPropertyList)
{
return(response as PaginatedPropertyList);
}
var msg = response is ErrorResult ? (response as ErrorResult).Message : "Failed to retreive properties";
_dialogService.Alert(msg, "Request Failed");
return(null);
}
public async Task <object> GetProperties(PropertyListRequest requestParams)
{
if (!LoggedIn)
{
Debug.WriteLine("Not logged in");
return(null);
}
var flurl = PropertiesRequestUrl.SetQueryParams(requestParams);
// Flurl seems to skip bool parameters. Add it manually.
flurl.SetQueryParam("SortAscending", requestParams.SortAscending ? "true" : "false");
// Flurl doesn't know how to marshal a list into a query string, so we do it ourselves by
// emitting the same key for different userid values, so that Web Api query string
// parsing will be able to re-create the List<int>
flurl.RemoveQueryParam("UserIdListFilter");
string url = flurl;
foreach (var userid in requestParams.UserIdListFilter)
{
url += "&UserIdListFilter=" + userid;
}
using (var response = await _client.GetAsync(url))
{
var content = response.Content != null ? await response.Content.ReadAsStringAsync() : null;
if (response.IsSuccessStatusCode == false)
{
var errorResult = content != null?JsonConvert.DeserializeObject <ErrorResult>(content) : null;
Debug.WriteLine("Request failed: " + response.ToString());
return(errorResult);
}
var parsedObject = JsonConvert.DeserializeObject <PaginatedPropertyList>(content);
if (parsedObject == null)
{
Debug.WriteLine("Could not deserialize json(" + content + ")");
}
return(parsedObject);
}
}
public IHttpActionResult GetProperties([FromUri] PropertyListRequest requestParams)
{
loggedInUser = GetLoggedInUser();
if (requestParams == null)
{
return(BadRequest("Property list request parameters are missing"));
}
var result = new PropertyListRequestValidator().Validate(requestParams);
if (!result.IsValid)
{
return(new ValidatorError("Error validating page request parameters", HttpStatusCode.BadRequest, result, Request));
}
// Get properties based on parameters we got
var paginatedList = GetPaginatedPropertyList(requestParams);
return(Ok(paginatedList));
}
