public async Task <GetAllCityResponseDto> GetAllAsync(PagingDto pagingDto)
{
if (pagingDto.RecordsPerPage > 100)
{
return new GetAllCityResponseDto {
Success = false, Message = "The maximum number of records per page is 100."
}
}
;
var citiesTask = CityRepository.GetAllAsync(pagingDto.RecordsPerPage, pagingDto.Page);
var countTask = CityRepository.CountAsync();
await Task.WhenAll(citiesTask, countTask);
var totalPages = Math.DivRem(countTask.Result, pagingDto.RecordsPerPage, out int remainder);
pagingDto.TotalRecords = countTask.Result;
pagingDto.TotalPages = remainder > 0 ? totalPages + 1 : totalPages;
return(new GetAllCityResponseDto
{
Data = citiesTask.Result.Select(city => new CityDto
{
Key = city.Key.ToString(),
Name = city.Name,
PostalCode = city.PostalCode,
CreatedOn = city.CreatedOn.ToString("s")
}).ToList(),
Paging = pagingDto
});
}
/// <summary>
/// This method returns all Lockers by City
/// </summary>
/// <returns></returns>
public async Task <List <LockerDVM> > GetLockersByCityName(string key)
{
List <LockerDVM> cdvmList = null;
var cList = await lockerRepository.GetAllAsync();
var searchRes = new List <Locker>();
if (cList.Count() > 0)
{
var cities = await cityRepository.GetAllAsync();
var sc = cities.Where(m => m.Name.ToLower().StartsWith(key.ToLower()) || m.Name.Contains(key.ToLower()) || m.Name.ToLower() == key.ToLower());
foreach (var city in sc)
{
var sList = cList.Where(m => m.CityId == city.CityId);
searchRes.AddRange(sList);
}
try
{
cdvmList = mapper.Map <List <LockerDVM> >(searchRes);
}
catch (Exception ex)
{
throw ex;
}
}
return(cdvmList);
}
public void getAllAsyncTest()
{
//Arrange
CityRepository repo = new CityRepository();
//Act
Task <IList <City> > task = repo.GetAllAsync();
//Assert
Assert.IsNotNull(task);
}
public async Task OnGetAllWithTemperaturesAsync()
{
var cities = Builder <City> .CreateListOfSize(10).Build();
var temperatures = Builder <CityTemperature> .CreateListOfSize(10).Build();
CityRepository.GetAllAsync().Returns(cities);
CityTemperatureRepository.GetAllAsync().Returns(temperatures);
var result = await CityService.GetAllWithTemperaturesAsync();
result.Data.Should().HaveCount(10);
}
public async Task OnGetAllAsyncCountOdd()
{
var count = 11;
var paging = new PagingDto {
RecordsPerPage = 2
};
var cities = Builder <City> .CreateListOfSize(paging.RecordsPerPage).Build();
CityRepository.CountAsync().Returns(count);
CityRepository.GetAllAsync(Arg.Any <int>(), Arg.Any <int>()).Returns(cities);
var result = await CityService.GetAllAsync(paging);
result.Success.Should().BeNull();
result.Data.Should().HaveCount(paging.RecordsPerPage);
result.Paging.TotalPages.Should().Be((count / paging.RecordsPerPage) + 1);
}
public async Task <List <CityDVM> > GetAllCitiesAsync()
{
List <CityDVM> cdvmList = null;
var cList = await cityRepository.GetAllAsync();
if (cList != null)
{
cdvmList = new List <CityDVM>();
try
{
cdvmList = mapper.Map <List <CityDVM> >(cList.ToList());
}
catch (Exception ex)
{
throw ex;
}
}
return(cdvmList);
}
public async Task <GetAllCityTemperaturesDto> GetAllWithTemperaturesAsync()
{
var citiesTask = CityRepository.GetAllAsync();
var temperaturesTask = CityTemperatureRepository.GetAllAsync();
await Task.WhenAll(citiesTask, temperaturesTask);
return(new GetAllCityTemperaturesDto
{
Data = citiesTask.Result.Select(city => new CityWithTemperatureDto
{
City = city.Name,
Temperatures = temperaturesTask.Result.Where(t => t.CityKey == city.Key).Select(t => new CityTemperatureDto
{
Temperature = t.Temperature,
CreatedOn = t.CreatedOn.ToString("s")
})
.OrderBy(i => i.CreatedOn)
.ToList()
})
.OrderBy(i => i.City)
.ToList()
});
}
public async Task <IList <City> > Get()
{
return(await cityRepo.GetAllAsync());
}
