public async Task CreateRevisions_WithRemovalOfOld()
        {
            const int revisionCount = 2;
            var       siteId        = await MakeSite().ConfigureAwait(false);

            using var api = CreateApi();
            MyPage page = await MyPage.CreateAsync(api).ConfigureAwait(false);

            page.SiteId    = siteId;
            page.Title     = "Startpage";
            page.Text      = "Welcome";
            page.IsHidden  = true;
            page.Published = DateTime.Now;
            await PageRepository.Save(page).ConfigureAwait(false);

            var pageId = page.Id;
            await PageRepository.CreateRevision(pageId, revisionCount).ConfigureAwait(false);

            await PageRepository.CreateRevision(pageId, revisionCount).ConfigureAwait(false);

            await PageRepository.CreateRevision(pageId, revisionCount).ConfigureAwait(false);

            using var session = SessionFactory.OpenSession();
            using var txn     = session.BeginTransaction();
            var revisions = session.Query <PageRevisionEntity>().Where(p => p.Page.Id == pageId).ToList();

            Assert.AreEqual(revisionCount, revisions.Count);
            txn.Commit();
        }
        private async Task <MyBlogPage> MakeBlog(Guid siteId, int sortOrder = 0)
        {
            using var api = CreateApi();
            MyBlogPage blog = await MyBlogPage.CreateAsync(api).ConfigureAwait(false);

            blog.SiteId    = siteId;
            blog.Title     = "Blog Archive";
            blog.SortOrder = sortOrder;
            await PageRepository.Save(blog).ConfigureAwait(false);

            return(blog);
        }
        public async Task GetBySlug()
        {
            var siteId = await MakeSite().ConfigureAwait(false);

            var firstPage = await MakePage(siteId).ConfigureAwait(false);

            firstPage.Slug = $"slug-{RandomNumber.Next()}";
            await PageRepository.Save(firstPage).ConfigureAwait(false);

            var retrieved = await PageRepository.GetBySlug <MyPage>(firstPage.Slug, siteId).ConfigureAwait(false);

            Assert.AreEqual(firstPage.Id, retrieved.Id);
        }
        public async Task GetBySlug_RandomSiteId()
        {
            var siteId = await MakeSite().ConfigureAwait(false);

            var firstPage = await MakePage(siteId).ConfigureAwait(false);

            firstPage.Slug = $"slug-{RandomNumber.Next()}";
            await PageRepository.Save(firstPage).ConfigureAwait(false);

            var retrieved = await PageRepository.GetBySlug <MyPage>(firstPage.Slug, Guid.NewGuid()).ConfigureAwait(false);

            Assert.IsNull(retrieved);
        }
        private async Task <MyPage> MakePage(Guid siteId)
        {
            using var api = CreateApi();
            MyPage page = await MyPage.CreateAsync(api).ConfigureAwait(false);

            page.SiteId    = siteId;
            page.Title     = "Startpage";
            page.Text      = "Welcome";
            page.IsHidden  = true;
            page.Published = DateTime.Now;
            await PageRepository.Save(page).ConfigureAwait(false);

            return(page);
        }
        public async Task GetStartPage_SinglePage()
        {
            var siteId = await MakeSite().ConfigureAwait(false);

            var aPage = await MakePage(siteId).ConfigureAwait(false);

            aPage.ParentId = null;
            var pageId = aPage.Id;
            await PageRepository.Save(aPage).ConfigureAwait(false);

            var startPage = await PageRepository.GetStartpage <DynamicPage>(siteId).ConfigureAwait(false);

            Assert.AreEqual(pageId, startPage.Id);
        }
        private async Task <MyPage> MakePageWithBlocks(Guid siteId)
        {
            var page = await MakePage(siteId).ConfigureAwait(false);

            page.Blocks.Add(new Piranha.Extend.Blocks.TextBlock
            {
                Body = Lorem.Sentence(3)
            });
            page.Blocks.Add(new Piranha.Extend.Blocks.TextBlock
            {
                Body = Lorem.Sentence(3)
            });
            await PageRepository.Save(page).ConfigureAwait(false);

            return(page);
        }
        public async Task Save_AfterChange()
        {
            var siteId = await MakeSite().ConfigureAwait(false);

            MyPage page = await MakePage(siteId).ConfigureAwait(false);

            var    pageId  = page.Id;
            string newText = $"Welcome at {DateTime.Now}";

            page.Text = newText;
            await PageRepository.Save(page).ConfigureAwait(false);

            var retrieved = await PageRepository.GetById <MyPage>(pageId).ConfigureAwait(false);

            Assert.AreEqual(newText, retrieved.Text.Value);
        }
