public async Task <IPagedResults <TModel> > SelectAsync(IDbDataParameter[] dbParams)
{
IPagedResults <TModel> output = null;
using (var context = _dbContext)
{
output = await context.ExecuteReaderAsync <IPagedResults <TModel> >(
CommandType.StoredProcedure,
"SelectTagsPaged",
async reader =>
{
if ((reader != null) && (reader.HasRows))
{
output = new PagedResults <TModel>();
while (await reader.ReadAsync())
{
var tag = ActivateInstanceOf <TModel> .Instance();
tag.PopulateModel(reader);
output.Data.Add(tag);
}
if (await reader.NextResultAsync())
{
await reader.ReadAsync();
output.PopulateTotal(reader);
}
}
return(output);
},
dbParams);
}
return(output);
}
public async Task <IPagedResults <Models.Media> > SelectAsync(IDbDataParameter[] dbParams)
{
IPagedResults <Models.Media> output = null;
using (var context = _dbContext)
{
output = await context.ExecuteReaderAsync <IPagedResults <Models.Media> >(
CommandType.StoredProcedure,
"SelectMediaPaged",
async reader =>
{
if ((reader != null) && (reader.HasRows))
{
output = new PagedResults <Models.Media>();
while (await reader.ReadAsync())
{
var entity = new Models.Media();
entity.PopulateModel(reader);
output.Data.Add(entity);
}
if (await reader.NextResultAsync())
{
await reader.ReadAsync();
output.PopulateTotal(reader);
}
}
return(output);
},
dbParams);
}
return(output);
}
public async Task <IPagedResults <User> > SelectAsync(IDbDataParameter[] dbParams)
{
IPagedResults <User> results = null;
using (var context = _dbContext)
{
results = await context.ExecuteReaderAsync <IPagedResults <User> >(
CommandType.StoredProcedure,
"SelectUsersPaged",
async reader =>
{
if ((reader != null) && (reader.HasRows))
{
var output = new PagedResults <User>();
while (await reader.ReadAsync())
{
var user = new User();
user.PopulateModel(reader);
output.Data.Add(user);
}
if (await reader.NextResultAsync())
{
if (reader.HasRows)
{
await reader.ReadAsync();
output.PopulateTotal(reader);
}
}
return(output);
}
return(null);
},
dbParams);
}
return(results);
}
public async Task <IPagedResults <TModel> > SelectAsync(IDbDataParameter[] dbParams)
{
PagedResults <TModel> results = null;
using (var context = _dbContext)
{
results = await context.ExecuteReaderAsync(
CommandType.StoredProcedure,
"SelectEntityRepliesPaged",
async reader =>
{
if ((reader != null) && (reader.HasRows))
{
var output = new PagedResults <TModel>();
while (await reader.ReadAsync())
{
var reply = ActivateInstanceOf <TModel> .Instance();
reply.PopulateModel(reader);
output.Data.Add(reply);
}
if (await reader.NextResultAsync())
{
if (reader.HasRows)
{
await reader.ReadAsync();
output.PopulateTotal(reader);
}
}
return(output);
}
return(null);
},
dbParams);
}
return(results);
}
public async Task<IPagedResults<EntityMetric>> SelectAsync(IDbDataParameter[] dbParams)
{
IPagedResults<EntityMetric> output = null;
using (var context = _dbContext)
{
output = await context.ExecuteReaderAsync<IPagedResults<EntityMetric>>(
CommandType.StoredProcedure,
"SelectEntityMetricsPaged",
async reader =>
{
if ((reader != null) && (reader.HasRows))
{
output = new PagedResults<EntityMetric>();
while (await reader.ReadAsync())
{
var metric = new EntityMetric();
metric.PopulateModel(reader);
output.Data.Add(metric);
}
if (await reader.NextResultAsync())
{
if (reader.HasRows)
{
await reader.ReadAsync();
output.PopulateTotal(reader);
}
}
}
return output;
},
dbParams);
}
return output;
}
public async Task <IPagedResults <Role> > SelectAsync(IDbDataParameter[] dbParams)
{
IPagedResults <Role> output = null;
using (var context = _dbContext)
{
output = await context.ExecuteReaderAsync(
CommandType.StoredProcedure,
"SelectRolesPaged",
async reader =>
{
if ((reader != null) && (reader.HasRows))
{
output = new PagedResults <Role>();
while (await reader.ReadAsync())
{
var role = new Role();
role.PopulateModel(reader);
output.Data.Add(role);
}
if (await reader.NextResultAsync())
{
if (reader.HasRows)
{
await reader.ReadAsync();
output.PopulateTotal(reader);
}
}
}
return(output);
},
dbParams);
}
return(output);
}
public async Task <IPagedResults <FeatureEntityCount> > SelectAsync(IDbDataParameter[] dbParams)
{
IPagedResults <FeatureEntityCount> results = null;
using (var context = _dbContext)
{
results = await context.ExecuteReaderAsync(
CommandType.StoredProcedure,
"SelectEntitiesPaged",
async reader =>
{
if ((reader != null) && (reader.HasRows))
{
var output = new PagedResults <FeatureEntityCount>();
while (await reader.ReadAsync())
{
var entity = new FeatureEntityCount();
entity.PopulateModel(reader);
output.Data.Add(entity);
}
if (await reader.NextResultAsync())
{
await reader.ReadAsync();
output.PopulateTotal(reader);
}
return(output);
}
return(null);
},
dbParams);
}
return(results);
}
