public Task <List <PageMetadataProvider> > GetPageTypesAsync(IPageCollection collection)
        {
            if (collection == null)
            {
                throw new ArgumentNullException(nameof(collection));
            }

            var basePageType = pageMetadataManager.FindPageMetadataByName(collection.PageTypeName);

            if (basePageType == null)
            {
                throw new InvalidOperationException();
            }

            var result = new List <PageMetadataProvider>();

            foreach (var pageType in basePageType.GetDerivedMetadataWithHierarhy(true))
            {
                if (pageType.ContentType.IsAbstract)
                {
                    continue;
                }

                result.Add(pageType);
            }
            return(Task.FromResult(result));
        }
예제 #2
0
        public MetadataManager(IPageManager pageAllocator, HeapWithOffsets <char[]> stringHeap, IBootPageAllocator bootPageAllocator, ILogManager logManager)
        {
            this.pageAllocator = pageAllocator;
            this.stringHeap    = stringHeap;
            this.logManager    = logManager;

            if (!bootPageAllocator.BootPageInitialized())
            {
                using (ITransaction tran = this.logManager.CreateTransaction(this.pageAllocator, false, "GET_BOOT_PAGE"))
                    using (Releaser releaser = tran.AcquireLock(IBootPageAllocator.BootPageId, LockManager.LockTypeEnum.Exclusive).Result)
                    {
                        bootPageAllocator.AllocatePageBootPage(PageType.MixedPage, this.masterPageColumnDefinition, tran);
                        this.masterMetadataCollection = new PageListCollection(this.pageAllocator, this.masterPageColumnDefinition, IBootPageAllocator.BootPageId);
                        tran.Commit();
                    }

                MetadataInitialSetup();
            }
            else
            {
                using (ITransaction tran = this.logManager.CreateTransaction(this.pageAllocator, false, "GET_BOOT_PAGE"))
                {
                    using Releaser releaser       = tran.AcquireLock(IBootPageAllocator.BootPageId, LockManager.LockTypeEnum.Exclusive).Result;
                    this.masterMetadataCollection = new PageListCollection(this.pageAllocator, this.masterPageColumnDefinition, IBootPageAllocator.BootPageId);
                    tran.Commit();
                }
            }
        }
예제 #3
0
        private void Load(IDocumentData data)
        {
            var flags = FlagsManager.LoadFlags(DefaultMerger.AddDefaults(data.DocumentWideFlags));

            this.pageCollection = this.elementFactory.CreatePageCollection(flags);
            this.pageCollection.SetCursor(false, this.cursor);
        }
예제 #4
0
            public async Task <bool> MoveNextAsync(CancellationToken cancellationToken)
            {
                if (currentPageCollection == null)
                {
                    return(false);
                }
                if (currentEnumerator.MoveNext())
                {
                    return(true);
                }
                if (currentPageCollection.NextUri == null)
                {
                    return(false);
                }

                currentPageCollection = await currentPageCollection.ReadNextAsync(cancellationToken).ConfigureAwait(false);

                if (currentPageCollection == null)
                {
                    return(false);
                }

                currentEnumerator.Dispose();
                currentEnumerator = currentPageCollection.GetEnumerator();
                return(currentEnumerator.MoveNext());
            }
