public async Task ShouldReturnEmptyPaging(IPageParameters pageParameters, IUnitOfWork uow)
{
// Arrange
var sut = new TeamsService(uow, this.Logger);
// Act
var actual = await sut.GetTeams(uow.Repository <Team>().First(t => t.Code != Team.RootTeamCode).Code, pageParameters);
// Assert
Assert.Empty(actual);
Assert.Equal(0, actual.PageNumber);
Assert.Equal(0, actual.TotalPages);
Assert.Equal(pageParameters.PageSize, actual.PageSize);
}
private void CheckSettingsAndContinue(PageToken requestedPage, IPageParameters pageParameters)
{
if (
string.IsNullOrEmpty(SettingsService.Instance.LocalSettings.ServerAddress) ||
string.IsNullOrEmpty(SettingsService.Instance.LocalSettings.Username)
)
{
NavigationService.Navigate(PageToken.Login.ToString(), null);
}
else
{
var vault = new PasswordVault();
IReadOnlyList <PasswordCredential> credentialList = null;
try
{
credentialList = vault.FindAllByResource(SettingsService.Instance.LocalSettings.ServerAddress);
}
catch
{
// ignored
}
var credential = credentialList?.FirstOrDefault(item => item.UserName.Equals(SettingsService.Instance.LocalSettings.Username));
if (credential != null)
{
credential.RetrievePassword();
if (!string.IsNullOrEmpty(credential.Password))
{
NavigationService.Navigate(requestedPage.ToString(), pageParameters?.Serialize());
}
else
{
NavigationService.Navigate(
PageToken.Login.ToString(),
null);
}
}
else
{
NavigationService.Navigate(
PageToken.Login.ToString(),
null);
}
}
// Ensure the current window is active
Window.Current.Activate();
}
protected override Task OnLaunchApplicationAsync(LaunchActivatedEventArgs args)
{
// Ensure the current window is active
Window.Current.Activate();
// Remove unnecessary notifications whenever the app is used.
ToastNotificationManager.History.RemoveGroup(ToastNotificationService.SyncAction);
PinStartPageParameters pageParameters = null;
if (!string.IsNullOrEmpty(args?.Arguments))
{
var tmpResourceInfo = JsonConvert.DeserializeObject <ResourceInfo>(args.Arguments);
if (tmpResourceInfo != null)
{
pageParameters = new PinStartPageParameters()
{
ResourceInfo = tmpResourceInfo,
PageTarget = tmpResourceInfo.IsDirectory ? PageToken.DirectoryList : PageToken.FileInfo
};
}
}
if (SettingsService.Default.Value.LocalSettings.UseWindowsHello)
{
CheckSettingsAndContinue(PageToken.Verification, pageParameters);
}
else
{
IPageParameters resourceInfoPageParameters = null;
if (pageParameters?.PageTarget == PageToken.DirectoryList)
{
resourceInfoPageParameters = new DirectoryListPageParameters
{
ResourceInfo = pageParameters?.ResourceInfo
};
}
else if (pageParameters?.PageTarget == PageToken.FileInfo)
{
resourceInfoPageParameters = new FileInfoPageParameters
{
ResourceInfo = pageParameters?.ResourceInfo
};
}
CheckSettingsAndContinue(pageParameters?.PageTarget ?? PageToken.DirectoryList, resourceInfoPageParameters);
}
return(Task.FromResult(true));
}
public void Setup()
{
DbContextOptions <TestDbContext> options = new DbContextOptionsBuilder <TestDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options;
_dbContext = new TestDbContext(options);
_allUsers = new Fixture().CreateMany <User>(10);
_dbContext.Users.AddRange(_allUsers);
_dbContext.SaveChanges();
_options = new StaticPageParameters
{
Offset = 2,
Limit = 1
};
_repository = new PagedFactory(_options).MakePaged <Repository>(_dbContext);
}
public static async Task <IPagedCollection <T> > ApplyPaging <T>(this IQueryable <T> query, IPageParameters paging, CancellationToken cancellationToken = default(CancellationToken))
{
var skip = (paging.PageNumber - 1) * paging.PageSize;
var count = await query.CountAsync(cancellationToken);
if (count == 0)
{
return(PagedCollection <T> .Empty(paging.PageSize));
}
var totalPages = count / paging.PageSize;
if ((count % paging.PageSize) > 0)
{
totalPages++;
}
if (skip >= count)
{
return(new PagedCollection <T>(new T[0], totalPages + 1, totalPages, paging.PageSize));
}
var result = await query.Skip(skip).Take(paging.PageSize).ToListAsync(cancellationToken);
return(new PagedCollection <T>(result, paging.PageNumber, totalPages, paging.PageSize));
}
/// <summary>
/// Read method,
/// gets a list of VehicleModels from VehicleModel Repository,
/// does sorting, filtering and pagging.
/// </summary>
/// <param name="sortParameters">Has 2 properties: Sort and Sort Direction.</param>
/// <param name="filterParameters">Has 2 properties: Search and MakeId.</param>
/// <param name="pageParameters">Has 2 properties: Page and PageSize.</param>
/// <returns>Retuns a list of paged, sorted and filtered IVehicleModel.</returns>
public async Task <IPagedResult <IVehicleModel> > GetVehicleModelsAsync(ISortParameters sortParameters, IFilterParameters filterParameters, IPageParameters pageParameters)
{
return(await repository.GetVehicleModelsAsync(sortParameters, filterParameters, pageParameters));
}
public async Task <IPagedList <VehicleMake> > GetVehicleMakesAsync(ISortParameters sort, IFilterParameters filter, IPageParameters pagep)
{
var makeList = await _repository.GetVehicleMakesAsync(sort, filter, pagep);
var makeVMList = AutoMapper.Mapper.Map <IEnumerable <VehicleMake> >(makeList);
return(new StaticPagedList <VehicleMake>(makeVMList, makeList.GetMetaData()));
}
public async Task ShouldThrowObjectNotFoundExceptionOnNotFoundColde(IUnitOfWork unitOfWork, IPageParameters paging, string code)
{
// Arrange
var sut = new TeamsService(unitOfWork, this.Logger);
// Act & Assert
await Assert.ThrowsAsync <ObjectNotFoundException>(() => sut.GetTeams(code, paging));
}
public IPagedList <IVehicleMake> GetVehicleMakePaged(ISortParameters sortParameters, IFilterParameters filterParameters, IPageParameters pageParameters)
{
var vehicleMakeList = context.VehicleMakes.AsEnumerable();
switch (sortParameters.Sort)
{
case "Name":
vehicleMakeList = vehicleMakeList.OrderBy(c => c.Name);
break;
case "Abrv":
vehicleMakeList = vehicleMakeList.OrderBy(c => c.Abrv);
break;
default:
vehicleMakeList = vehicleMakeList.OrderBy(c => c.Id);
break;
}
if (!string.IsNullOrEmpty(filterParameters.Search))
{
vehicleMakeList = vehicleMakeList.Where(c => c.Name.ToUpper().Contains(filterParameters.Search.ToUpper()));
}
if (sortParameters.Direction == "Descending")
{
vehicleMakeList = vehicleMakeList.Reverse();
}
return(vehicleMakeList.ToPagedList(pageParameters.Page, pageParameters.PageSize));
}
public async Task <IPagedList <VehicleMakeEntity> > GetVehicleMakesAsync(ISortParameters sort, IFilterParameters filter, IPageParameters pagep)
{
//Search
if (!string.IsNullOrEmpty(filter.Search))
{
vehicleMakes = repository.GetAll().Where(s => s.Name.ToUpper().StartsWith(filter.Search.ToUpper())).AsQueryable();
}
else
{
vehicleMakes = repository.GetAll().AsQueryable();
}
//OrderBy
switch (sort.SortBy?.ToUpper())
{
case "NAME":
vehicleMakes = vehicleMakes.OrderBy(s => s.Name).AsQueryable();
break;
case "ID":
vehicleMakes = vehicleMakes.OrderBy(s => s.Id).AsQueryable();
break;
default:
vehicleMakes = vehicleMakes.OrderBy(s => s.Id).AsQueryable();
break;
}
//ORDER BY DESCENDING
if (sort.SortOrder?.ToUpper() == "DESC")
{
vehicleMakes = vehicleMakes.OrderByDescending(s => s.Name).AsQueryable();
vehicleMakes = vehicleMakes.OrderByDescending(s => s.Id).AsQueryable();
}
;
return(vehicleMakes.ToPagedList(pagep.Page, pagep.PageSize));
}
public async Task <IPagedCollection <TeamFacade> > GetTeams(string parentTeamCode, IPageParameters paging, CancellationToken cancellationToken = default(CancellationToken))
{
Guard.NotNull(parentTeamCode, nameof(parentTeamCode));
Guard.NotNull(paging, nameof(paging));
var parentTeam = await this.unitOfWork.Repository <Team>().FirstOrDefaultAsync(t => t.Code == parentTeamCode);
if (parentTeam == null)
{
throw new ObjectNotFoundException();
}
var data = await this.unitOfWork.Repository <Team>()
.Where(t => t.ParentId == parentTeam.Id)
.Select(t => new TeamFacade
{
Id = t.Id,
Name = t.Name,
Code = t.Code,
})
.OrderBy(f => f.Code)
.ApplyPaging(paging, cancellationToken);
return(data);
}
public Task <IPagedCollection <TeamFacade> > GetTeams(IPageParameters paging, CancellationToken cancellationToken = default(CancellationToken))
{
return(this.GetTeams(Team.RootTeamCode, paging, cancellationToken));
}
public PagedProxy(IPageParameters parameters)
{
_parameters = parameters;
}
/// <summary>
/// Read method,
/// gets a list of VehicleMakes from Generic Repository,
/// does sorting, filtering and pagging.
/// </summary>
/// <param name="sortParameters">Has 2 properties: Sort and Sort Direction.</param>
/// <param name="filterParameters">Has 2 properties: Search and MakeId.</param>
/// <param name="pageParameters">Has 2 properties: Page and PageSize.</param>
/// <returns>Returns a list of paged, sorted and filtered IVehicleMake.</returns>
public async Task <IPagedResult <IVehicleMake> > GetVehicleMakesAsync(ISortParameters sortParameters, IFilterParameters filterParameters, IPageParameters pageParameters)
{
IQueryable <VehicleMakeEntity> vehicleMakeList;
PagedResult <IVehicleMake> PagedVehicleMake = new PagedResult <IVehicleMake>();
if (!string.IsNullOrEmpty(filterParameters.Search))
{
vehicleMakeList = Repository.GetVehiclesAsync().Where(x => x.Abrv.ToUpper() == filterParameters.Search.ToUpper() || x.Name.ToUpper().Contains(filterParameters.Search.ToUpper())).OrderBy(x => x.Id).AsQueryable();
}
else
{
vehicleMakeList = Repository.GetVehiclesAsync().OrderBy(x => x.Id);
}
if (!string.IsNullOrEmpty(sortParameters.Sort))
{
if (sortParameters.Sort.ToUpper() == "NAME")
{
vehicleMakeList = vehicleMakeList.OrderBy(x => x.Name).AsQueryable();
}
else if (sortParameters.Sort.ToUpper() == "ABRV")
{
vehicleMakeList = vehicleMakeList.OrderBy(x => x.Abrv).AsQueryable();
}
}
else
{
vehicleMakeList = vehicleMakeList.OrderBy(x => x.Id).AsQueryable();
}
if (sortParameters.SortDirection.ToUpper() == "DESCENDING")
{
vehicleMakeList.Reverse();
}
if (pageParameters.PageSize != 0)
{
int?skipAmount;
if (pageParameters.Page == 0 || pageParameters.Page == null)
{
skipAmount = 0;
}
else
{
skipAmount = (pageParameters.PageSize * (pageParameters.Page - 1));
}
var totalNumberOfRecords = vehicleMakeList.Count();
vehicleMakeList = vehicleMakeList.Skip((int)skipAmount).Take(pageParameters.PageSize).AsQueryable();
var mod = totalNumberOfRecords % pageParameters.PageSize;
var totalPageCount = (totalNumberOfRecords / pageParameters.PageSize) + (mod == 0 ? 0 : 1);
var Results = AutoMapper.Mapper.Map <IEnumerable <IVehicleMake> >(vehicleMakeList.ToList());
PagedVehicleMake.PageNumber = (int)pageParameters.Page;
PagedVehicleMake.PageSize = pageParameters.PageSize;
PagedVehicleMake.TotalNumberOfPages = totalPageCount;
if (sortParameters.SortDirection != null)
{
if (sortParameters.SortDirection.ToUpper() == "DESCENDING")
{
Results = Results.Reverse();
}
}
PagedVehicleMake.Results = Results;
}
else
{
PagedVehicleMake.PageNumber = 0;
PagedVehicleMake.PageSize = 0;
PagedVehicleMake.TotalNumberOfPages = 0;
PagedVehicleMake.Results = AutoMapper.Mapper.Map <IEnumerable <IVehicleMake> >(vehicleMakeList.ToList());
}
return(PagedVehicleMake);
}
public PagedFactory(IPageParameters pageParameters)
{
_interceptor = new PagedProxy(pageParameters);
}
