public void SelectRoleByIdGeneratesCorrectQuery()
{
var generatedQuery = _queryFactory.GetQuery <SelectRoleByIdQuery>();
const string expected = "SELECT * FROM `identity`.`identityrole` WHERE `Id` = @Id";
Assert.Equal(expected, generatedQuery);
}
public void SelectRoleByIdGeneratesCorrectQuery()
{
var generatedQuery = _queryFactory.GetQuery <SelectRoleByIdQuery>();
var expected = "SELECT * FROM \"dbo\".\"IdentityRole\" WHERE \"Id\" = @Id";
Assert.Equal(expected, generatedQuery);
}
public void SelectRoleByIdGeneratesCorrectQuery()
{
var generatedQuery = _queryFactory.GetQuery <SelectRoleByIdQuery>();
const string expected = "SELECT * FROM [dbo].[IdentityRole] WHERE [Id] = @Id";
Assert.Equal(expected, generatedQuery);
}
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 <Form> InsertAsync(Form form)
{
using (var connection = GetConnection())
{
await connection.QueryAsync(_queryFactory.GetQuery(QueryType.Insert), Form.New(form));
return(form);
}
}
public async Task <ProfileForm> InsertAsync(ProfileForm profileForm)
{
using (var connection = GetConnection())
{
await connection.QueryAsync(_queryFactory.GetQuery(QueryType.Insert), ProfileForm.New(profileForm));
return(profileForm);
}
}
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 <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 <IdentityUser> GetByEmailAsync(string email)
{
try
{
var selectFunction = new Func <DbConnection, Task <IdentityUser> >(async x =>
{
var dynamicParameters = new DynamicParameters();
dynamicParameters.Add("Email", email);
var query = _queryFactory.GetQuery <SelectUserByEmailQuery>();
var userDictionary = new Dictionary <string, IdentityUser>();
var result = await x.QueryAsync <IdentityUser, IdentityUserRole, IdentityUser>(sql: query,
param: dynamicParameters,
transaction: _unitOfWork.Transaction,
map: UserRoleMapping(userDictionary) /*,
* splitOn: "Id"*/);
if (userDictionary.Count > 0)
{
return(userDictionary.FirstOrDefault().Value);
}
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 StartAsync(CancellationToken cancellationToken)
{
await _contextInitializer.InitializeAsync(cancellationToken);
var maria = await _queryFactory
.GetQuery <MariaDbEntity>()
.AllAsync(cancellationToken);
var sqlite = await _queryFactory
.GetQuery <SqliteEntity>()
.AllAsync(cancellationToken);
var psql = await _queryFactory
.GetQuery <PsqlEntity>()
.AllAsync(cancellationToken);
}
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 <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 <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 <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 <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 static ReadOnlyCollection <FolderItem> GetFiles(this IQueryFactory <FolderItem> queryFactory, string path)
{
var folderItems = queryFactory
.GetQuery(new FolderItemsQueryCriteria()
{
Path = path
})
.Execute();
return(new ReadOnlyCollection <FolderItem>(folderItems.ToList()));
}
public static ReadOnlyCollection <Folder> GetRecentFolders(this IQueryFactory <Folder> queryFactory, int?top = null, bool?includeSpecial = null)
{
var recentFolders = queryFactory
.GetQuery(new RecentFoldersQueryCriteria()
{
Top = top, IncludeSpecial = includeSpecial
})
.Execute();
return(new ReadOnlyCollection <Folder>(recentFolders.ToList()));
}
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 <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 <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 <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 <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 <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 <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);
}
}
private IQuery <TEntity, IExpressionSpecification <TEntity> > GetBaseQuery()
{
var query = QueryFactory
.GetQuery <TEntity>()
.Where(BaseWhere);
if (Include != null)
{
foreach (var expression in Include)
{
query = query.Include(expression);
}
}
return(query);
}