async Task <TModel> BuildFromResultSets(DbDataReader reader)
{
TModel model = null;
if ((reader != null) && (reader.HasRows))
{
model = ActivateInstanceOf <TModel> .Instance();
await reader.ReadAsync();
model.PopulateModel(reader);
// Data
if (await reader.NextResultAsync())
{
var data = new List <EntityReplyData>();
if (reader.HasRows)
{
while (await reader.ReadAsync())
{
var entityData = new EntityReplyData(reader);
data.Add(entityData);
}
}
model.Data = data;
}
}
return(model);
}
// --------------------------
async Task <IEnumerable <IEntityReplyData> > SerializeMetaDataAsync(TModel entity)
{
// Get all existing entity data
var data = await _entityReplyDataStore.GetByReplyIdAsync(entity.Id);
// Prepare list to search, use dummy list if needed
var dataList = data?.ToList() ?? new List <IEntityReplyData>();
// Iterate all meta data on the supplied type,
// check if a key already exists, if so update existing key
var output = new List <IEntityReplyData>();
foreach (var item in entity.MetaData)
{
var key = item.Key.FullName;
var entityData = dataList.FirstOrDefault(d => d.Key == key);
if (entityData != null)
{
entityData.Value = await item.Value.SerializeAsync();
}
else
{
entityData = new EntityReplyData()
{
Key = key,
Value = item.Value.Serialize()
};
}
output.Add(entityData);
}
return(output);
}
public async Task <IEntityReplyData> SelectByIdAsync(int id)
{
if (_logger.IsEnabled(LogLevel.Information))
{
_logger.LogInformation($"Selecting entity reply data with id: {id}");
}
EntityReplyData data = null;
using (var context = _dbContext)
{
data = await context.ExecuteReaderAsync(
CommandType.StoredProcedure,
"SelectEntityReplyDatumById",
async reader =>
{
if (reader != null)
{
if (reader.HasRows)
{
data = new EntityReplyData();
await reader.ReadAsync();
data.PopulateModel(reader);
}
}
return(data);
}, new IDbDataParameter[]
{
new DbParam("Id", DbType.Int32, id)
});
}
return(data);
}
public async Task <IEnumerable <IEntityReplyData> > SelectByReplyIdAsync(int entityId)
{
IList <EntityReplyData> data = null;
using (var context = _dbContext)
{
data = await context.ExecuteReaderAsync(
CommandType.StoredProcedure,
"SelectEntityReplyDatumByReplyId",
async reader =>
{
if (reader != null)
{
if (reader.HasRows)
{
data = new List <EntityReplyData>();
while (await reader.ReadAsync())
{
var entityData = new EntityReplyData();
entityData.PopulateModel(reader);
data.Add(entityData);
}
}
}
return(data);
}, new IDbDataParameter[]
{
new DbParam("ReplyId", DbType.Int32, entityId)
});
}
return(data);
}
public async Task <IPagedResults <IEntityReplyData> > SelectAsync(IDbDataParameter[] dbParams)
{
IPagedResults <IEntityReplyData> results = null;
using (var context = _dbContext)
{
results = await context.ExecuteReaderAsync <PagedResults <IEntityReplyData> >(
CommandType.StoredProcedure,
"SelectEntityReplyDatumPaged",
async reader =>
{
if ((reader != null) && (reader.HasRows))
{
var output = new PagedResults <IEntityReplyData>();
while (await reader.ReadAsync())
{
var data = new EntityReplyData();
data.PopulateModel(reader);
output.Data.Add(data);
}
if (await reader.NextResultAsync())
{
await reader.ReadAsync();
output.PopulateTotal(reader);
}
return(output);
}
return(null);
},
dbParams);
}
return(results);
}
