Пример #1
0
        public async Task SendPages(IMessageChannel channel, PageFormat pageFormat)
        {
            var pagedContent = new PagedContent(_id++)
            {
                Pages            = BuildPages(pageFormat),
                HasHiddenContent = pageFormat.HasHiddenColumns
            };

            if (pagedContent.TotalPages == 0)
            {
                return;
            }
            if (pagedContent.HasHiddenContent)
            {
                pagedContent.RevealedPages = BuildPages(pageFormat.RevealedPageFormat);
                _revealEmoteDictionary.AddOrUpdate(pageFormat.RevealEmote,
                                                   emote => new HashSet <int>(new[] { pagedContent.Id }), (emote, set) =>
                {
                    set.Add(pagedContent.Id);
                    return(set);
                });
            }
            var message = await channel.SendMessageAsync(pagedContent.Pages.First().Content);

            if (pagedContent.TotalPages == 1 && !pageFormat.HasHiddenColumns)
            {
                return;
            }
            if (!_pagedContentDictionary.TryAdd(message.Id, pagedContent))
            {
                return;
            }
            //TODO This design will need to revisited if this bot is scaled up.
            //Right now, memory is being managed by preventing more than 100 concurrent page processes from being stored in RAM
            if (_pagedContentDictionary.Count > 100)
            {
                _pagedContentDictionary.Remove(_pagedContentDictionary.Keys.First(), out _);
            }
            if (pagedContent.TotalPages > 1)
            {
                await message.AddReactionAsync(new Emoji(ArrowBackward));

                await message.AddReactionAsync(new Emoji(ArrowForward));
            }
            if (pageFormat.HasHiddenColumns)
            {
                await message.AddReactionAsync(pageFormat.RevealEmote);
            }
        }
        public async Task OnGet()
        {
            try
            {
                // Ugly way...
                var headlessClient = new ContentDeliveryService(new ContentDeliveryConfiguration("marcin-headless-uk-fest"));

                // Pure HttpClient way...
                var headlessHttpClient = _clientFactory.CreateClient("headless");

                var test = await headlessClient.Content.GetRoot();

                var test2 = await headlessHttpClient.GetAsync("/").ConfigureAwait(false);

                // Not yet possible...?
                //var test3 = await _contentDeliveryClient.Content.GetRoot();

                Events = await headlessClient.Content.GetByType("event");
            }
            catch (Exception _)
            {
            }
        }
 public HomeViewModel(PagedContent <Article> articles, SidebarViewModel sidebar, ITitleProvider titleProvider = null) : this(sidebar, titleProvider)
 {
     Articles = articles;
 }
Пример #4
0
        private static async Task PageAndRenderDescendants(IContentDelivery contentDelivery, PagedContent pagedContent, Guid parentId, int page)
        {
            foreach (var contentItem in pagedContent.Content.Items)
            {
                RenderContentWithUrl(contentItem);
            }

            if (page < pagedContent.TotalPages)
            {
                int nextPage         = page + 1;
                var nextPagedContent = await contentDelivery.GetDescendants(parentId, null, nextPage);
                await PageAndRenderDescendants(contentDelivery, nextPagedContent, parentId, nextPage);
            }
        }