public async Task <PaginatedPlainModel <Shareholder> > GetAll(int startIndex, int pageSize, ShareholderFilter shareholderFilter = null)
{
var filteredShareholders = SearchByFilters(shareholderFilter, context.Shareholders.Include(c => c.Company).Include(c => c.Person).AsQueryable());
var shareholders = await PaginatedPlainModel <Shareholder> .Paginate(filteredShareholders, startIndex, pageSize);
return(shareholders);
}
public async Task <PaginatedPlainModel <Person> > GetAll(int startIndex, int pageSize, PersonFilter personFilter)
{
var filteredPersons = SearchByFilters(personFilter, context.Persons.Include(p => p.ApplicationUser).AsQueryable());
var persons = await PaginatedPlainModel <Person> .Paginate(filteredPersons, startIndex, pageSize);
return(persons);
}
public async Task <PaginatedPlainModel <Person> > GetAll(int startIndex, int pageSize, PersonFilter personFilter = null)
{
var filteredPersons = SearchByFilters(personFilter, container.Persons.AsQueryable());
var persons = await PaginatedPlainModel <Person> .Paginate(filteredPersons, startIndex, pageSize);
return(await Task.FromResult(persons).ConfigureAwait(false));
}
public async Task <PaginatedPlainModel <Shareholder> > GetAll(int startIndex, int pageSize, ShareholderFilter shareholderFilter = null)
{
var filteredShareholders = SearchByFilters(shareholderFilter, container.Shareholders.AsQueryable());
var shareholders = await PaginatedPlainModel <Shareholder> .Paginate(filteredShareholders, startIndex, pageSize);
return(await Task.FromResult(shareholders).ConfigureAwait(false));
}
public override async Task <PaginatedPlainModel <Account> > GetAll(int startIndex, int pageSize)
{
try
{
var accounts = await PaginatedPlainModel <Account> .Paginate(context.Accounts.Include(p => p.Transactions), startIndex, pageSize);
return(accounts);
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <PaginatedModel <PersonDTO> > GetAllPersons(int pageNumber, int pageSize, PersonFilterModel personFilter = null)
{
PaginatedPlainModel <Person> persons = null;
if (personFilter != null)
{
var filter = PersonFilterDtoToPerson.Instance.Map(personFilter);
persons = await unitOfWork.PersonRepository.GetAll(pageNumber, pageSize, filter);
}
else
{
persons = await unitOfWork.PersonRepository.GetAll(pageNumber, pageSize);
}
//TODo smt better here
return(new PaginatedModel <PersonDTO>(persons.Select(p => PersonEntityToDtoMapper.Instance.Map(p)), persons.PageNumber, persons.PageSize, persons.TotalCount, persons.TotalPages));
}
public async Task <PaginatedModel <ShareholderDTO> > GetAllShareholders(int pageNumber, int pageSize, ShareholderFilterModel shareholderFilterModel = null)
{
PaginatedPlainModel <Shareholder> shareholders = null;
if (shareholderFilterModel != null)
{
var filter = ShareholderFilterDtoToShareholder.Instance.Map(shareholderFilterModel);
shareholders = await unitOfWork.ShareholderRepository.GetAll(pageNumber, pageSize, filter);
}
else
{
shareholders = await unitOfWork.ShareholderRepository.GetAll(pageNumber, pageSize);
}
//TODO smt better
return(new PaginatedModel <ShareholderDTO>(shareholders.Select(shareholder => ShareholderEntityToDtoMapper.Instance.Map(shareholder)), shareholders.PageNumber, shareholders.PageSize, shareholders.TotalCount, shareholders.TotalPages));
}
public override async Task <PaginatedPlainModel <Shareholder> > GetAll(int startIndex, int pageSize)
{
var shareholders = await PaginatedPlainModel <Shareholder> .Paginate(context.Shareholders.Include(c => c.Company).Include(e => e.Person), startIndex, pageSize);
return(shareholders);
}
public async Task <PaginatedPlainModel <Account> > GetAll(int startIndex, int pageSize)
{
var accounts = await PaginatedPlainModel <Account> .Paginate(container.Accounts.AsQueryable(), startIndex, pageSize);
return(await Task.FromResult(accounts).ConfigureAwait(false));
}
public virtual async Task <PaginatedPlainModel <TEntity> > GetAll(int startIndex, int pageSize)
{
return(await PaginatedPlainModel <TEntity> .Paginate(DBSet.AsTracking(), startIndex, pageSize));
}
public async Task <PaginatedPlainModel <Transaction> > GetAll(int startIndex, int pageSize)
{
var transactions = await PaginatedPlainModel <Transaction> .Paginate(container.Transactions.AsQueryable(), startIndex, pageSize);
return(await Task.FromResult(transactions).ConfigureAwait(false));
}
public override async Task <PaginatedPlainModel <Person> > GetAll(int startIndex, int pageSize)
{
var persons = await PaginatedPlainModel <Person> .Paginate(context.Persons.Include(p => p.ApplicationUser), startIndex, pageSize);
return(persons);
}
public async Task <PaginatedPlainModel <Company> > GetAll(int startIndex, int pageSize)
{
var comapnies = await PaginatedPlainModel <Company> .Paginate(container.Companies.AsQueryable(), startIndex, pageSize);
return(await Task.FromResult(comapnies).ConfigureAwait(false));
}
public async Task <PaginatedPlainModel <Shareholder> > GetAll(int startIndex, int pageSize)
{
var shareholders = await PaginatedPlainModel <Shareholder> .Paginate(container.Shareholders.AsQueryable(), startIndex, pageSize);
return(await Task.FromResult(shareholders).ConfigureAwait(false));
}
public override async Task <PaginatedPlainModel <Transaction> > GetAll(int startIndex, int pageSize)
{
var transactions = await PaginatedPlainModel <Transaction> .Paginate(context.Transactions.Include(p => p.SourceAccount), startIndex, pageSize);
return(transactions);
}