예제 #5
0
        public async Task <IPage> CreatePageAsync(IPageCollection collection, string pageType = null, string pageHeader = null, CancellationToken cancellationToken = default)
        {
            if (collection == null)
            {
                throw new ArgumentNullException(nameof(collection));
            }

            if (pageType == null)
            {
                pageType = collection.PageTypeName;
            }

            var basePageMetadata = pageMetadataManager.GetMetadata(collection.PageTypeName);
            var pageMetadata     = pageMetadataManager.GetMetadata(pageType);

            if (!pageMetadata.AllowCreateModel)
            {
                throw new InvalidOperationException($"Нельзя создать страницу с типом {pageMetadata.Name}, так как её тип контент является абстрактным.");
            }
            if (!pageMetadata.IsInheritedOrEqual(basePageMetadata))
            {
                throw new ArgumentException($"Тип страницы {pageType} не подходит для коллекции {collection.Title} ({collection.Id}).");
            }

            var pageContent = pageMetadata.CreatePageModel();

            ApplyDefaultDataToContentModel(pageMetadata, pageContent, pageHeader);

            var pageContentData = pageMetadata.ContentMetadata.ConvertContentModelToDictionary(pageContent);

            pageHeader = pageMetadata.GetPageHeader(pageContent);

            var page = await pageRepositiry.CreatePageAsync(collection.WebsiteId, collection.Id, pageMetadata.Name, pageHeader, pageContentData, cancellationToken);

            if (collection.CustomSorting)
            {
                switch (collection.SortMode)
                {
                case PageSortMode.FirstNew:
                {
                    await UpPagePositionAsync(page, null, cancellationToken);

                    break;
                }

                case PageSortMode.FirstOld:
                {
                    await DownPagePositionAsync(page, null, cancellationToken);

                    break;
                }

                default:
                    throw new Exception();
                }
            }

            return(page);
        }
예제 #6
0
        private void New()
        {
            var flags = FlagsManager.LoadFlags(Defaults.DocumentWideFlags);

            this.pageCollection = this.elementFactory.CreatePageCollection(flags); // TODO: Set back to page collection
            this.pageCollection.Region.SetParent(this.frame);
            this.pageCollection.Region.SetPoint(FramePoint.TOPLEFT, this.frame, FramePoint.TOPLEFT, 20, -20);
            this.pageCollection.SetCursor(false, this.cursor);
        }
예제 #7
0
            public PageCollectionReadToEndEnumerable(IPageCollection <T> pageCollection)
            {
                if (pageCollection == null)
                {
                    throw new ArgumentNullException(nameof(pageCollection));
                }

                this.pageCollection = pageCollection;
            }
예제 #8
0
        public CurrentConfig(IConfig config)
        {
            _config = config;

            SetSiteConfig(_config.Environment.Site);
            SetBrowserConfig(_config.Environment.Browser);
            SetLoginConfig(_config.Environment.Login);
            Pages = new PageCollection();
        }
예제 #9
0
        public MetadataColumnsManager(IAllocateMixedPage pageAllocator, MixedPage firstPage, HeapWithOffsets <char[]> stringHeap)
        {
            if (pageAllocator == null || firstPage == null)
            {
                throw new ArgumentNullException();
            }

            this.pageListCollection = new PageListCollection(pageAllocator, columnDefinitions, firstPage.PageId());
            this.stringHeap         = stringHeap;
        }
예제 #10
0
            public PageCollectionReadToEndEnumerator(IPageCollection <T> pageCollection)
            {
                if (pageCollection == null)
                {
                    throw new ArgumentNullException(nameof(pageCollection));
                }

                this.initialPageCollection = pageCollection;
                this.currentPageCollection = pageCollection;
                this.currentEnumerator     = pageCollection.GetEnumerator();
            }
        public Task UpdateCollectionAsync(IPageCollection collection, CancellationToken cancellationToken = default)
        {
            if (!collectionIds.TryGetValue(collection.Id, out int index))
            {
                throw new InvalidOperationException();
            }

            collections[index] = (PageCollection)collection;

            return(Task.CompletedTask);
        }
        public void OnRemoveCollection(IPageCollection pageCollection)
        {
            var pages = pagesByCollections[pageCollection.Id];

            if (pages.Count > 0)
            {
                throw new InvalidOperationException("Нельзя удалить коллекцию страниц, так как она содержит страницы.");
            }

            collectionsByPages[pageCollection.PageId ?? Guid.Empty].Remove(pageCollection);
            pagesByCollections.Remove(pageCollection.Id);
        }
