public async Task <IEnumerable <object> > DoctorScheduleList(decimal doctorId, bool showRecent, DateTime?start, DateTime?end, int?limit, int?skip) { var query = _context.Reservation .Where(d => d.DoctorId == doctorId) .Where(x => x.Starttime.Date >= start.Value.Date && x.Endtime.Date <= end.Value.Date); query = showRecent ? query.Where(x => x.Visit != null && x.Canceled == false).Where(x => x.Starttime.AddMinutes(-30) < DateTime.Now) : query.Where(x => x.Visit == null).Where(x => x.Starttime.AddMinutes(30) >= DateTime.Now); var anonymousQuery = query.Select(s => new { reservationId = s.Id, reservationStartTime = s.Starttime, reservationEndTime = s.Endtime, isCanceled = s.Canceled, localName = s.Room.Local.Name, roomNumber = s.Room.Number, patientId = s.Patient.Id, patientName = s.Patient.IdNavigation.Name, patientLastname = s.Patient.IdNavigation.Lastname, visit = _context.Visit.FirstOrDefault(y => y.ReservationId == s.Id) }); IOrderedQueryable <object> orderedQuery = showRecent ? anonymousQuery.OrderByDescending(x => x.reservationStartTime) : anonymousQuery.OrderBy(x => x.reservationStartTime); var trimmedQuery = PaginationService <object> .SplitAndLimitQueryable(skip, limit, orderedQuery); return(await trimmedQuery.ToListAsync()); }
public void Refresh(CriteriaType criteriaType, TCriteria criteria) { Busy = true; Guid refreshGuid = Guid.NewGuid(); _refreshGuid = refreshGuid; PaginationService.GetItems(criteriaType, PageSize, criteria, items => { if (_refreshGuid != refreshGuid) { return; } _dispatcher.Invoke(() => { CriteriaType = criteriaType; if (criteriaType == CriteriaType.DownFromInfinity && items.Any()) { Criteria = _getCriteriaFunc(items.First()); } else if (criteriaType == CriteriaType.UpFromInfinity && items.Any()) { Criteria = _getCriteriaFunc(items.Last()); } else { Criteria = criteria; } UpdateItems(items); Busy = false; }); }); }
public void PaginationGettingTotalPagesWorks() { List <Article> data = new List <Article> { new Article { Id = 0, Title = "T0" }, new Article { Id = 1, Title = "T1" }, new Article { Id = 2, Title = "T2" }, new Article { Id = 3, Title = "T3" }, new Article { Id = 4, Title = "T4" }, }; int pageSize = 2; int totalPages = PaginationService.GetTotalPages(data, pageSize); Assert.IsTrue(totalPages == 3); }
public async Task <Pagination <ProductListResponseModel> > GetAllProducts(ProductListRequestModel requestModel) { var parameters = new DynamicParameters(); parameters.Add("@PageSize", requestModel.PageSize); parameters.Add("@Offset", requestModel.Page); await using var connection = _dbConnection.CreateDbConnection(); var products = await connection.QueryMultipleAsync(ProductQuery(requestModel), parameters); var productListResponseModel = new ProductListResponseModel(); var productResult = products.Read <ProductServiceResponseModel, CategoryServiceResponseModel, ProductListResponseModel> ((product, category) => { product.CategoryServiceResponseModel = category; productListResponseModel.ProductServiceResponseModel = product; return(productListResponseModel); } , splitOn: "CategoryId"); var totalItemCount = products.Read <int>().FirstOrDefault(); var productResponse = PaginationService.GetPagination( productResult.AsQueryable(), requestModel.Page.Value, string.Empty, true, requestModel.PageSize.Value); return(productResponse); }
public void PaginationWorks() { List <Article> data = new List <Article> { new Article { Id = 0, Title = "T0" }, new Article { Id = 1, Title = "T1" }, new Article { Id = 2, Title = "T2" }, new Article { Id = 3, Title = "T3" }, new Article { Id = 4, Title = "T4" }, }; int pageSize = 2; var res0 = PaginationService.Paginate(data, 2, pageSize).ToList(); var res1 = PaginationService.Paginate(data, 3, pageSize).ToList(); var res2 = PaginationService.Paginate(data, 4, pageSize).ToList(); Assert.IsTrue(res0.Count() == 2); Assert.IsTrue(res1.Count() == 1); Assert.IsTrue(res2.Count() == 0); Assert.IsTrue(res0[0].Title == "T2"); Assert.IsTrue(res1[0].Title == "T4"); }
public async Task <IEnumerable <object> > GetAllWithRoles(int?limit, int?skip) { var query = _context.Person .Select(x => new { id = x.Id, name = x.Name, lastname = x.Lastname, email = x.Email, gender = x.Gender, birthdate = x.Birthdate, pesel = x.Pesel, userroles = _context.Userroles .Where(u => u.PersonId == x.Id) .Select(u => new { roleId = u.RoleId, dateofissue = u.Dateofissue, personId = u.PersonId, roleName = u.Role.Name }) }) .OrderBy(x => x.lastname) .ThenBy(x => x.name); var trimmed = PaginationService <object> .SplitAndLimitQueryable(skip, limit, query); return(await trimmed.ToListAsync()); }
private static PaginationModel <ImageLikesModel> BuildEditPaginationModel <TFinder> (PaginationService <Picture, TFinder> pagination, int pageNumber, int userId) where TFinder : PaginationFinder <Picture> { var pictures = pagination.GetPageObjects(pageNumber); var models = new List <ImageLikesModel>(12); var dao = new VoteFindDao(); var ownerDao = new VoteOwnerDao(); models.AddRange(pictures.Select(picture => new ImageLikesModel { VotesModel = new VotesModel { Dislikes = dao.GetDislikesVoteCount(picture.PictureId), Likes = dao.GetLikesVoteCount(picture.PictureId), IsOwner = ownerDao.CheckOwner(userId, picture.PictureId) }, ImageModel = new ImageEditModel { PictureUrl = picture.PictureUrl, PictureId = picture.PictureId } })); return(new PaginationModel <ImageLikesModel> { ObjectsList = models, PagesCount = pagination.GetPagesCount(), PageNumber = pageNumber }); }
public BaseServiceTest() { // Настройка тестовых строк подключения. var builder = new ConfigurationBuilder().AddJsonFile("appsettings.json"); AppConfiguration = builder.Build(); MsSqlConfigString = AppConfiguration["ConnectionStrings:TestMsSqlConnection"]; PostgreConfigString = AppConfiguration["ConnectionStrings:TestNpgSqlConnection"]; // Настройка тестовых контекстов. var optionsMsSqlBuilder = new DbContextOptionsBuilder <ApplicationDbContext>(); optionsMsSqlBuilder.UseSqlServer(MsSqlConfigString); ApplicationDbContext = new ApplicationDbContext(optionsMsSqlBuilder.Options); var optionsBuilder = new DbContextOptionsBuilder <PostgreDbContext>(); optionsBuilder.UseNpgsql(PostgreConfigString); PostgreContext = new PostgreDbContext(optionsBuilder.Options); // Настройка экземпляров сервисов для тестов. UserService = new UserService(null, PostgreContext, null, null); ExecutorService = new ExecutorService(null, PostgreContext, UserService); PaginationService = new PaginationService(PostgreContext, UserService); }
public async Task <PagedResultBase <DigitalAccountTransactionModel> > GetFilterAsync(DateTime startDate, DateTime endDate, int page, int pageSize) { var query = _appDbContext.DigitalAccountTransactions.Where(c => c.CreatedDate.Date >= startDate.Date && c.CreatedDate.Date <= endDate.Date); return(await PaginationService.GetPagination(query, page, pageSize)); }
public void PageCount(int pageSize, int totalEntries, int expectedPages) { var range = Enumerable.Range(1, totalEntries).AsQueryable(); var result = PaginationService.Paginate(range, 1, pageSize); Assert.Equal(expectedPages, result.PageCount); }
private async Task OnReactionAddedAsync(Cacheable <IUserMessage, ulong> message, ISocketMessageChannel channel, SocketReaction reaction) { InternalStatistics.IncrementEvent("ReactionAdded"); using var scope = Provider.CreateScope(); await scope.ServiceProvider.GetService <EmoteStats>().IncrementFromReactionAsync(reaction); if (reaction.User.IsSpecified && reaction.User.Value.IsUser()) { await PaginationService.HandleReactionAsync(reaction); await scope.ServiceProvider.GetService <UserReactionsService>().IncrementReactionStatsAsync(reaction); await scope.ServiceProvider.GetService <ReminderService>().HandleRemindCopyAsync(reaction); if (channel is SocketTextChannel textChannel) { await scope.ServiceProvider.GetService <PointsService>().IncrementPointsAsync(textChannel.Guild, reaction); } if (message.HasValue) { await scope.ServiceProvider.GetService <ReminderService>().PostponeReminderAsync(message.Value, reaction); } } }
public LaunchesListCommands(OddityCore oddity, PaginationService paginationService, CacheService cacheService, LaunchesListTableGenerator launchesListTableGenerator) { _oddity = oddity; _paginationService = paginationService; _cacheService = cacheService; _launchesListTableGenerator = launchesListTableGenerator; _allowedPaginationTypes = new List <CacheContentType> { CacheContentType.UpcomingLaunches, CacheContentType.PastLaunches, CacheContentType.AllLaunches, CacheContentType.FailedStarts, CacheContentType.FailedLandings, CacheContentType.LaunchesWithOrbit }; Bot.Client.MessageReactionAdded += Client_MessageReactionAddedAsync; _cacheService.RegisterDataProvider(CacheContentType.UpcomingLaunches, async p => await _oddity.LaunchesEndpoint.GetUpcoming().ExecuteAsync()); _cacheService.RegisterDataProvider(CacheContentType.PastLaunches, async p => await _oddity.LaunchesEndpoint.GetPast().ExecuteAsync()); _cacheService.RegisterDataProvider(CacheContentType.AllLaunches, async p => await _oddity.LaunchesEndpoint.GetAll().ExecuteAsync()); _cacheService.RegisterDataProvider(CacheContentType.FailedStarts, async p => { var result = await _oddity.LaunchesEndpoint.Query() .WithFieldEqual(q => q.Success, false) .WithLimit(1000) .ExecuteAsync(); return(result.Data); }); }
public async Task Call_TotalPages_should_invoke_TotalNumberOfRecords() { paginationService = new PaginationService <WeatherHistory>(pagination.Object, pageLinkFactory.Object); await paginationService.TotalPages(); pagination.Verify(x => x.TotalNumberOfRecords(), Times.Once); }
public async Task <IEnumerable <Oldmedicinehistory> > GetAll(int?limit, int?skip) { var query = _context.Oldmedicinehistory.OrderByDescending(x => x.Date); var trimmed = (IOrderedQueryable <Oldmedicinehistory>) PaginationService <Oldmedicinehistory> .SplitAndLimitQueryable(skip, limit, query); return(await trimmed.ToListAsync()); }
private async Task OnMessageDeletedAsync(Cacheable <IMessage, ulong> message, ISocketMessageChannel channel) { InternalStatistics.IncrementEvent("MessageDeleted"); if (channel is IPrivateChannel || (message.HasValue && !message.Value.Author.IsUser())) { return; } SocketGuildUser user = null; if (message.HasValue && message.Value.Author is SocketGuildUser guildUser) { user = guildUser; } else if (MessageCache.Exists(message.Id)) { var author = MessageCache.Get(message.Id).Author; user = author is SocketGuildUser socketGuildUser ? socketGuildUser : null; } using var scope = Provider.CreateScope(); if (user != null) { await scope.ServiceProvider.GetService <UserMessagesService>().DecrementMessageStats(user.Guild, user, channel); } await Logger.OnMessageDelete(message, channel).ConfigureAwait(false); PaginationService.DeleteEmbed(message.Id); }
public void Test_GetPage(int page, int expected) { var cut = new PaginationService(100, 10); var actual = cut.GetPage(page); Assert.Equal(expected, actual); }
public async Task <IEnumerable <object> > GetAllByName(string name, int?limit, int?skip) { var query = _table.Where(x => name == null || x.Name.ToLower().Contains(name.ToLower())).OrderBy(x => x.Name); var orderedQuery = PaginationService <T> .SplitAndLimitQueryable(skip, limit, query); return(await orderedQuery.ToListAsync()); }
public void CustomCountPageCount(int pageSize, int expectedPages) { var range = Enumerable.Range(1, 10).AsQueryable(); var result = PaginationService.Paginate(range, 1, pageSize, (x) => 400); Assert.Equal(expectedPages, result.PageCount); }
public ReactionAddedHandler(DiscordSocketClient client, InternalStatistics internalStatistics, PaginationService paginationService, IServiceProvider provider) { Client = client; InternalStatistics = internalStatistics; PaginationService = paginationService; Provider = provider; }
public GCSearchController(IScopeProvider scopeProvider) { QueriesRepository = new QueriesRepository(); SettingsRepository = new SettingsRepository(); PaginationService = new PaginationService(); NodeService = new NodeService(); _scopeProvider = scopeProvider; }
public async Task CustomAsyncCountPageCount(int pageSize, int expectedPages) { var range = Enumerable.Range(1, 10).AsQueryable(); var result = await PaginationService.PaginateAsync(range, 1, pageSize, (x) => Task.FromResult(400)); Assert.Equal(expectedPages, result.PageCount); }
public MessageUpdatedHandler(DiscordShardedClient s, DatabaseService d, PaginationService p) { this.database = d; this.shard = s; this.paginationService = p; this.shard.MessageUpdated += ShardOnMessageUpdated; this.logger.Information("Registered"); }
public void Test_PageRange(int records, int recordsPerPage, int expected) { var cut = new PaginationService(records, recordsPerPage); var actual = cut.PageRange.Max; Assert.Equal(expected, actual); Assert.Equal(1, cut.PageRange.Min); }
protected async Task SendPaginatedEmbedAsync(PaginatedEmbed embed) { if (PaginationService == null) { throw new InvalidOperationException("Paginated embed requires PaginationService"); } await PaginationService.SendPaginatedMessage(embed, async embed => await ReplyAsync(embed: embed)); }
public TrueShipCommonService(TrueShipConfiguration config, IWebRequestServices webRequestServices) { Condition.Requires(config, "config").IsNotNull(); Condition.Requires(webRequestServices, "webRequestServices").IsNotNull(); this._webRequestServices = webRequestServices; this._requestService = new RequestCreatorService(config.Credentials.AccessToken); this._paginationService = new PaginationService(this._webRequestServices); }
private async Task OnReactionAddedAsync(Cacheable <IUserMessage, ulong> message, ISocketMessageChannel channel, SocketReaction reaction) { InternalStatistics.IncrementEvent("ReactionAdded"); EmoteStats.IncrementFromReaction(reaction); await PaginationService.HandleReactionAsync(reaction); UserService.IncrementReaction(reaction); }
public ReactionAddedHandler(DiscordSocketClient client, EmoteStats emoteStats, InternalStatistics internalStatistics, PaginationService paginationService, UserService userService) { Client = client; EmoteStats = emoteStats; InternalStatistics = internalStatistics; PaginationService = paginationService; UserService = userService; }
public MessageDeletedHandler(DiscordSocketClient client, InternalStatistics internalStatistics, PaginationService paginationService, IMessageCache messageCache, IServiceProvider provider) { Client = client; InternalStatistics = internalStatistics; PaginationService = paginationService; MessageCache = messageCache; Provider = provider; }
public async Task StartAsync(bool sleep = true) { var config = Configuration.Config; _client = new DiscordShardedClient(new DiscordSocketConfig { AlwaysDownloadUsers = true, LogLevel = Discord.LogSeverity.Info, MessageCacheSize = 1000 }); _services = new ServiceCollection() .AddSingleton(_client) .AddSingleton(Audio.AudioService.Instance) .BuildServiceProvider(); _commands = new CommandHandler(_client, new CommandService(new CommandServiceConfig { LogLevel = LogSeverity.Info, DefaultRunMode = RunMode.Async }), _services); new Logger(new DirectoryInfo(Directory.GetCurrentDirectory()).Parent.Parent.Parent.FullName + "/Logs", add: true); _client.ShardReady += ShardReady; _client.Log += Log; Databases.Users = await DataBase <long, UserData> .Async(new DirectoryInfo(Directory.GetCurrentDirectory()).Parent.Parent.Parent.FullName + "/Databases/Users.db", x => { UserData retVal = new UserData { Key = x, Prefix = ".f", SendCompMessage = true }; return(retVal); }); paginationService = new PaginationService <DiscordShardedClient>(_client); await _commands.InitializeAsync(); _ = Commands; await _client.LoginAsync(TokenType.Bot, config.Token); await _client.StartAsync(); if (sleep) { await Task.Delay(-1); } }
public async Task InitMyCustomerPaginationTestAsync() { var mock = new Mock <IPaginationService>(); mock.Setup(a => a.InitMyCustomerPaginationAsync(1, "petya")).Returns(Task.FromResult(new IndexOutput())); var component = new PaginationService(PostgreContext, UserService); var result = await component.InitMyCustomerPaginationAsync(3, "petya"); Assert.IsNotNull(result); }