public static void ClassInit(TestContext context) { serviceProvider = TestStartup.ConfigureServices(); pageProvider = serviceProvider.GetRequiredService <IPageProvider>(); forumAdapterFactory = serviceProvider.GetRequiredService <ForumAdapterFactory>(); }
public PageController(ITemplateTypeProvider templateProvider, IWidgetTypeProvider widgetProvider, IPageTemplateProvider pageTemplateProvider, IPageProvider pageProvider) { this.templateProvider = templateProvider; this.widgetProvider = widgetProvider; this.pageTemplateProvider = pageTemplateProvider; this.pageProvider = pageProvider; }
/// <summary> /// Public function to check for identifiable forums from a provided web page. /// </summary> /// <param name="uri">The URI being checked. Cache the host so we don't have to verify again.</param> /// <param name="token">Cancellation token for loading page.</param> /// <returns>Returns the forum type that was identified, if any.</returns> public static async Task <ForumType> IdentifyForumTypeAsync(Uri?uri, IPageProvider pageProvider, CancellationToken token) { if (uri == null) { return(ForumType.Unknown); } if (!forumTypes.TryGetValue(uri.Host, out ForumType forumType)) { var doc = await GetDocumentAsync(uri, pageProvider, token).ConfigureAwait(false); if (doc == null) { ArgumentException e = new ArgumentException($"Unable to load forum URL: {uri.AbsoluteUri}"); e.Data["Notify"] = true; throw e; } forumType = IdentifyForumTypeFromHtmlDocument(doc); forumTypes[uri.Host] = forumType; } return(forumType); }
public static void Create <T, TColl>(int pageSize , IPageProvider <T, TColl> pageProvider , ICountProvider countProvider , Action <TColl> created ) where T : new() where TColl : IList <T>, new() { if (null == countProvider) { throw new ArgumentNullException("countProvider"); } if (null == pageProvider) { throw new ArgumentNullException("pageProvider"); } countProvider.CountAvailable += (s, e) => { var collection = new TColl(); HashSet <int> fetchingPages = new HashSet <int>(); var data = new { Count = 0 }; for (int i = 0; i < e.Count; i += pageSize) { var t = ProxyFactory.CreateProxy <T>(new PageInterceptor <T, TColl>(pageProvider, pageSize, collection)); (t as IPageableElement).PageIndex = i / pageSize; for (int j = i; j < i + pageSize && j < e.Count; ++j) { collection.Add(t); } } created(collection); }; countProvider.GetCount(); }
/// <summary> /// Get the HTML document for the specified URI. /// </summary> /// <param name="uri">The URI to load.</param> /// <param name="token">The cancellation token.</param> /// <returns>Returns the requested page, if found. Otherwise, null.</returns> private async static Task <HtmlDocument?> GetDocumentAsync(Uri uri, IPageProvider pageProvider, CancellationToken token) { HtmlDocument?page = null; try { page = await pageProvider.GetHtmlDocumentAsync(uri.AbsoluteUri, uri.Host, CachingMode.UseCache, ShouldCache.Yes, SuppressNotifications.Yes, token) .ConfigureAwait(false); if (token.IsCancellationRequested) { page = null; } } catch (OperationCanceledException) { } catch (Exception e) { Logger2.LogError(e, "Attempt to query site to determine forum adapter failed."); } return(page); }
public CheckingPageVersionRequestMiddleware( ISiteRequestAccessor siteRequest, IPageProvider pageProvider) { _siteRequest = siteRequest; _pageProvider = pageProvider; }
/// <summary> /// Gets the range of post numbers to tally, for the given quest. /// This may require loading information from the site. /// </summary> /// <param name="quest">The quest being tallied.</param> /// <param name="pageProvider">The page provider to use to load any needed pages.</param> /// <param name="token">The cancellation token to check for cancellation requests.</param> /// <returns>Returns a ThreadRangeInfo describing which pages to load for the tally.</returns> public async Task <ThreadRangeInfo> GetQuestRangeInfoAsync(IQuest quest, IPageProvider pageProvider, CancellationToken token) { if (quest == null) { throw new ArgumentNullException(nameof(quest)); } if (pageProvider == null) { throw new ArgumentNullException(nameof(pageProvider)); } // Use the provided start post if we aren't trying to find the threadmarks. if (!quest.CheckForLastThreadmark) { return(new ThreadRangeInfo(true, quest.StartPost)); } var(foundThreadmark, rangeInfo) = await TryGetRSSThreadmarksRange(quest, pageProvider, token); if (foundThreadmark) { return(rangeInfo); } (foundThreadmark, rangeInfo) = await TryGetThreadmarksRange(quest, pageProvider, token); if (foundThreadmark) { return(rangeInfo); } // If we get here, just fall back on default start post. return(new ThreadRangeInfo(true, quest.StartPost)); }
public static IObservable<ScrollRequest> ToScrollRequest(this IObservable<KeyboardNavigationType> source, IPageProvider pageProvider ) { return source.Select(keys => { var size = pageProvider.PageSize; var firstIndex = pageProvider.FirstIndex; switch (keys) { case KeyboardNavigationType.Up: return new ScrollRequest(ScrollReason.User, size, firstIndex - 1); case KeyboardNavigationType.Down: return new ScrollRequest(ScrollReason.User, size, firstIndex + 1); case KeyboardNavigationType.PageUp: return new ScrollRequest(ScrollReason.User, size, firstIndex - size); case KeyboardNavigationType.PageDown: return new ScrollRequest(ScrollReason.User, size, firstIndex + size); case KeyboardNavigationType.Home: return new ScrollRequest(ScrollReason.User, size, 0); case KeyboardNavigationType.End: return new ScrollRequest(size); default: throw new ArgumentOutOfRangeException(nameof(keys), keys, null); } }); }
/// <summary> /// Collects the posts out of a quest based on the quest's configuration. /// </summary> /// <param name="quest">The quest to read.</param> /// <param name="pageProvider">The page provider to use to read this quest.</param> /// <param name="token">The cancellation token.</param> /// <returns>Returns a list of posts extracted from the quest.</returns> private async Task <(string threadTitle, List <Post> posts)> ReadQuestAsyncImpl( IQuest quest, IPageProvider pageProvider, CancellationToken token) { logger.LogDebug($"Reading quest {quest.DisplayName} with ForumReader."); IForumAdapter2 adapter = await forumAdapterFactory.CreateForumAdapterAsync(quest, pageProvider, token).ConfigureAwait(false); logger.LogDebug($"Forum adapter created for {quest.DisplayName}."); SyncQuestWithForumAdapter(quest, adapter); logger.LogDebug($"Quest {quest.DisplayName} synced with forum adapter."); ThreadRangeInfo rangeInfo = await GetStartInfoAsync(quest, adapter, pageProvider, token).ConfigureAwait(false); logger.LogDebug($"Range info acquired for {quest.DisplayName}. ({rangeInfo})"); List <Task <HtmlDocument?> > loadingPages = await LoadQuestPagesAsync(quest, adapter, rangeInfo, pageProvider, token).ConfigureAwait(false); logger.LogDebug($"Got {loadingPages.Count} pages loading {quest.DisplayName}."); var(threadInfo, posts2) = await GetPostsFromPagesAsync(loadingPages, quest, adapter, rangeInfo).ConfigureAwait(false); logger.LogDebug($"Got {posts2.Count} posts for quest {quest.DisplayName}."); List <Post> filteredPosts = FilterPosts(posts2, quest, threadInfo, rangeInfo); logger.LogDebug($"Filtered to {filteredPosts.Count} posts for quest {quest.DisplayName}."); return(threadInfo.Title, filteredPosts); }
/// <summary> /// Acquire a list of page loading tasks for the pages that are intended /// to be tallied. /// </summary> /// <param name="quest">The quest for which the tally is being run.</param> /// <param name="adapter">The forum adapter that handles the quest's thread.</param> /// <param name="threadRangeInfo">The range of posts that are wanted in the tally.</param> /// <param name="token">A cancellation token.</param> /// <returns>Returns a list of page loading tasks.</returns> private async Task <List <Task <HtmlDocument?> > > LoadQuestPagesAsync( IQuest quest, IForumAdapter2 adapter, ThreadRangeInfo threadRangeInfo, IPageProvider pageProvider, CancellationToken token) { int firstPageNumber = threadRangeInfo.GetStartPage(quest); // Get the first page in order to find out how many pages are in the thread // Keep it as a task. Task <HtmlDocument?> firstPage = GetFirstPage(firstPageNumber, quest, adapter, pageProvider, token); // Get the last page number. int lastPageNumber = await GetLastPageNumber(quest, adapter, threadRangeInfo, firstPage).ConfigureAwait(false); // Initiate tasks for any remaining pages IEnumerable <Task <HtmlDocument?> > remainingPages = GetRemainingPages(firstPageNumber, lastPageNumber, quest, adapter, pageProvider, token); // Collect all the page load tasks (including the finished first page) to return to caller. List <Task <HtmlDocument?> > pagesToLoad = new List <Task <HtmlDocument?> >() { firstPage }; pagesToLoad.AddRange(remainingPages); return(pagesToLoad); }
/// <summary> /// Get the HTML document for the specified URI. /// </summary> /// <param name="uri">The URI to load.</param> /// <param name="token">The cancellation token.</param> /// <returns>Returns the requested page, if found. Otherwise, null.</returns> private async static Task <HtmlDocument> GetDocumentAsync(Uri uri, CancellationToken token) { IPageProvider pageProvider = ViewModels.ViewModelService.MainViewModel.PageProvider; try { HtmlDocument page = await pageProvider.GetPage(uri.AbsoluteUri, uri.Host, CachingMode.UseCache, ShouldCache.Yes, SuppressNotifications.No, token) .ConfigureAwait(false); if (token.IsCancellationRequested) { return(null); } return(page); } catch (OperationCanceledException) { return(null); } catch (Exception e) { ErrorLog.Log(e); return(null); } }
/// <summary> /// Loads the HTML pages that are relevant to a quest's tally. /// </summary> /// <param name="quest">The quest being loaded.</param> /// <param name="adapter">The quest's forum adapter, used to forum the URLs to load.</param> /// <param name="threadRangeInfo">The range info that determines which pages to load.</param> /// <param name="token">The cancellation token.</param> /// <returns>Returns a list of tasks that are handling the async loading of the requested pages.</returns> private async Task <List <Task <HtmlDocument> > > LoadQuestPagesAsync( IQuest quest, IForumAdapter adapter, ThreadRangeInfo threadRangeInfo, CancellationToken token) { var scanInfo = await GetPagesToScanAsync(quest, adapter, threadRangeInfo, token).ConfigureAwait(false); int firstPageNumber = scanInfo.Item1; int lastPageNumber = scanInfo.Item2; int pagesToScan = scanInfo.Item3; // We will store the loaded pages in a new List. List <Task <HtmlDocument> > pages = new List <Task <HtmlDocument> >(); IPageProvider pageProvider = ViewModels.ViewModelService.MainViewModel.PageProvider; // Initiate the async tasks to load the pages if (pagesToScan > 0) { // Initiate tasks for all pages other than the first page (which we already loaded) var results = from pageNum in Enumerable.Range(firstPageNumber, pagesToScan) let pageUrl = adapter.GetUrlForPage(pageNum, quest.PostsPerPage) let shouldCache = (pageNum == lastPageNumber) ? ShouldCache.No : ShouldCache.Yes select pageProvider.GetPage(pageUrl, $"Page {pageNum}", CachingMode.UseCache, shouldCache, SuppressNotifications.No, token); pages.AddRange(results.ToList()); } return(pages); }
public FrontUserPageSectionController(IContentTypeProvider contentTypeProvider , IPageSectionTypeProvider pageSectionTypeProvider , IPageSectionDataTypeProvider pageSectionDataTypeProvider , IFrontUserPageSectionProvider frontUserPageSectionProvider , IPageSectionProvider pageSectionProvider , IFrontUserPageProvider frontUserPageProvider , IMasterListProvider masterListProvider , IMasterProvider masterProvider , ICheckProvider checkProvider , IClaimCheck claimCheck , IPageProvider pageProvider , Microsoft.AspNetCore.Identity.UserManager <SIPx.API.Models.SipUser> userManager) { _masterProvider = masterProvider; _contentTypeProvider = contentTypeProvider; _pageSectionTypeProvider = pageSectionTypeProvider; _pageSectionDataTypeProvider = pageSectionDataTypeProvider; _frontUserPageSectionProvider = frontUserPageSectionProvider; _pageSectionProvider = pageSectionProvider; _frontUserPageProvider = frontUserPageProvider; _masterListProvider = masterListProvider; _checkProvider = checkProvider; _claimCheck = claimCheck; _pageProvider = pageProvider; _userManager = userManager; }
public MainViewModel(QuestCollectionWrapper config, HttpClientHandler handler, IPageProvider pageProvider, ITextResultsProvider textResults, IErrorLogger errorLogger, Func <string, CompareInfo, CompareOptions, int> hashFunction) { ErrorLog.LogUsing(errorLogger); Agnostic.HashStringsUsing(hashFunction); if (config != null) { QuestList = config.QuestCollection; QuestList.Sort(); SelectQuest(config.CurrentQuest); } else { QuestList = new QuestCollection(); SelectQuest(null); } SetupNetwork(pageProvider, handler); SetupTextResults(textResults); AllVotesCollection = new ObservableCollectionExt <string>(); AllVotersCollection = new ObservableCollectionExt <string>(); BuildCheckForNewRelease(); BuildTally(); BindVoteCounter(); SetupCommands(); }
void Start() { pageProvider = GetComponent <IPageProvider>(); if (pageProvider == null) { throw new System.NullReferenceException( "PagedScrollRect is missing an IPageProvider. " + "Please look at IPageProvider.cs for details."); } scrollEffects = GetComponents <BaseScrollEffect>(); if (scrollEffects.Length == 0) { Debug.LogWarning( "PagedScrollRect does not have any BaseScrollEffects. " + "Adding defaults."); gameObject.AddComponent <TranslateScrollEffect>(); gameObject.AddComponent <FadeScrollEffect>(); scrollEffects = GetComponents <BaseScrollEffect>(); } if (!onlyScrollWhenPointing) { CanScroll = true; } // Immediately snap to the starting page. SnapToPage(StartPage, true, true); }
public static object Resource(string language, string resourceName) { //Todo: Clean // Get the cache Cache cache = HttpContext.Current.Cache; if (cache["Resources"] == null) { cache.Insert("Resources", new Dictionary <string, Dictionary <string, string> >()); } var resources = (Dictionary <string, Dictionary <string, string> >)cache.Get("Resources"); Dictionary <string, string> languageSpecificResources; if (!resources.ContainsKey(language)) { // create the whole resources dictionary for the specified language string resourceFile = ConfigurationManager.AppSettings["ResourcePath"]; string resourcePagePath = String.Format("/{0}/{1}", language, resourceFile); IPageProvider provider = DependencyResolver.Current.GetService <IPageProvider>(); IPageFactory factory = DependencyResolver.Current.GetService <IPageFactory>(); factory.PageProvider = provider; var resourcesPage = factory.FindPage(resourcePagePath); languageSpecificResources = new Dictionary <string, string>(); foreach (IComponentPresentation componentPresentation in resourcesPage.ComponentPresentations) { foreach (IFieldSet fieldSet in componentPresentation.Component.Fields["Resource"].EmbeddedValues) { if (languageSpecificResources.ContainsKey(fieldSet["Key"].Value)) { throw new DuplicateNameException(String.Format("Duplicate key found for key name: {0}", fieldSet["Key"].Value)); } languageSpecificResources.Add(fieldSet["Key"].Value, fieldSet["Value"].Value); } } // add the dictionary to the main resources dictionary in the cache resources.Add(language, languageSpecificResources); } else { languageSpecificResources = resources[language]; } if (languageSpecificResources.ContainsKey(resourceName)) { return(languageSpecificResources[resourceName]); } return(String.Format("[{0}]", resourceName)); }
private void InitializePageCascading(IPageProvider filePageProvider, Page page) { this.Add(filePageProvider.Get(page)); foreach (var item in filePageProvider.ChildPages(page)) { InitializePageCascading(filePageProvider, item); } }
public Tally(IPageProvider pageProvider, IVoteCounter voteCounter) { VoteCounter = voteCounter ?? throw new ArgumentNullException(nameof(voteCounter)); // Hook up to event notifications pageProvider.StatusChanged += PageProvider_StatusChanged; AdvancedOptions.Instance.PropertyChanged += Options_PropertyChanged; }
private void ExportPageCascading(IPageProvider filePageProvider, Page page) { filePageProvider.Add(page); foreach (var item in this.ChildPages(page)) { ExportPageCascading(filePageProvider, item); } }
/// <summary> /// Gets the thread range info (page and post numbers) based on the quest configuration. /// May load pages (such as for checking threadmarks), so will use the ViewModel's page provider. /// </summary> /// <param name="quest">The quest we're getting thread info for.</param> /// <param name="adapter">The quest's forum adapter.</param> /// <param name="token">The cancellation token.</param> /// <returns>Returns the quest's thread range info.</returns> private async Task <ThreadRangeInfo> GetStartInfoAsync(IQuest quest, IForumAdapter adapter, CancellationToken token) { IPageProvider pageProvider = ViewModels.ViewModelService.MainViewModel.PageProvider; ThreadRangeInfo rangeInfo = await adapter.GetStartingPostNumberAsync(quest, pageProvider, token).ConfigureAwait(false); return(rangeInfo); }
public PagesController( IPageService service, IPageProvider provider, ILogger <PagesController> logger) : base(logger) { _service = service; _provider = provider; }
public PageMap(IPageProvider <TData> source, IRange <int> range) { _source = source; if (ReferenceEquals(null, _source)) { throw new ArgumentException(); } SetBounds(range); }
public PageMap(IPageProvider <TData> source, int first, int last) { _source = source; if (ReferenceEquals(null, _source)) { throw new ArgumentException(); } SetBounds(first, last); }
public static T Create <T>(IPageProvider <TData> source, IRange <int> range) where T : PageMap <TData> { if (ReferenceEquals(typeof(T), typeof(PageMap <TData>))) { return(new PageMap <TData>(source, range) as T); } throw new NotSupportedException("type not supported"); }
private void ExportAsFileCascading(IPageProvider filePageProvider, Page page) { page = Get(page); filePageProvider.Add(page); foreach (var item in ChildPages(page)) { ExportAsFileCascading(filePageProvider, item); } }
public void Bind(IPageProvider <TData> pageProvider) { _chain = new Chain <PageMap <TData>, TData>( pageProvider, new [] { new PageMap <TData>(pageProvider, new Range <int>()), new PageMap <TData>(pageProvider, new Range <int>()), }); }
public PublishingManager(IPageProvider provider, TextContentManager textContentManager, LocalPublishingQueueManager localPublishingQueueManager, RemotePublishingQueueManager remotePublishingQueueManager, PageManager pageManager, IPublishingLogProvider publishingLogProvider) { this._provider = provider; this._textContentManager = textContentManager; this._localPublishingQueueManager = localPublishingQueueManager; this._remotePublishingQueueManager = remotePublishingQueueManager; this._pageManager = pageManager; this._publishingLogProvider = publishingLogProvider; }
public PageInterceptor(IPageProvider <T, TColl> pageFiller , int pageSize , TColl collection ) { this.pageFiller = pageFiller; this.pageSize = pageSize; this.collection = collection; }
public PageController(IPageProvider pageProvider, ILogger logger) { if (pageProvider == null) throw new ArgumentNullException("pageProvider"); if (logger == null) throw new ArgumentNullException("logger"); PageProvider = pageProvider; Logger = logger; }
/// <summary> /// Initializes a new instance of the <see cref="NavigationManager{TPageIdentifier}"/> class. /// To gather page definitions it searches for classes marked with <see cref="NavigationPageAttribute"/> from <see cref="Assembly.GetCallingAssembly"/> /// </summary> /// <param name="fragmentManager">Fragment manager of main activity.</param> /// <param name="rootFrame">The view which will be used as the one being replaced with new Views</param> /// <param name="viewModelResolver">Class used to resolve ViewModels for pages derived from <see cref="FragmentBase{TViewModel}"/></param> /// <param name="stackResolver">Class allowing to differentiate to which stack given indentigier belongs.</param> /// <param name="interceptTransaction">Delegate allowing to modify <see cref="FragmentTransaction"/> before commiting.</param> public NavigationManager( FragmentManager fragmentManager, ViewGroup rootFrame, IViewModelResolver viewModelResolver = null, IStackResolver <NavigationFragmentBase, TPageIdentifier> stackResolver = null, Action <FragmentTransaction> interceptTransaction = null) : base(stackResolver) { _fragmentManager = fragmentManager; _rootFrame = rootFrame; _interceptTransaction = interceptTransaction; NavigationFragmentBase.ViewModelResolver = viewModelResolver; var types = Assembly.GetCallingAssembly().GetTypes(); foreach (var type in types) { var attr = type.GetTypeInfo().GetCustomAttribute <NavigationPageAttribute>(); if (attr != null) { IPageProvider <NavigationFragmentBase> provider = null; switch (attr.PageProviderType) { case NavigationPageAttribute.PageProvider.Cached: provider = ObtainProviderFromType(typeof(CachedPageProvider <>)); break; case NavigationPageAttribute.PageProvider.Oneshot: provider = ObtainProviderFromType(typeof(OneshotPageProvider <>)); break; default: throw new ArgumentOutOfRangeException(); } PageDefinitions.Add((TPageIdentifier)(object)attr.Page, provider); } IPageProvider <NavigationFragmentBase> ObtainProviderFromType(Type providerType) { return((IPageProvider <NavigationFragmentBase>)providerType.MakeGenericType(type) .GetConstructor(new Type[] { }) .Invoke(null)); } } foreach (var pageDefinition in PageDefinitions) { pageDefinition.Value.PageIdentifier = pageDefinition.Key; } }
public CheckingPageRequestMiddleware( ISiteRequestAccessor siteRequestAccessor, ISiteRouteProvider siteRouteProvider, IThemeProvider themeProvider, IPageProvider pageProvider) { _siteRequestAccessor = siteRequestAccessor; _siteRouteProvider = siteRouteProvider; _pageProvider = pageProvider; _themeProvider = themeProvider; }
public RemotePublishingQueueManager(IRemotePublishingQueueProvider remotePublishingQueueProvider, ICmisSession cmisSession, PageManager pageManager, TextContentManager textContentManager, IPublishingLogProvider publishingLogProvider, IPageProvider pageProvider) : base(remotePublishingQueueProvider) { this._remotePublishingQueueProvider = remotePublishingQueueProvider; this._cmisSession = cmisSession; this._textContentManager = textContentManager; this._pageManager = pageManager; this._publishingLogProvider = publishingLogProvider; this._pageProvider = pageProvider; }
public PageFactory(IPageProvider pageProvider, IComponentPresentationFactory componentPresentationFactory, IFactoriesFacade facade) : base(facade) { if (pageProvider == null) throw new ArgumentNullException("pageProvider"); if (componentPresentationFactory == null) throw new ArgumentNullException("componentPresentationFactory"); ComponentPresentationFactory = componentPresentationFactory; PageProvider = pageProvider; }
public InlineEditingController(IPageProvider pageProvider, ITextContentBinder binder) { this.PageProvider = pageProvider; Binder = binder; }
public ZenitBetParser(IPageProvider provider, List<IGameParser> gameParsers) { this.provider = provider; this.gameParsers = gameParsers; }
public static void Register(IPageProvider provider) { providers.Add(provider); }
void Start() { pageProvider = GetComponent<IPageProvider>(); if (pageProvider == null) { throw new System.NullReferenceException( "PagedScrollRect is missing an IPageProvider. " + "Please look at IPageProvider.cs for details."); } scrollEffects = GetComponents<BaseScrollEffect>(); if (scrollEffects.Length == 0) { Debug.LogWarning( "PagedScrollRect does not have any BaseScrollEffects. " + "Adding defaults."); gameObject.AddComponent<TranslateScrollEffect>(); gameObject.AddComponent<FadeScrollEffect>(); scrollEffects = GetComponents<BaseScrollEffect>(); } if (!onlyScrollWhenPointing) { CanScroll = true; } // Immediately snap to the starting page. SnapToPage(StartPage, true); }
public EtfSecurities(IPageProvider provider) { this.pageProvider = provider; }