public async Task <IEnumerable <T> > GetAsync <T>(string procedureName, object parameters,
RnDCommandType operationType, Enum product)
{
try
{
return(await WithConnection(async c =>
{
// map the result from stored procedure to Employee data model
if (operationType == RnDCommandType.StoredProcedure)
{
var results = await c.QueryAsync <T>(procedureName, parameters,
commandType: CommandType.StoredProcedure);
return results;
}
else
{
var results = await c.QueryAsync <T>(procedureName, parameters, commandType: CommandType.Text);
return results;
}
}, product));
}
catch (Exception ex)
{
_logger.Error(ex.Message + "------" + ex.StackTrace);
throw;
}
}
private async Task DapperMultiMapper <T>(string procedureName, Type[] types, Func <object[], T> map, object parameters,
RnDCommandType operationType, string splitOn, Enum product)
{
try
{
await WithConnection(async c =>
{
// map the result from stored procedure to Employee data model
if (operationType == RnDCommandType.StoredProcedure)
{
var results = await c.QueryAsync(procedureName, types, map, parameters,
commandType: CommandType.StoredProcedure, splitOn: splitOn);
return(results);
}
else
{
var results = await c.QueryAsync(procedureName, types, map, parameters, commandType: CommandType.Text, splitOn: splitOn);
return(results);
}
}, product);
}
catch (Exception ex)
{
_logger.Error(ex.Message + "------" + ex.StackTrace);
throw;
}
}
public async Task GetComplexDataUsingMapAsync <T>(string query, object parameters,
RnDCommandType operationType, string breakOn, Type[] types, Func <object[], T> map, Enum product)
{
try
{
await DapperMultiMapper(query, types, map, parameters, RnDCommandType.Text, breakOn, product);
}
catch (Exception ex)
{
_logger.Error(ex.Message + "------" + ex.StackTrace);
throw;
}
}
// This should be used when we dont have any data to return from query
public async Task <int> ExecuteAsync(string procedureName, object parameters, RnDCommandType operationType,
Enum product)
{
try
{
return(await WithConnection(async c =>
{
if (operationType == RnDCommandType.StoredProcedure)
{
var results = await c.ExecuteAsync(procedureName, parameters,
commandType: CommandType.StoredProcedure);
return results;
}
else
{
var results = await c.ExecuteAsync(procedureName, parameters, commandType: CommandType.Text);
return results;
}
}, product));
}
catch (Exception ex)
{
_logger.Error(ex.Message + "------" + ex.StackTrace);
throw;
}
}
//This method the order of select clauses in proc and the entity should be same
public async Task <T> GetMultipleDataAsync <T>(string query, object parameters, RnDCommandType operationType,
Enum product)
where T : class
{
var returnResult = Activator.CreateInstance(typeof(T));
return(await WithConnection(async con =>
{
SqlMapper.GridReader data;
if (operationType == RnDCommandType.StoredProcedure)
{
data = await con.QueryMultipleAsync(query, parameters, commandType: CommandType.StoredProcedure);
}
else
{
data = await con.QueryMultipleAsync(query, parameters, commandType: CommandType.Text);
}
foreach (var eachProperty in typeof(T).GetProperties())
{
var attribute = eachProperty.GetCustomAttributes(typeof(DescriptionAttribute), true)
.FirstOrDefault();
if (attribute != null && ((DescriptionAttribute)attribute).Description == "ignoreMapping")
{
continue;
}
var type = eachProperty.PropertyType;
var isListType = false;
if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(List <>))
{
type = type.GetGenericArguments()[0];
isListType = true;
}
var resultData = data.Read(type).ToList();
try
{
if (resultData.Any())
{
eachProperty.SetValue(returnResult,
isListType ? ConvertList(resultData, eachProperty.PropertyType) : resultData[0],
null);
}
}
catch (Exception ex)
{
_logger.Error(ex.Message + "------" + ex.StackTrace);
}
}
return (T)returnResult;
}, product));
}
