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); }