Beispiel #9
0
        private async Task <MyPage> MakePage(Guid siteId)
        {
            var    pageRepository = new PageRepository(SessionFactory, new ContentServiceFactory(_contentFactory), Module.Mapper);
            MyPage page;

            using var api = CreateApi();
            page          = await MyPage.CreateAsync(api).ConfigureAwait(false);

            page.SiteId    = siteId;
            page.Title     = "Startpage";
            page.Text      = "Welcome";
            page.IsHidden  = true;
            page.Published = DateTime.Now;
            await pageRepository.Save(page).ConfigureAwait(false);

            return(page);
        }
        public async Task Save_WithPublishDateInPastShouldNotHaveDraft()
        {
            var siteId = await MakeSite().ConfigureAwait(false);

            using var api = CreateApi();
            MyPage page = await MyPage.CreateAsync(api).ConfigureAwait(false);

            page.SiteId    = siteId;
            page.Title     = "Startpage";
            page.Text      = "Welcome";
            page.IsHidden  = true;
            page.Published = DateTime.Now.AddDays(-42);
            await PageRepository.Save(page).ConfigureAwait(false);

            var pageId = page.Id;
            var draft  = await PageRepository.GetDraftById <MyPage>(pageId).ConfigureAwait(false);

            Assert.IsNull(draft);
        }
        public async Task GetStartPage_BasedOnSortOrder()
        {
            var siteId = await MakeSite().ConfigureAwait(false);

            var firstPage = await MakePage(siteId).ConfigureAwait(false);

            var secondPage = await MakePage(siteId).ConfigureAwait(false);

            var secondPageId = secondPage.Id;

            firstPage.SortOrder  = 1;
            secondPage.SortOrder = 0;
            await PageRepository.Save(secondPage).ConfigureAwait(false);

            await PageRepository.Save(firstPage).ConfigureAwait(false);

            var retrieved = await PageRepository.GetStartpage <DynamicPage>(siteId).ConfigureAwait(false);

            Assert.AreEqual(secondPageId, retrieved.Id);
        }
Beispiel #12
0
        public async Task GetSitemap()
        {
            var repository = new SiteRepository(SessionFactory, new ContentServiceFactory(_contentFactory));
            var siteId     = await MakeSite().ConfigureAwait(false);

            _ = await MakePage(siteId).ConfigureAwait(false);

            var anotherPage = await MakePage(siteId).ConfigureAwait(false);

            anotherPage.Published = null;
            var pageRepository = new PageRepository(SessionFactory, new ContentServiceFactory(_contentFactory), Module.Mapper);
            await pageRepository.Save(anotherPage).ConfigureAwait(false);

            var siteMap = await repository.GetSitemap(siteId, true).ConfigureAwait(false);

            Assert.AreEqual(1, siteMap.Count);
            var siteMapIncludingNonPublished = await repository.GetSitemap(siteId, false).ConfigureAwait(false);

            Assert.AreEqual(2, siteMapIncludingNonPublished.Count);
        }
        public async Task Save_PublishedAsDraft()
        {
            var siteId = await MakeSite().ConfigureAwait(false);

            using var api = CreateApi();
            MyPage page = await MyPage.CreateAsync(api).ConfigureAwait(false);

            page.SiteId    = siteId;
            page.Title     = "Startpage";
            page.Text      = "Welcome";
            page.IsHidden  = true;
            page.Published = DateTime.Now.AddDays(-1);
            await PageRepository.Save(page).ConfigureAwait(false);

            await PageRepository.SaveDraft(page).ConfigureAwait(false);

            var pageId    = page.Id;
            var retrieved = await PageRepository.GetDraftById <MyPage>(pageId).ConfigureAwait(false);

            Assert.AreEqual(pageId, retrieved.Id);
            Assert.AreEqual(siteId, retrieved.SiteId);
        }
        public async Task DeleteDraft()
        {
            var siteId = await MakeSite().ConfigureAwait(false);

            using var api = CreateApi();
            MyPage page = await MyPage.CreateAsync(api).ConfigureAwait(false);

            page.SiteId    = siteId;
            page.Title     = "Startpage";
            page.Text      = "Welcome";
            page.IsHidden  = true;
            page.Published = DateTime.Now;
            await PageRepository.Save(page).ConfigureAwait(false);

            await PageRepository.SaveDraft(page).ConfigureAwait(false);

            var draftId = page.Id;
            await PageRepository.DeleteDraft(draftId).ConfigureAwait(false);

            var retrieved = await PageRepository.GetDraftById <MyPage>(draftId).ConfigureAwait(false);

            Assert.IsNull(retrieved);
        }
        public async Task Save_UnpublishedTwiceDoesNotCreateDraft()
        {
            DateTime?unpublished = null;
            var      siteId      = await MakeSite().ConfigureAwait(false);

            using var api = CreateApi();
            MyPage page = await MyPage.CreateAsync(api).ConfigureAwait(false);

            page.SiteId    = siteId;
            page.Title     = "Startpage";
            page.Text      = "Welcome";
            page.IsHidden  = true;
            page.Published = unpublished;
            await PageRepository.Save(page).ConfigureAwait(false);

            page.Text = $"Welcome, ${Name.FirstName()}";
            await PageRepository.Save(page).ConfigureAwait(false);

            var pageId = page.Id;
            var draft  = await PageRepository.GetDraftById <MyPage>(pageId).ConfigureAwait(false);

            Assert.IsNull(draft);
        }