예제 #13
0
        public MetadataTablesManager(IAllocateMixedPage pageAllocator, MixedPage firstPage, HeapWithOffsets <char[]> stringHeap, IMetadataObjectManager <MetadataColumn, ColumnCreateDefinition, Tuple <int, int> > columnManager)
        {
            if (pageAllocator == null || firstPage == null || columnManager == null)
            {
                throw new ArgumentNullException();
            }

            this.pageListCollection = new PageListCollection(pageAllocator, columnDefinitions, firstPage.PageId());
            this.stringHeap         = stringHeap;
            this.columnManager      = columnManager;
            this.pageAllocator      = pageAllocator;
        }
 private PageCollectionModel GetPageCollectionModel(IPageCollection pageCollection)
 {
     return(new PageCollectionModel
     {
         Id = pageCollection.Id,
         CreatedDate = pageCollection.CreatedDate,
         PageId = pageCollection.PageId,
         Title = pageCollection.Title,
         PageType = pageCollection.PageTypeName,
         Sort = pageCollection.SortMode
     });
 }
        public async Task <Result> UpdateCollectionAsync(IPageCollection collection, CancellationToken cancellationToken = default)
        {
            try
            {
                await repositiry.UpdateCollectionAsync(collection, cancellationToken);

                return(Result.Success);
            }
            catch (Exception ex)
            {
                return(Result.Failed(ex));
            }
        }
        public Task DeleteCollectionAsync(IPageCollection collection, CancellationToken cancellationToken = default)
        {
            if (!collectionIds.TryGetValue(collection.Id, out int index))
            {
                throw new InvalidOperationException();
            }

            pageHierarhy.OnRemoveCollection(collection);

            collectionIds.Remove(collection.Id);
            collections.Remove(index);

            return(Task.CompletedTask);
        }
예제 #17
0
        public async Task DeleteCollectionAsync(IPageCollection collection, CancellationToken cancellationToken = default)
        {
            var collectionDocument = (PageCollectionDocument)collection;
            var curVersion         = collectionDocument.Version;

            collectionDocument.Version++;

            var deleteResult = await documents.DeleteOneAsync(it => it.Id == collection.Id && it.Version == curVersion, cancellationToken : cancellationToken);

            if (deleteResult.DeletedCount != 1)
            {
                throw new InvalidOperationException();
            }
        }
예제 #18
0
        public PhyOpScan(IPageCollection <RowHolder> collection, ITransaction tran, MetadataColumn[] scanColumnInfo, string collectionName)
        {
            this.source         = collection;
            this.tran           = tran;
            this.collectionName = collectionName;

            this.scanColumnInfo = new MetadataColumn[scanColumnInfo.Length];
            for (int i = 0; i < scanColumnInfo.Length; i++)
            {
                this.scanColumnInfo[i] = new MetadataColumn(
                    scanColumnInfo[i].ColumnId,
                    scanColumnInfo[i].TableId,
                    collectionName + "." + scanColumnInfo[i].ColumnName,
                    scanColumnInfo[i].ColumnType);
            }
        }
예제 #19
0
        public static void SetConfig(string configPath)
        {
            _config = new CurrentConfig(GetConfig.UseJsonFile(configPath)
                                        .UseTypeParser(new DictionaryParser())
                                        .Build());

            Site    = _config.Site;
            Browser = _config.Browser;
            Pages   = _config.Pages;

            if (_config.Login == null)
            {
                return;
            }

            Login = _config.Login;
        }
        protected override async Task OnInitializeAsync()
        {
            if (!RouteData.Values.TryGetValue("id", out object pageCollectionIdValue))
            {
                AddErrors("Not valid id.");
                return;
            }

            if (!Guid.TryParse(pageCollectionIdValue.ToString(), out Guid pageCollectionId))
            {
                AddErrors("Not valid id.");
                return;
            }

            pageCollection = await pageCollectionService.FindCollectiondByIdAsync(pageCollectionId);

            if (pageCollection == null)
            {
                AddErrors("Not found page collection.");
                return;
            }
        }
