public async Task <IEnumerable <Restaurant> > GetRestaurantsAsync(RestaurantResourceParameters restaurantParams)
{
if (restaurantParams == null)
{
throw new ArgumentNullException(nameof(restaurantParams));
}
// check if both is null
if (string.IsNullOrWhiteSpace(restaurantParams.MainCategory) &&
string.IsNullOrWhiteSpace(restaurantParams.SearchQuery) &&
string.IsNullOrWhiteSpace(restaurantParams.Sort))
{
return(await GetRestaurantsAsync());
}
var collection = _context.Restaurants as IQueryable <Restaurant>;
if (!string.IsNullOrWhiteSpace(restaurantParams.SearchQuery))
{
var searchQuery = restaurantParams.SearchQuery.Trim();
collection = collection.Where(r => r.Name.IndexOf(searchQuery, StringComparison.CurrentCultureIgnoreCase) >= 0 ||
r.Address.IndexOf(searchQuery, StringComparison.CurrentCultureIgnoreCase) >= 0);
Console.WriteLine(collection.ToList()[0]);
}
// sort query
collection = SortRestaurant(restaurantParams.Sort, collection);
return(await collection.AsNoTracking().ToListAsync());
}
public async Task <ActionResult <IEnumerable <RestaurantDto> > > GetRestaurants(
[FromQuery] RestaurantResourceParameters resourceParameters)
{
var restaurants = await _knockRepository.GetRestaurantsAsync(resourceParameters);
return(Ok(_mapper.Map <IEnumerable <RestaurantDto> >(restaurants)));
}
public async Task <IActionResult> GetDefaultCityRestaurants(RestaurantResourceParameters restaurantParams)
{
var restaurants = await _restService.GetRestaurantsForCityAsync(OrdConstants.DefaultCity,
restaurantParams);
SetRestaurantsPaginationMetaData(restaurants);
var models = _restMapper.RestaurantEntitiesToModels(restaurants);
return(Ok(models));
}
public async Task <IActionResult> GetRestaurants(RestaurantResourceParameters restaurantParams)
{
// If no suburb and no city has been specified, get all restaurants for Johannesburg
// which will be the default city for all users. If no suburb and no city was specified
// I assume that geolocation failed so the default will be loaded unless the user specifies
// a different suburb or city.
// Might have to get suburb and city from user so if suburb is not in service areas
// then city can be searched and if city is not in suburb areas, load default.
if (!string.IsNullOrEmpty(restaurantParams.Suburb) &&
!string.IsNullOrEmpty(restaurantParams.City))
{
return(BadRequest(new
{
Error = "Cannot request restaurants by suburb and city together. " +
"Please request either suburb or city separately."
}));
}
PagedList <Restaurant> restaurants = null;
if (!string.IsNullOrEmpty(restaurantParams.Suburb))
{
restaurants = await _restService.GetRestaurantsForSuburbAsync(restaurantParams.Suburb,
restaurantParams);
}
if (!string.IsNullOrEmpty(restaurantParams.City))
{
restaurants = await _restService.GetRestaurantsForCityAsync(restaurantParams.City,
restaurantParams);
}
if (restaurants == null)
{
restaurants = new PagedList <Restaurant>();
}
var paginationMetadata = new
{
totalCount = restaurants.TotalCount,
pageSize = restaurants.PageSize,
currentPage = restaurants.CurrentPage,
totalPages = restaurants.TotalPages
};
var models = _restMapper.RestaurantEntitiesToModels(restaurants);
return(Ok(new { Values = models, PagingInfo = paginationMetadata }));
}
public async Task <PagedList <Restaurant> > GetRestaurantsForSuburbAsync(string suburbName,
RestaurantResourceParameters restaurantParameters)
{
var restaurants = _restRepo.EntityDbSet
.Where(r => r.Suburb == suburbName)
.Where(r => r.IsActive)
.Include(r => r.CollectionTypes)
.ThenInclude(c => c.CollectionType)
.Include(r => r.PaymentMethods)
.ThenInclude(p => p.PaymentMethod);
return(await PagedList <Restaurant> .CreateAsync(restaurants,
restaurantParameters.PageNumber,
restaurantParameters.PageSize));
}
public async Task <IActionResult> GetServiceAreaRestaurants(ServiceArea serviceArea,
RestaurantResourceParameters restaurantParams)
{
// Check that serviceArea object is not null, if so return error 400.
if (string.IsNullOrEmpty(serviceArea.Suburb) &&
string.IsNullOrEmpty(serviceArea.City))
{
return(BadRequest(new
{
Error = "Service Area suburb and city were not provided."
}));
}
// Check if suburb is in service areas, if not, move onto city.
if (await _saService.SuburbIsInService(serviceArea.Suburb))
{
var restaurants = await _restService.GetRestaurantsForSuburbAsync(serviceArea.Suburb,
restaurantParams);
SetRestaurantsPaginationMetaData(restaurants);
var models = _restMapper.RestaurantEntitiesToModels(restaurants);
return(Ok(models));
}
// Check if city is in service areas, if not, redirect to default city.
if (await _saService.CityIsInService(serviceArea.City))
{
var restaurants = await _restService.GetRestaurantsForCityAsync(serviceArea.City,
restaurantParams);
SetRestaurantsPaginationMetaData(restaurants);
var models = _restMapper.RestaurantEntitiesToModels(restaurants);
return(Ok(models));
}
return(RedirectToAction("GetDefaultCityRestaurants"));
}
