public async Task <TRole> GetById(TKey id)
{
try
{
using (var conn = _connectionProvider.Create())
{
await conn.OpenAsync();
var dynamicParameters = new DynamicParameters();
dynamicParameters.Add("Id", id);
var query = _sqlConfiguration.SelectRoleByIdQuery
.ReplaceQueryParameters(_sqlConfiguration.SchemaName,
_sqlConfiguration.RoleTable,
_sqlConfiguration.ParameterNotation,
new string[] { "%ID%" },
new string[] { "Id" });
return(await conn.QueryFirstOrDefaultAsync <TRole>(sql : query,
param : dynamicParameters));
}
}
catch (Exception ex)
{
_log.LogError(ex.Message, ex);
return(null);
}
}
public async Task <bool> MarkCallDispatchesAsSentByCallIdUsersAsync(int callId, List <Guid> usersToMark)
{
try
{
var userIds = new StringBuilder();
foreach (var userId in usersToMark)
{
if (userIds.Length == 0)
{
userIds.Append($"|{userId}|");
}
else
{
userIds.Append($"{userId}|");
}
}
var selectFunction = new Func <DbConnection, Task <bool> >(async x =>
{
var dynamicParameters = new DynamicParameters();
dynamicParameters.Add("CallId", callId);
dynamicParameters.Add("UserIds", userIds.ToString());
var query = _queryFactory.GetQuery <UpdateUserDispatchesAsSentQuery>();
var result = await x.QueryAsync <Call>(sql: query,
param: dynamicParameters,
transaction: _unitOfWork.Transaction);
return(true);
});
DbConnection conn = null;
if (_unitOfWork?.Connection == null)
{
using (conn = _connectionProvider.Create())
{
await conn.OpenAsync();
return(await selectFunction(conn));
}
}
else
{
conn = _unitOfWork.CreateOrGetConnection();
return(await selectFunction(conn));
}
}
catch (Exception ex)
{
Logging.LogException(ex);
throw;
}
}
public async Task <IEnumerable <ShiftGroup> > GetShiftGroupsByGroupIdAsync(int departmentGroupId)
{
try
{
var selectFunction = new Func <DbConnection, Task <IEnumerable <ShiftGroup> > >(async x =>
{
var dynamicParameters = new DynamicParameters();
dynamicParameters.Add("GroupId", departmentGroupId);
var query = _queryFactory.GetQuery <SelectShiftGroupByGroupQuery>();
var dictionary = new Dictionary <int, ShiftGroup>();
var result = await x.QueryAsync <ShiftGroup, ShiftGroupRole, ShiftGroup>(sql: query,
param: dynamicParameters,
transaction: _unitOfWork.Transaction,
map: ShiftGroupMapping(dictionary),
splitOn: "ShiftGroupRoleId");
List <ShiftGroup> shiftGroups = null;
if (dictionary.Count > 0)
{
shiftGroups = dictionary.Select(y => y.Value).ToList();
}
else
{
shiftGroups = result.ToList();
}
return(shiftGroups.AsEnumerable());
});
DbConnection conn = null;
if (_unitOfWork?.Connection == null)
{
using (conn = _connectionProvider.Create())
{
await conn.OpenAsync();
return(await selectFunction(conn));
}
}
else
{
conn = _unitOfWork.CreateOrGetConnection();
return(await selectFunction(conn));
}
}
catch (Exception ex)
{
Logging.LogException(ex);
return(null);
}
}
public async Task <int> CreateUnitOfferingAsync(UnitOffering model)
{
try
{
using (var connection = _connectionProvider.Create())
{
return(await connection.ExecuteScalarAsync <int>("DBIG5_ADMIN.ADD_UNITOFFERING_VIASQLDEV",
new
{
pUNIT_ID = model.Unit_ID,
pSTUDYPERIOD_ID = model.StudyPeriod_ID,
pId = model.Id,
pUNITOFFERING_STARTDATE = model.UnitOffering_StartDate
},
commandType : CommandType.StoredProcedure));
}
}
catch (Exception ex)
{
_transaction.DiscardChanges();
Console.WriteLine(ex);
}
//Return failed to insert
return(0);
}
public async Task <ShiftSignupTrade> GetShiftSignupTradeBySourceShiftSignupIdAsync(int shiftSignupId)
{
try
{
var selectFunction = new Func <DbConnection, Task <ShiftSignupTrade> >(async x =>
{
var dynamicParameters = new DynamicParameters();
dynamicParameters.Add("ShiftSignupId", shiftSignupId);
var query = _queryFactory.GetQuery <SelectShiftSignupTradeBySourceIdQuery>();
var dictionary = new Dictionary <int, ShiftSignupTrade>();
var result = await x.QueryAsync <ShiftSignupTrade, ShiftSignupTradeUser, ShiftSignupTrade>(sql: query,
param: dynamicParameters,
transaction: _unitOfWork.Transaction,
map: ShiftSignupTradeMapping(dictionary),
splitOn: "ShiftSignupTradeUserId");
if (dictionary.Count > 0)
{
return(dictionary.Select(y => y.Value).FirstOrDefault());
}
return(result.FirstOrDefault());
});
DbConnection conn = null;
if (_unitOfWork?.Connection == null)
{
using (conn = _connectionProvider.Create())
{
await conn.OpenAsync();
return(await selectFunction(conn));
}
}
else
{
conn = _unitOfWork.CreateOrGetConnection();
return(await selectFunction(conn));
}
}
catch (Exception ex)
{
Logging.LogException(ex);
return(null);
}
}
public async Task <DispatchProtocol> GetDispatchProtocolByIdAsync(int protocolId)
{
try
{
var selectFunction = new Func <DbConnection, Task <DispatchProtocol> >(async x =>
{
var dynamicParameters = new DynamicParameters();
dynamicParameters.Add("ProtocolId", protocolId);
var query = _queryFactory.GetQuery <SelectProtocolByIdQuery>();
var dictionary = new Dictionary <int, DispatchProtocol>();
var result = await x.QueryAsync <DispatchProtocol, DispatchProtocolTrigger, DispatchProtocol>(sql: query,
param: dynamicParameters,
transaction: _unitOfWork.Transaction,
map: DispatchProtocolTriggerMapping(dictionary),
splitOn: "DispatchProtocolTriggerId");
if (dictionary.Count > 0)
{
return(dictionary.Select(y => y.Value).FirstOrDefault());
}
return(result.FirstOrDefault());
});
DbConnection conn = null;
if (_unitOfWork?.Connection == null)
{
using (conn = _connectionProvider.Create())
{
await conn.OpenAsync();
return(await selectFunction(conn));
}
}
else
{
conn = _unitOfWork.CreateOrGetConnection();
return(await selectFunction(conn));
}
}
catch (Exception ex)
{
Logging.LogException(ex);
return(null);
}
}
public async Task <IEnumerable <CustomState> > GetCustomStatesByDepartmentIdAsync(int departmentId)
{
try
{
var selectFunction = new Func <DbConnection, Task <IEnumerable <CustomState> > >(async x =>
{
var dynamicParameters = new DynamicParameters();
dynamicParameters.Add("DepartmentId", departmentId);
var query = _queryFactory.GetQuery <SelectStatesByDidUserQuery>();
var dictionary = new Dictionary <int, CustomState>();
var result = await x.QueryAsync <CustomState, CustomStateDetail, CustomState>(sql: query,
param: dynamicParameters,
transaction: _unitOfWork.Transaction,
map: CustomStateDetailMapping(dictionary),
splitOn: "CustomStateDetailId");
if (dictionary.Count > 0)
{
return(dictionary.Select(y => y.Value));
}
return(result);
});
DbConnection conn = null;
if (_unitOfWork?.Connection == null)
{
using (conn = _connectionProvider.Create())
{
await conn.OpenAsync();
return(await selectFunction(conn));
}
}
else
{
conn = _unitOfWork.CreateOrGetConnection();
return(await selectFunction(conn));
}
}
catch (Exception ex)
{
Logging.LogException(ex);
return(null);
}
}
public async Task <IEnumerable <UserViewModel> > GetEmployeesAsync()
{
try
{
using (var connection = _connectionProvider.Create())
{
return(await connection.QueryAsync <UserViewModel>("dbig5_admin.READ_EMPLOYEE_LIST_VIASQLDEV", commandType : CommandType.StoredProcedure));
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
return(null);
}
public async Task <IEnumerable <Report_Project> > GetProjectsAsync(int?id)
{
try
{
using (var connection = _connectionProvider.Create())
{
return(await connection.QueryAsync <Report_Project>(
"dbig5_admin.REPORT_PROJECT_LIST_VIASQLDEV", new { pUnitID = id }, commandType : CommandType.StoredProcedure));
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
return(null);
}
//param @Context.Session.GetInt32("SELECTED_UNIT")
public async Task <IEnumerable <FormOfferingViewModel> > GetFormOfferingsAsync(int?id)
{
try
{
using (var connection = _connectionProvider.Create())
{
return(await connection.QueryAsync <FormOfferingViewModel>("dbig5_admin.READ_FORMOFFERING_LIST_VIASQLDEV",
new { pUNITOFFERING_ID = id },
commandType : CommandType.StoredProcedure));
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
return(null);
}
public async Task <int> CreateStudyPeriodAsync(StudyPeriod model)
{
try
{
using (var connection = _connectionProvider.Create())
{
return(await connection.ExecuteScalarAsync <int>("DBIG5_ADMIN.ADD_STUDYPERIOD_VIASQLDEV",
new { pSTUDYPERIOD_NAME = model.StudyPeriod_Name },
commandType : CommandType.StoredProcedure));
}
}
catch (Exception ex)
{
_transaction.DiscardChanges();
Console.WriteLine(ex);
return(0);
}
}
/*
*
*
* public async Task<IEnumerable<int>> GetRolesForUserAsync(int userID)
* {
* try
* {
* using (var connection = _connectionProvider.Create())
* {
* return await connection.QueryAsync<int>("dbig5_admin.READ_ROLES_FOR_USER_VIASQLDEV", new { pUserID = userID }, commandType: CommandType.StoredProcedure);
* }
* }
* catch (Exception ex)
* {
* Console.WriteLine(ex);
* }
* return null;
* }
*/
public async Task <int> CreateFormCategoryAsync(FormCategoryViewModel model)
{
try
{
using (var connection = _connectionProvider.Create())
{
return(await connection.QuerySingleAsync <int>("dbig5_admin.ADD_CATEGORY_VIASQLDEV", new
{
pCATEGORY_TYPE = model.Category_Type
}, commandType : CommandType.StoredProcedure));
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
// Return "Fail to Insert"
return(0);
}
public async Task <DepartmentSetting> GetDepartmentSettingByUserIdTypeAsync(string userId, DepartmentSettingTypes type)
{
try
{
var selectFunction = new Func <DbConnection, Task <DepartmentSetting> >(async x =>
{
var dynamicParameters = new DynamicParameters();
dynamicParameters.Add("UserId", userId);
dynamicParameters.Add("SettingType", (int)type);
var query = _queryFactory.GetQuery <SelectBySettingTypeUserIdQuery>();
return(await x.QueryFirstOrDefaultAsync <DepartmentSetting>(sql: query,
param: dynamicParameters,
transaction: _unitOfWork.Transaction));
});
DbConnection conn = null;
if (_unitOfWork?.Connection == null)
{
using (conn = _connectionProvider.Create())
{
await conn.OpenAsync();
return(await selectFunction(conn));
}
}
else
{
conn = _unitOfWork.CreateOrGetConnection();
return(await selectFunction(conn));
}
}
catch (Exception ex)
{
Logging.LogException(ex);
throw;
}
return(null);
}
public async Task <IEnumerable <Call> > GetAllCallsByDepartmentDateRangeAsync(int departmentId, DateTime startDate, DateTime endDate)
{
try
{
var selectFunction = new Func <DbConnection, Task <IEnumerable <Call> > >(async x =>
{
var dynamicParameters = new DynamicParameters();
dynamicParameters.Add("DepartmentId", departmentId);
dynamicParameters.Add("StartDate", startDate);
dynamicParameters.Add("EndDate", endDate);
var query = _queryFactory.GetQuery <SelectAllCallsByDidDateQuery>();
return(await x.QueryAsync <Call>(sql: query,
param: dynamicParameters,
transaction: _unitOfWork.Transaction));
});
DbConnection conn = null;
if (_unitOfWork?.Connection == null)
{
using (conn = _connectionProvider.Create())
{
await conn.OpenAsync();
return(await selectFunction(conn));
}
}
else
{
conn = _unitOfWork.CreateOrGetConnection();
return(await selectFunction(conn));
}
}
catch (Exception ex)
{
Logging.LogException(ex);
throw;
}
}
public async Task <IEnumerable <DepartmentMember> > GetAllDepartmentMembersWithinLimitsAsync(int departmentId)
{
try
{
var selectFunction = new Func <DbConnection, Task <IEnumerable <DepartmentMember> > >(async x =>
{
var dynamicParameters = new DynamicParameters();
dynamicParameters.Add("DepartmentId", departmentId);
var query = _queryFactory.GetQuery <SelectMembersWithinLimitsQuery>();
return(await x.QueryAsync <DepartmentMember, IdentityUser, DepartmentMember>(sql: query,
param: dynamicParameters,
transaction: _unitOfWork.Transaction,
map: (up, u) => { up.User = u; return up; } /*,
* splitOn: "Id"*/));
});
DbConnection conn = null;
if (_unitOfWork?.Connection == null)
{
using (conn = _connectionProvider.Create())
{
await conn.OpenAsync();
return(await selectFunction(conn));
}
}
else
{
conn = _unitOfWork.CreateOrGetConnection();
return(await selectFunction(conn));
}
}
catch (Exception ex)
{
Logging.LogException(ex);
throw;
}
}
public async Task <int> GetUnreadMessageCountAsync(string userId)
{
try
{
var selectFunction = new Func <DbConnection, Task <int> >(async x =>
{
var dynamicParameters = new DynamicParameters();
dynamicParameters.Add("UserId", userId);
var query = _queryFactory.GetQuery <SelectUnreadMessageCountQuery>();
var result = await x.QueryFirstOrDefaultAsync <int>(sql: query,
param: dynamicParameters,
transaction: _unitOfWork.Transaction);
return(result);
});
DbConnection conn = null;
if (_unitOfWork?.Connection == null)
{
using (conn = _connectionProvider.Create())
{
await conn.OpenAsync();
return(await selectFunction(conn));
}
}
else
{
conn = _unitOfWork.CreateOrGetConnection();
return(await selectFunction(conn));
}
}
catch (Exception ex)
{
Logging.LogException(ex);
return(0);
}
}
public async Task <IEnumerable <ActionLog> > GetLastActionLogsForDepartmentAsync(int departmentId, bool disableAutoAvailable, DateTime timeStamp)
{
try
{
var latestTimestamp = DateTime.UtcNow.AddYears(-1);
var selectFunction = new Func <DbConnection, Task <IEnumerable <ActionLog> > >(async x =>
{
var dynamicParameters = new DynamicParameters();
dynamicParameters.Add("DepartmentId", departmentId);
dynamicParameters.Add("DisableAutoAvailable", disableAutoAvailable);
dynamicParameters.Add("Timestamp", timeStamp);
dynamicParameters.Add("LatestTimestamp", latestTimestamp);
var query = _queryFactory.GetQuery <SelectLastActionLogsForDepartmentQuery>();
return(await x.QueryAsync <ActionLog, IdentityUser, ActionLog>(sql: query,
param: dynamicParameters,
transaction: _unitOfWork.Transaction,
map: (up, u) => { up.User = u; return up; },
splitOn: "Id"));
});
DbConnection conn = null;
if (_unitOfWork?.Connection == null)
{
using (conn = _connectionProvider.Create())
{
await conn.OpenAsync();
return(await selectFunction(conn));
}
}
else
{
conn = _unitOfWork.CreateOrGetConnection();
return(await selectFunction(conn));
}
}
catch (Exception ex)
{
Logging.LogException(ex);
throw;
}
}
public async Task <IEnumerable <PersonnelRoleUser> > GetAllRoleUsersForUserAsync(int departmentId, string userId)
{
try
{
var selectFunction = new Func <DbConnection, Task <IEnumerable <PersonnelRoleUser> > >(async x =>
{
var dynamicParameters = new DynamicParameters();
dynamicParameters.Add("DepartmentId", departmentId);
dynamicParameters.Add("UserId", userId);
var query = _queryFactory.GetQuery <SelectRoleUsersByUserQuery>();
return(await x.QueryAsync <PersonnelRoleUser>(sql: query,
param: dynamicParameters,
transaction: _unitOfWork.Transaction));
});
DbConnection conn = null;
if (_unitOfWork?.Connection == null)
{
using (conn = _connectionProvider.Create())
{
await conn.OpenAsync();
return(await selectFunction(conn));
}
}
else
{
conn = _unitOfWork.CreateOrGetConnection();
return(await selectFunction(conn));
}
}
catch (Exception ex)
{
Logging.LogException(ex);
throw;
}
}
public async Task <MessageRecipient> GetMessageRecipientByMessageAndUserAsync(int messageId, string userId)
{
try
{
var selectFunction = new Func <DbConnection, Task <MessageRecipient> >(async x =>
{
var dynamicParameters = new DynamicParameters();
dynamicParameters.Add("MessageId", messageId);
dynamicParameters.Add("UserId", userId);
var query = _queryFactory.GetQuery <SelectMessageRecpByMessageUsQuery>();
return(await x.QueryFirstOrDefaultAsync <MessageRecipient>(sql: query,
param: dynamicParameters,
transaction: _unitOfWork.Transaction));
});
DbConnection conn = null;
if (_unitOfWork?.Connection == null)
{
using (conn = _connectionProvider.Create())
{
await conn.OpenAsync();
return(await selectFunction(conn));
}
}
else
{
conn = _unitOfWork.CreateOrGetConnection();
return(await selectFunction(conn));
}
}
catch (Exception ex)
{
Logging.LogException(ex);
throw;
}
}
public async Task <IEnumerable <UserState> > GetLatestUserStatesByDepartmentIdAsync(int departmentId)
{
try
{
var selectFunction = new Func <DbConnection, Task <IEnumerable <UserState> > >(async x =>
{
var dynamicParameters = new DynamicParameters();
dynamicParameters.Add("DepartmentId", departmentId);
dynamicParameters.Add("Timestamp", DateTime.UtcNow.AddMonths(-3));
var query = _queryFactory.GetQuery <SelectLatestUserStatesByDidQuery>();
return(await x.QueryAsync <UserState>(sql: query,
param: dynamicParameters,
transaction: _unitOfWork.Transaction));
});
DbConnection conn = null;
if (_unitOfWork?.Connection == null)
{
using (conn = _connectionProvider.Create())
{
await conn.OpenAsync();
return(await selectFunction(conn));
}
}
else
{
conn = _unitOfWork.CreateOrGetConnection();
return(await selectFunction(conn));
}
}
catch (Exception ex)
{
Logging.LogException(ex);
throw;
}
}
public async Task <CallAttachment> GetCallAttachmentByCallIdAndTypeAsync(int callId, CallAttachmentTypes type)
{
try
{
var selectFunction = new Func <DbConnection, Task <CallAttachment> >(async x =>
{
var dynamicParameters = new DynamicParameters();
dynamicParameters.Add("CallId", callId);
dynamicParameters.Add("Type", (int)type);
var query = _queryFactory.GetQuery <SelectCallAttachmentByCallIdTypeQuery>();
return(await x.QueryFirstOrDefaultAsync <CallAttachment>(sql: query,
param: dynamicParameters,
transaction: _unitOfWork.Transaction));
});
DbConnection conn = null;
if (_unitOfWork?.Connection == null)
{
using (conn = _connectionProvider.Create())
{
await conn.OpenAsync();
return(await selectFunction(conn));
}
}
else
{
conn = _unitOfWork.CreateOrGetConnection();
return(await selectFunction(conn));
}
}
catch (Exception ex)
{
Logging.LogException(ex);
throw;
}
}
public async Task <Unit> GetUnitByNameDepartmentIdAsync(int departmentId, string name)
{
try
{
var selectFunction = new Func <DbConnection, Task <Unit> >(async x =>
{
var dynamicParameters = new DynamicParameters();
dynamicParameters.Add("DepartmentId", departmentId);
dynamicParameters.Add("UnitName", name);
var query = _queryFactory.GetQuery <SelectUnitByDIdNameQuery>();
return(await x.QueryFirstOrDefaultAsync <Unit>(sql: query,
param: dynamicParameters,
transaction: _unitOfWork.Transaction));
});
DbConnection conn = null;
if (_unitOfWork?.Connection == null)
{
using (conn = _connectionProvider.Create())
{
await conn.OpenAsync();
return(await selectFunction(conn));
}
}
else
{
conn = _unitOfWork.CreateOrGetConnection();
return(await selectFunction(conn));
}
}
catch (Exception ex)
{
Logging.LogException(ex);
throw;
}
}
public async Task <int> CreateUnitAsync(Unit model)
{
try
{
using (var connection = _connectionProvider.Create())
{
return(await connection.ExecuteScalarAsync <int>("dbig5_admin.ADD_UNIT_VIASQLDEV",
new
{
pUNIT_CODE = model.Unit_Code,
pUNIT_NAME = model.Unit_Name
},
commandType : CommandType.StoredProcedure));
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
return(0);
}
public async Task <IEnumerable <UnitActiveRole> > GetActiveRolesByUnitIdAsync(int unitId)
{
try
{
var selectFunction = new Func <DbConnection, Task <IEnumerable <UnitActiveRole> > >(async x =>
{
var dynamicParameters = new DynamicParameters();
dynamicParameters.Add("UnitId", unitId);
var query = _queryFactory.GetQuery <SelectUnitActiveRolesByUnitIdQuery>();
return(await x.QueryAsync <UnitActiveRole>(sql: query,
param: dynamicParameters,
transaction: _unitOfWork.Transaction));
});
DbConnection conn = null;
if (_unitOfWork?.Connection == null)
{
using (conn = _connectionProvider.Create())
{
await conn.OpenAsync();
return(await selectFunction(conn));
}
}
else
{
conn = _unitOfWork.CreateOrGetConnection();
return(await selectFunction(conn));
}
}
catch (Exception ex)
{
Logging.LogException(ex);
throw;
}
}
public async Task <Invite> GetInviteByCodeAsync(Guid code)
{
try
{
var selectFunction = new Func <DbConnection, Task <Invite> >(async x =>
{
var dynamicParameters = new DynamicParameters();
dynamicParameters.Add("Code", code);
var query = _queryFactory.GetQuery <SelectInviteByCodeQuery>();
return(await x.QueryFirstOrDefaultAsync <Invite>(sql: query,
param: dynamicParameters,
transaction: _unitOfWork.Transaction));
});
DbConnection conn = null;
if (_unitOfWork?.Connection == null)
{
using (conn = _connectionProvider.Create())
{
await conn.OpenAsync();
return(await selectFunction(conn));
}
}
else
{
conn = _unitOfWork.CreateOrGetConnection();
return(await selectFunction(conn));
}
}
catch (Exception ex)
{
Logging.LogException(ex);
throw;
}
}
public async Task <DistributionList> GetDistributionListByEmailAddressAsync(string email)
{
try
{
var selectFunction = new Func <DbConnection, Task <DistributionList> >(async x =>
{
var dynamicParameters = new DynamicParameters();
dynamicParameters.Add("EmailAddress", email);
var query = _queryFactory.GetQuery <SelectDListByEmailQuery>();
return(await x.QueryFirstOrDefaultAsync <DistributionList>(sql: query,
param: dynamicParameters,
transaction: _unitOfWork.Transaction));
});
DbConnection conn = null;
if (_unitOfWork?.Connection == null)
{
using (conn = _connectionProvider.Create())
{
await conn.OpenAsync();
return(await selectFunction(conn));
}
}
else
{
conn = _unitOfWork.CreateOrGetConnection();
return(await selectFunction(conn));
}
}
catch (Exception ex)
{
Logging.LogException(ex);
throw;
}
}
public async Task <TRole> GetById(TKey id)
{
try
{
var selectFunction = new Func <DbConnection, Task <TRole> >(async x =>
{
var dynamicParameters = new DynamicParameters();
dynamicParameters.Add("Id", id);
var query = _queryFactory.GetQuery <SelectRoleByIdQuery>();
return(await x.QueryFirstOrDefaultAsync <TRole>(sql: query,
param: dynamicParameters,
transaction: _unitOfWork.Transaction));
});
DbConnection conn = null;
if (_unitOfWork?.Connection == null)
{
using (conn = _connectionProvider.Create())
{
await conn.OpenAsync();
return(await selectFunction(conn));
}
}
else
{
conn = _unitOfWork.CreateOrGetConnection();
return(await selectFunction(conn));
}
}
catch (Exception ex)
{
_log.LogError(ex, ex.Message);
throw;
}
}
public async Task <int> CreateEnrolmentAsync(Enrolment model)
{
try
{
using (var connection = _connectionProvider.Create())
{
return(await connection.ExecuteScalarAsync <int>("DBIG5_ADMIN.ADD_ENROLMENT_VIASQLDEV",
new
{
pId = model.Student_ID,
pUNITOFFERING_ID = model.UnitOffering_ID
},
commandType : CommandType.StoredProcedure));
}
}
catch (Exception ex)
{
_transaction.DiscardChanges();
Console.WriteLine(ex);
}
//Return failed to insert
return(0);
}
public async Task <IEnumerable <TrainingQuestion> > GetTrainingQuestionsByTrainingIdAsync(int trainingId)
{
try
{
var selectFunction = new Func <DbConnection, Task <IEnumerable <TrainingQuestion> > >(async x =>
{
var dynamicParameters = new DynamicParameters();
dynamicParameters.Add("TrainingId", trainingId);
var query = _queryFactory.GetQuery <SelectTrainingQuestionsByTrainIdQuery>();
var messageDictionary = new Dictionary <int, TrainingQuestion>();
var result = await x.QueryAsync <TrainingQuestion, TrainingQuestionAnswer, TrainingQuestion>(sql: query,
param: dynamicParameters,
transaction: _unitOfWork.Transaction,
map: TrainingQuestionAnswerMapping(messageDictionary),
splitOn: "TrainingQuestionAnswerId");
if (messageDictionary.Count > 0)
{
return(messageDictionary.Select(y => y.Value));
}
return(result);
});
DbConnection conn = null;
if (_unitOfWork?.Connection == null)
{
using (conn = _connectionProvider.Create())
{
await conn.OpenAsync();
return(await selectFunction(conn));
}
}
else
{
conn = _unitOfWork.CreateOrGetConnection();
return(await selectFunction(conn));
}
}
catch (Exception ex)
{
Logging.LogException(ex);
return(null);
}
}
public DbConnection CreateOrGetConnection()
{
_semaphore.Wait();
if (Connection == null)
{
Connection = _connectionProvider.Create();
Connection.Open();
Transaction = Connection.BeginTransaction();
}
_semaphore.Release();
return(Connection);
}