예제 #21
0
        protected override async Task OnInitializeAsync()
        {
            if (!Request.Query.TryGetValue("collectionId", out string pageCollectionIdValue))
            {
                AddErrors("Not valid id.");
                return;
            }

            if (!Guid.TryParse(pageCollectionIdValue, out Guid pageCollectionId))
            {
                AddErrors("Not valid id.");
                return;
            }

            pageCollection = await pageCollectionService.FindCollectiondByIdAsync(pageCollectionId);

            if (pageCollection == null)
            {
                AddErrors("Not found page collection.");
                return;
            }
        }
예제 #22
0
        private async Task <PageCollectionModel> GetPageCollectionModelAsync(IPageCollection pageCollection)
        {
            string pageUrl = "/";

            if (pageCollection.PageId.HasValue)
            {
                IPage page = await pageService.FindPageByIdAsync(pageCollection.PageId.Value);

                pageUrl = await pageLinkGenerator.GetPathAsync(page);
            }

            return(new PageCollectionModel
            {
                Id = pageCollection.Id,
                CreatedDate = pageCollection.CreatedDate,
                PageId = pageCollection.PageId,
                Title = pageCollection.Title,
                PageType = pageCollection.PageTypeName,
                Sort = pageCollection.SortMode,
                CustomSorting = pageCollection.CustomSorting,
                PageUrl = pageUrl
            });
        }
        public void OnAddCollection(Guid?pageId, IPageCollection pageCollection)
        {
            if (pageId.HasValue)
            {
                if (!collectionsByPages.TryGetValue(pageId.Value, out IList <IPageCollection> pageCollectionsByPages))
                {
                    throw new InvalidOperationException();
                }

                pageCollectionsByPages.Add(pageCollection);
            }
            else
            {
                if (!collectionsByWebSites.TryGetValue(pageCollection.WebsiteId, out IList <IPageCollection> pageCollectionsByWebsites))
                {
                    collectionsByWebSites.Add(pageCollection.WebsiteId, pageCollectionsByWebsites = new List <IPageCollection>());
                }

                pageCollectionsByWebsites.Add(pageCollection);
            }

            pagesByCollections.Add(pageCollection.Id, new List <IPage>());
        }
        public async Task <Result> DeleteCollectionAsync(IPageCollection collection, CancellationToken cancellationToken = default)
        {
            if (collection == null)
            {
                throw new ArgumentNullException(nameof(collection));
            }

            if (await pageRepositiry.HasPagesAsync(collection.Id))
            {
                return(Result.Failed("Нельзя удалить коллекцию страниц, которая содержит страницы."));
            }

            try
            {
                await repositiry.DeleteCollectionAsync(collection, cancellationToken);

                return(Result.Success);
            }
            catch (Exception ex)
            {
                return(Result.Failed(ex));
            }
        }
예제 #25
0
 public static Task <IPage> CreatePageAsync <TContent>(this IPageService pageService, IPageCollection collection, TContent pageContent, CancellationToken cancellationToken = default)
     where TContent : class
 {
     return(pageService.CreatePageAsync(collection, pageContent, cancellationToken));
 }
예제 #26
0
 /// <summary>
 /// 转换分页实体
 /// </summary>
 /// <typeparam name="TSource">原类型</typeparam>
 /// <typeparam name="TTarget">目标类型</typeparam>
 /// <param name="sourcePageCollection">源分页实体</param>
 /// <param name="convert">转换的方法</param>
 /// <returns></returns>
 public static IPageCollection <TTarget> Convert <TSource, TTarget>(this IPageCollection <TSource> sourcePageCollection, Func <TSource, TTarget> convert)
 {
     return(new PageCollection <TTarget>(sourcePageCollection.Data.Select(a => convert(a)), sourcePageCollection.RecordCount, sourcePageCollection.PageIndex, sourcePageCollection.PageSize));
 }
예제 #27
0
 public PhyOpTableInsert(IPageCollection <RowHolder> pageCollection, IPhysicalOperator <RowHolder> input)
 {
     this.pageCollection = pageCollection;
     this.input          = input;
 }