starred/BookStack
1
0
Fork 0
mirror of https://github.com/BookStackApp/BookStack.git synced 2026-02-05 00:29:48 +03:00
Code Issues 303 Packages Projects Releases 10 Wiki Activity

Merge pull request #5917 from BookStackApp/copy_references

Browse Source 
Internal reference handling on content copying
This commit is contained in:
Dan Brown
2025-11-29 20:50:05 +00:00
committed by GitHub
parent bb350639c6 3cd3e73f60
commit cf847974d2
8 changed files with 540 additions and 283 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
app/Entities/Models/Page.php
View File

@@ -124,6 +124,14 @@ class Page extends BookChild
return url('/' . implode('/', $parts));
}
/**
* Get the ID-based permalink for this page.
*/
public function getPermalink(): string
{
return url("/link/{$this->id}");
}
/**
* Get this page for JSON display.
*/

51
app/Entities/Tools/Cloner.php
View File

@@ -13,30 +13,47 @@ use BookStack\Entities\Repos\BookRepo;
use BookStack\Entities\Repos\ChapterRepo;
use BookStack\Entities\Repos\PageRepo;
use BookStack\Permissions\Permission;
use BookStack\References\ReferenceChangeContext;
use BookStack\References\ReferenceUpdater;
use BookStack\Uploads\Image;
use BookStack\Uploads\ImageService;
use Illuminate\Http\UploadedFile;
class Cloner
{
protected ReferenceChangeContext $referenceChangeContext;
public function __construct(
protected PageRepo $pageRepo,
protected ChapterRepo $chapterRepo,
protected BookRepo $bookRepo,
protected ImageService $imageService,
protected ReferenceUpdater $referenceUpdater,
) {
$this->referenceChangeContext = new ReferenceChangeContext();
}
/**
* Clone the given page into the given parent using the provided name.
*/
public function clonePage(Page $original, Entity $parent, string $newName): Page
{
$context = $this->newReferenceChangeContext();
$page = $this->createPageClone($original, $parent, $newName);
$this->referenceUpdater->changeReferencesUsingContext($context);
return $page;
}
protected function createPageClone(Page $original, Entity $parent, string $newName): Page
{
$copyPage = $this->pageRepo->getNewDraftPage($parent);
$pageData = $this->entityToInputData($original);
$pageData['name'] = $newName;
return $this->pageRepo->publishDraft($copyPage, $pageData);
$newPage = $this->pageRepo->publishDraft($copyPage, $pageData);
$this->referenceChangeContext->add($original, $newPage);
return $newPage;
}
/**
@@ -44,6 +61,14 @@ class Cloner
* Clones all child pages.
*/
public function cloneChapter(Chapter $original, Book $parent, string $newName): Chapter
{
$context = $this->newReferenceChangeContext();
$chapter = $this->createChapterClone($original, $parent, $newName);
$this->referenceUpdater->changeReferencesUsingContext($context);
return $chapter;
}
protected function createChapterClone(Chapter $original, Book $parent, string $newName): Chapter
{
$chapterDetails = $this->entityToInputData($original);
$chapterDetails['name'] = $newName;
@@ -53,10 +78,12 @@ class Cloner
if (userCan(Permission::PageCreate, $copyChapter)) {
/** @var Page $page */
foreach ($original->getVisiblePages() as $page) {
$this->clonePage($page, $copyChapter, $page->name);
$this->createPageClone($page, $copyChapter, $page->name);
}
}
$this->referenceChangeContext->add($original, $copyChapter);
return $copyChapter;
}
@@ -65,6 +92,14 @@ class Cloner
* Clones all child chapters and pages.
*/
public function cloneBook(Book $original, string $newName): Book
{
$context = $this->newReferenceChangeContext();
$book = $this->createBookClone($original, $newName);
$this->referenceUpdater->changeReferencesUsingContext($context);
return $book;
}
protected function createBookClone(Book $original, string $newName): Book
{
$bookDetails = $this->entityToInputData($original);
$bookDetails['name'] = $newName;
@@ -76,11 +111,11 @@ class Cloner
$directChildren = $original->getDirectVisibleChildren();
foreach ($directChildren as $child) {
if ($child instanceof Chapter && userCan(Permission::ChapterCreate, $copyBook)) {
$this->cloneChapter($child, $copyBook, $child->name);
$this->createChapterClone($child, $copyBook, $child->name);
}
if ($child instanceof Page && !$child->draft && userCan(Permission::PageCreate, $copyBook)) {
$this->clonePage($child, $copyBook, $child->name);
$this->createPageClone($child, $copyBook, $child->name);
}
}
@@ -92,6 +127,8 @@ class Cloner
}
}
$this->referenceChangeContext->add($original, $copyBook);
return $copyBook;
}
@@ -155,4 +192,10 @@ class Cloner
return $tags;
}
protected function newReferenceChangeContext(): ReferenceChangeContext
{
$this->referenceChangeContext = new ReferenceChangeContext();
return $this->referenceChangeContext;
}
}

45
app/References/ReferenceChangeContext.php Normal file
View File

@@ -0,0 +1,45 @@
<?php
namespace BookStack\References;
use BookStack\Entities\Models\Entity;
class ReferenceChangeContext
{
/**
* Entity pairs where the first is the old entity and the second is the new entity.
* @var array<array{0: Entity, 1: Entity}>
*/
protected array $changes = [];
public function add(Entity $oldEntity, Entity $newEntity): void
{
$this->changes[] = [$oldEntity, $newEntity];
}
/**
* Get all the new entities from the changes.
*/
public function getNewEntities(): array
{
return array_column($this->changes, 1);
}
/**
* Get all the old entities from the changes.
*/
public function getOldEntities(): array
{
return array_column($this->changes, 0);
}
public function getNewForOld(Entity $oldEntity): ?Entity
{
foreach ($this->changes as [$old, $new]) {
if ($old->id === $oldEntity->id && $old->type === $oldEntity->type) {
return $new;
}
}
return null;
}
}

42
app/References/ReferenceUpdater.php
View File

@@ -5,7 +5,6 @@ namespace BookStack\References;
use BookStack\Entities\Models\Book;
use BookStack\Entities\Models\HasDescriptionInterface;
use BookStack\Entities\Models\Entity;
use BookStack\Entities\Models\EntityContainerData;
use BookStack\Entities\Models\Page;
use BookStack\Entities\Repos\RevisionRepo;
use BookStack\Util\HtmlDocument;
@@ -30,6 +29,47 @@ class ReferenceUpdater
}
}
/**
* Change existing references for a range of entities using the given context.
*/
public function changeReferencesUsingContext(ReferenceChangeContext $context): void
{
$bindings = [];
foreach ($context->getOldEntities() as $old) {
$bindings[] = $old->getMorphClass();
$bindings[] = $old->id;
}
// No targets to update within the context, so no need to continue.
if (count($bindings) < 2) {
return;
}
$toReferenceQuery = '(to_type, to_id) IN (' . rtrim(str_repeat('(?,?),', count($bindings) / 2), ',') . ')';
// Cycle each new entity in the context
foreach ($context->getNewEntities() as $new) {
// For each, get all references from it which lead to other items within the context of the change
$newReferencesInContext = $new->referencesFrom()->whereRaw($toReferenceQuery, $bindings)->get();
// For each reference, update the URL and the reference entry
foreach ($newReferencesInContext as $reference) {
$oldToEntity = $reference->to;
$newToEntity = $context->getNewForOld($oldToEntity);
if ($newToEntity === null) {
continue;
}
$this->updateReferencesWithinEntity($new, $oldToEntity->getUrl(), $newToEntity->getUrl());
if ($newToEntity instanceof Page && $oldToEntity instanceof Page) {
$this->updateReferencesWithinEntity($new, $oldToEntity->getPermalink(), $newToEntity->getPermalink());
}
$reference->to_id = $newToEntity->id;
$reference->to_type = $newToEntity->getMorphClass();
$reference->save();
}
}
}
/**
* @return Reference[]
*/

104
tests/Entity/BookTest.php
View File

@@ -264,108 +264,4 @@ class BookTest extends TestCase
$resp = $this->asEditor()->get($book->getUrl());
$resp->assertSee("<p>My great<br>\ndescription<br>\n<br>\nwith newlines</p>", false);
}
public function test_show_view_has_copy_button()
{
$book = $this->entities->book();
$resp = $this->asEditor()->get($book->getUrl());
$this->withHtml($resp)->assertElementContains("a[href=\"{$book->getUrl('/copy')}\"]", 'Copy');
}
public function test_copy_view()
{
$book = $this->entities->book();
$resp = $this->asEditor()->get($book->getUrl('/copy'));
$resp->assertOk();
$resp->assertSee('Copy Book');
$this->withHtml($resp)->assertElementExists("input[name=\"name\"][value=\"{$book->name}\"]");
}
public function test_copy()
{
/** @var Book $book */
$book = Book::query()->whereHas('chapters')->whereHas('pages')->first();
$resp = $this->asEditor()->post($book->getUrl('/copy'), ['name' => 'My copy book']);
/** @var Book $copy */
$copy = Book::query()->where('name', '=', 'My copy book')->first();
$resp->assertRedirect($copy->getUrl());
$this->assertEquals($book->getDirectVisibleChildren()->count(), $copy->getDirectVisibleChildren()->count());
$this->get($copy->getUrl())->assertSee($book->description_html, false);
}
public function test_copy_does_not_copy_non_visible_content()
{
/** @var Book $book */
$book = Book::query()->whereHas('chapters')->whereHas('pages')->first();
// Hide child content
/** @var BookChild $page */
foreach ($book->getDirectVisibleChildren() as $child) {
$this->permissions->setEntityPermissions($child, [], []);
}
$this->asEditor()->post($book->getUrl('/copy'), ['name' => 'My copy book']);
/** @var Book $copy */
$copy = Book::query()->where('name', '=', 'My copy book')->first();
$this->assertEquals(0, $copy->getDirectVisibleChildren()->count());
}
public function test_copy_does_not_copy_pages_or_chapters_if_user_cant_create()
{
/** @var Book $book */
$book = Book::query()->whereHas('chapters')->whereHas('directPages')->whereHas('chapters')->first();
$viewer = $this->users->viewer();
$this->permissions->grantUserRolePermissions($viewer, ['book-create-all']);
$this->actingAs($viewer)->post($book->getUrl('/copy'), ['name' => 'My copy book']);
/** @var Book $copy */
$copy = Book::query()->where('name', '=', 'My copy book')->first();
$this->assertEquals(0, $copy->pages()->count());
$this->assertEquals(0, $copy->chapters()->count());
}
public function test_copy_clones_cover_image_if_existing()
{
$book = $this->entities->book();
$bookRepo = $this->app->make(BookRepo::class);
$coverImageFile = $this->files->uploadedImage('cover.png');
$bookRepo->updateCoverImage($book, $coverImageFile);
$this->asEditor()->post($book->getUrl('/copy'), ['name' => 'My copy book'])->assertRedirect();
/** @var Book $copy */
$copy = Book::query()->where('name', '=', 'My copy book')->first();
$this->assertNotNull($copy->coverInfo()->getImage());
$this->assertNotEquals($book->coverInfo()->getImage()->id, $copy->coverInfo()->getImage()->id);
}
public function test_copy_adds_book_to_shelves_if_edit_permissions_allows()
{
/** @var Bookshelf $shelfA */
/** @var Bookshelf $shelfB */
[$shelfA, $shelfB] = Bookshelf::query()->take(2)->get();
$book = $this->entities->book();
$shelfA->appendBook($book);
$shelfB->appendBook($book);
$viewer = $this->users->viewer();
$this->permissions->grantUserRolePermissions($viewer, ['book-update-all', 'book-create-all', 'bookshelf-update-all']);
$this->permissions->setEntityPermissions($shelfB);
$this->asEditor()->post($book->getUrl('/copy'), ['name' => 'My copy book']);
/** @var Book $copy */
$copy = Book::query()->where('name', '=', 'My copy book')->first();
$this->assertTrue($copy->shelves()->where('id', '=', $shelfA->id)->exists());
$this->assertFalse($copy->shelves()->where('id', '=', $shelfB->id)->exists());
}
}

83
tests/Entity/ChapterTest.php
View File

@@ -66,90 +66,7 @@ class ChapterTest extends TestCase
$this->assertNotificationContains($redirectReq, 'Chapter Successfully Deleted');
}
public function test_show_view_has_copy_button()
{
$chapter = $this->entities->chapter();
$resp = $this->asEditor()->get($chapter->getUrl());
$this->withHtml($resp)->assertElementContains("a[href$=\"{$chapter->getUrl('/copy')}\"]", 'Copy');
}
public function test_copy_view()
{
$chapter = $this->entities->chapter();
$resp = $this->asEditor()->get($chapter->getUrl('/copy'));
$resp->assertOk();
$resp->assertSee('Copy Chapter');
$this->withHtml($resp)->assertElementExists("input[name=\"name\"][value=\"{$chapter->name}\"]");
$this->withHtml($resp)->assertElementExists('input[name="entity_selection"]');
}
public function test_copy()
{
/** @var Chapter $chapter */
$chapter = Chapter::query()->whereHas('pages')->first();
/** @var Book $otherBook */
$otherBook = Book::query()->where('id', '!=', $chapter->book_id)->first();
$resp = $this->asEditor()->post($chapter->getUrl('/copy'), [
'name' => 'My copied chapter',
'entity_selection' => 'book:' . $otherBook->id,
]);
/** @var Chapter $newChapter */
$newChapter = Chapter::query()->where('name', '=', 'My copied chapter')->first();
$resp->assertRedirect($newChapter->getUrl());
$this->assertEquals($otherBook->id, $newChapter->book_id);
$this->assertEquals($chapter->pages->count(), $newChapter->pages->count());
}
public function test_copy_does_not_copy_non_visible_pages()
{
$chapter = $this->entities->chapterHasPages();
// Hide pages to all non-admin roles
/** @var Page $page */
foreach ($chapter->pages as $page) {
$this->permissions->setEntityPermissions($page, [], []);
}
$this->asEditor()->post($chapter->getUrl('/copy'), [
'name' => 'My copied chapter',
]);
/** @var Chapter $newChapter */
$newChapter = Chapter::query()->where('name', '=', 'My copied chapter')->first();
$this->assertEquals(0, $newChapter->pages()->count());
}
public function test_copy_does_not_copy_pages_if_user_cant_page_create()
{
$chapter = $this->entities->chapterHasPages();
$viewer = $this->users->viewer();
$this->permissions->grantUserRolePermissions($viewer, ['chapter-create-all']);
// Lacking permission results in no copied pages
$this->actingAs($viewer)->post($chapter->getUrl('/copy'), [
'name' => 'My copied chapter',
]);
/** @var Chapter $newChapter */
$newChapter = Chapter::query()->where('name', '=', 'My copied chapter')->first();
$this->assertEquals(0, $newChapter->pages()->count());
$this->permissions->grantUserRolePermissions($viewer, ['page-create-all']);
// Having permission rules in copied pages
$this->actingAs($viewer)->post($chapter->getUrl('/copy'), [
'name' => 'My copied again chapter',
]);
/** @var Chapter $newChapter2 */
$newChapter2 = Chapter::query()->where('name', '=', 'My copied again chapter')->first();
$this->assertEquals($chapter->pages()->count(), $newChapter2->pages()->count());
}
public function test_sort_book_action_visible_if_permissions_allow()
{

399
tests/Entity/CopyTest.php Normal file
View File

@@ -0,0 +1,399 @@
<?php
namespace Tests\Entity;
use BookStack\Entities\Models\Book;
use BookStack\Entities\Models\BookChild;
use BookStack\Entities\Models\Bookshelf;
use BookStack\Entities\Models\Chapter;
use BookStack\Entities\Models\Page;
use BookStack\Entities\Repos\BookRepo;
use Tests\TestCase;
class CopyTest extends TestCase
{
public function test_book_show_view_has_copy_button()
{
$book = $this->entities->book();
$resp = $this->asEditor()->get($book->getUrl());
$this->withHtml($resp)->assertElementContains("a[href=\"{$book->getUrl('/copy')}\"]", 'Copy');
}
public function test_book_copy_view()
{
$book = $this->entities->book();
$resp = $this->asEditor()->get($book->getUrl('/copy'));
$resp->assertOk();
$resp->assertSee('Copy Book');
$this->withHtml($resp)->assertElementExists("input[name=\"name\"][value=\"{$book->name}\"]");
}
public function test_book_copy()
{
/** @var Book $book */
$book = Book::query()->whereHas('chapters')->whereHas('pages')->first();
$resp = $this->asEditor()->post($book->getUrl('/copy'), ['name' => 'My copy book']);
/** @var Book $copy */
$copy = Book::query()->where('name', '=', 'My copy book')->first();
$resp->assertRedirect($copy->getUrl());
$this->assertEquals($book->getDirectVisibleChildren()->count(), $copy->getDirectVisibleChildren()->count());
$this->get($copy->getUrl())->assertSee($book->description_html, false);
}
public function test_book_copy_does_not_copy_non_visible_content()
{
/** @var Book $book */
$book = Book::query()->whereHas('chapters')->whereHas('pages')->first();
// Hide child content
/** @var BookChild $page */
foreach ($book->getDirectVisibleChildren() as $child) {
$this->permissions->setEntityPermissions($child, [], []);
}
$this->asEditor()->post($book->getUrl('/copy'), ['name' => 'My copy book']);
/** @var Book $copy */
$copy = Book::query()->where('name', '=', 'My copy book')->first();
$this->assertEquals(0, $copy->getDirectVisibleChildren()->count());
}
public function test_book_copy_does_not_copy_pages_or_chapters_if_user_cant_create()
{
/** @var Book $book */
$book = Book::query()->whereHas('chapters')->whereHas('directPages')->whereHas('chapters')->first();
$viewer = $this->users->viewer();
$this->permissions->grantUserRolePermissions($viewer, ['book-create-all']);
$this->actingAs($viewer)->post($book->getUrl('/copy'), ['name' => 'My copy book']);
/** @var Book $copy */
$copy = Book::query()->where('name', '=', 'My copy book')->first();
$this->assertEquals(0, $copy->pages()->count());
$this->assertEquals(0, $copy->chapters()->count());
}
public function test_book_copy_clones_cover_image_if_existing()
{
$book = $this->entities->book();
$bookRepo = $this->app->make(BookRepo::class);
$coverImageFile = $this->files->uploadedImage('cover.png');
$bookRepo->updateCoverImage($book, $coverImageFile);
$this->asEditor()->post($book->getUrl('/copy'), ['name' => 'My copy book'])->assertRedirect();
/** @var Book $copy */
$copy = Book::query()->where('name', '=', 'My copy book')->first();
$this->assertNotNull($copy->coverInfo()->getImage());
$this->assertNotEquals($book->coverInfo()->getImage()->id, $copy->coverInfo()->getImage()->id);
}
public function test_book_copy_adds_book_to_shelves_if_edit_permissions_allows()
{
/** @var Bookshelf $shelfA */
/** @var Bookshelf $shelfB */
[$shelfA, $shelfB] = Bookshelf::query()->take(2)->get();
$book = $this->entities->book();
$shelfA->appendBook($book);
$shelfB->appendBook($book);
$viewer = $this->users->viewer();
$this->permissions->grantUserRolePermissions($viewer, ['book-update-all', 'book-create-all', 'bookshelf-update-all']);
$this->permissions->setEntityPermissions($shelfB);
$this->asEditor()->post($book->getUrl('/copy'), ['name' => 'My copy book']);
/** @var Book $copy */
$copy = Book::query()->where('name', '=', 'My copy book')->first();
$this->assertTrue($copy->shelves()->where('id', '=', $shelfA->id)->exists());
$this->assertFalse($copy->shelves()->where('id', '=', $shelfB->id)->exists());
}
public function test_chapter_show_view_has_copy_button()
{
$chapter = $this->entities->chapter();
$resp = $this->asEditor()->get($chapter->getUrl());
$this->withHtml($resp)->assertElementContains("a[href$=\"{$chapter->getUrl('/copy')}\"]", 'Copy');
}
public function test_chapter_copy_view()
{
$chapter = $this->entities->chapter();
$resp = $this->asEditor()->get($chapter->getUrl('/copy'));
$resp->assertOk();
$resp->assertSee('Copy Chapter');
$this->withHtml($resp)->assertElementExists("input[name=\"name\"][value=\"{$chapter->name}\"]");
$this->withHtml($resp)->assertElementExists('input[name="entity_selection"]');
}
public function test_chapter_copy()
{
/** @var Chapter $chapter */
$chapter = Chapter::query()->whereHas('pages')->first();
/** @var Book $otherBook */
$otherBook = Book::query()->where('id', '!=', $chapter->book_id)->first();
$resp = $this->asEditor()->post($chapter->getUrl('/copy'), [
'name' => 'My copied chapter',
'entity_selection' => 'book:' . $otherBook->id,
]);
/** @var Chapter $newChapter */
$newChapter = Chapter::query()->where('name', '=', 'My copied chapter')->first();
$resp->assertRedirect($newChapter->getUrl());
$this->assertEquals($otherBook->id, $newChapter->book_id);
$this->assertEquals($chapter->pages->count(), $newChapter->pages->count());
}
public function test_chapter_copy_does_not_copy_non_visible_pages()
{
$chapter = $this->entities->chapterHasPages();
// Hide pages to all non-admin roles
/** @var Page $page */
foreach ($chapter->pages as $page) {
$this->permissions->setEntityPermissions($page, [], []);
}
$this->asEditor()->post($chapter->getUrl('/copy'), [
'name' => 'My copied chapter',
]);
/** @var Chapter $newChapter */
$newChapter = Chapter::query()->where('name', '=', 'My copied chapter')->first();
$this->assertEquals(0, $newChapter->pages()->count());
}
public function test_chapter_copy_does_not_copy_pages_if_user_cant_page_create()
{
$chapter = $this->entities->chapterHasPages();
$viewer = $this->users->viewer();
$this->permissions->grantUserRolePermissions($viewer, ['chapter-create-all']);
// Lacking permission results in no copied pages
$this->actingAs($viewer)->post($chapter->getUrl('/copy'), [
'name' => 'My copied chapter',
]);
/** @var Chapter $newChapter */
$newChapter = Chapter::query()->where('name', '=', 'My copied chapter')->first();
$this->assertEquals(0, $newChapter->pages()->count());
$this->permissions->grantUserRolePermissions($viewer, ['page-create-all']);
// Having permission rules in copied pages
$this->actingAs($viewer)->post($chapter->getUrl('/copy'), [
'name' => 'My copied again chapter',
]);
/** @var Chapter $newChapter2 */
$newChapter2 = Chapter::query()->where('name', '=', 'My copied again chapter')->first();
$this->assertEquals($chapter->pages()->count(), $newChapter2->pages()->count());
}
public function test_book_copy_updates_internal_references()
{
$book = $this->entities->bookHasChaptersAndPages();
/** @var Chapter $chapter */
$chapter = $book->chapters()->first();
/** @var Page $page */
$page = $chapter->pages()->first();
$this->asEditor();
$this->entities->updatePage($page, [
'name' => 'reference test page',
'html' => '<p>This is a test <a href="' . $book->getUrl() . '">book link</a></p>',
]);
// Quick pre-update to get stable slug
$this->put($book->getUrl(), ['name' => 'Internal ref test']);
$book->refresh();
$page->refresh();
$html = '<p>This is a test <a href="' . $page->getUrl() . '">page link</a></p>';
$this->put($book->getUrl(), ['name' => 'Internal ref test', 'description_html' => $html]);
$this->post($book->getUrl('/copy'), ['name' => 'My copied book']);
$newBook = Book::query()->where('name', '=', 'My copied book')->first();
$newPage = $newBook->pages()->where('name', '=', 'reference test page')->first();
$this->assertStringContainsString($newBook->getUrl(), $newPage->html);
$this->assertStringContainsString($newPage->getUrl(), $newBook->description_html);
$this->assertStringNotContainsString($book->getUrl(), $newPage->html);
$this->assertStringNotContainsString($page->getUrl(), $newBook->description_html);
}
public function test_chapter_copy_updates_internal_references()
{
$chapter = $this->entities->chapterHasPages();
/** @var Page $page */
$page = $chapter->pages()->first();
$this->asEditor();
$this->entities->updatePage($page, [
'name' => 'reference test page',
'html' => '<p>This is a test <a href="' . $chapter->getUrl() . '">chapter link</a></p>',
]);
// Quick pre-update to get stable slug
$this->put($chapter->getUrl(), ['name' => 'Internal ref test']);
$chapter->refresh();
$page->refresh();
$html = '<p>This is a test <a href="' . $page->getUrl() . '">page link</a></p>';
$this->put($chapter->getUrl(), ['name' => 'Internal ref test', 'description_html' => $html]);
$this->post($chapter->getUrl('/copy'), ['name' => 'My copied chapter']);
$newChapter = Chapter::query()->where('name', '=', 'My copied chapter')->first();
$newPage = $newChapter->pages()->where('name', '=', 'reference test page')->first();
$this->assertStringContainsString($newChapter->getUrl() . '"', $newPage->html);
$this->assertStringContainsString($newPage->getUrl() . '"', $newChapter->description_html);
$this->assertStringNotContainsString($chapter->getUrl() . '"', $newPage->html);
$this->assertStringNotContainsString($page->getUrl() . '"', $newChapter->description_html);
}
public function test_chapter_copy_updates_internal_permalink_references_in_its_description()
{
$chapter = $this->entities->chapterHasPages();
/** @var Page $page */
$page = $chapter->pages()->first();
$this->asEditor()->put($chapter->getUrl(), [
'name' => 'Internal ref test',
'description_html' => '<p>This is a test <a href="' . $page->getPermalink() . '">page link</a></p>',
]);
$chapter->refresh();
$this->post($chapter->getUrl('/copy'), ['name' => 'My copied chapter']);
$newChapter = Chapter::query()->where('name', '=', 'My copied chapter')->first();
$this->assertStringContainsString('/link/', $newChapter->description_html);
$this->assertStringNotContainsString($page->getPermalink() . '"', $newChapter->description_html);
}
public function test_page_copy_updates_internal_self_references()
{
$page = $this->entities->page();
$this->asEditor();
// Initial update to get stable slug
$this->entities->updatePage($page, ['name' => 'reference test page']);
$page->refresh();
$this->entities->updatePage($page, [
'name' => 'reference test page',
'html' => '<p>This is a test <a href="' . $page->getUrl() . '">page link</a></p>',
]);
$this->post($page->getUrl('/copy'), ['name' => 'My copied page']);
$newPage = Page::query()->where('name', '=', 'My copied page')->first();
$this->assertNotNull($newPage);
$this->assertStringContainsString($newPage->getUrl(), $newPage->html);
$this->assertStringNotContainsString($page->getUrl(), $newPage->html);
}
public function test_page_copy()
{
$page = $this->entities->page();
$page->html = '<p>This is some test content</p>';
$page->save();
$currentBook = $page->book;
$newBook = Book::where('id', '!=', $currentBook->id)->first();
$resp = $this->asEditor()->get($page->getUrl('/copy'));
$resp->assertSee('Copy Page');
$movePageResp = $this->post($page->getUrl('/copy'), [
'entity_selection' => 'book:' . $newBook->id,
'name' => 'My copied test page',
]);
$pageCopy = Page::where('name', '=', 'My copied test page')->first();
$movePageResp->assertRedirect($pageCopy->getUrl());
$this->assertTrue($pageCopy->book->id == $newBook->id, 'Page was copied to correct book');
$this->assertStringContainsString('This is some test content', $pageCopy->html);
}
public function test_page_copy_with_markdown_has_both_html_and_markdown()
{
$page = $this->entities->page();
$page->html = '<h1>This is some test content</h1>';
$page->markdown = '# This is some test content';
$page->save();
$newBook = Book::where('id', '!=', $page->book->id)->first();
$this->asEditor()->post($page->getUrl('/copy'), [
'entity_selection' => 'book:' . $newBook->id,
'name' => 'My copied test page',
]);
$pageCopy = Page::where('name', '=', 'My copied test page')->first();
$this->assertStringContainsString('This is some test content', $pageCopy->html);
$this->assertEquals('# This is some test content', $pageCopy->markdown);
}
public function test_page_copy_with_no_destination()
{
$page = $this->entities->page();
$currentBook = $page->book;
$resp = $this->asEditor()->get($page->getUrl('/copy'));
$resp->assertSee('Copy Page');
$movePageResp = $this->post($page->getUrl('/copy'), [
'name' => 'My copied test page',
]);
$pageCopy = Page::where('name', '=', 'My copied test page')->first();
$movePageResp->assertRedirect($pageCopy->getUrl());
$this->assertTrue($pageCopy->book->id == $currentBook->id, 'Page was copied to correct book');
$this->assertTrue($pageCopy->id !== $page->id, 'Page copy is not the same instance');
}
public function test_page_can_be_copied_without_edit_permission()
{
$page = $this->entities->page();
$currentBook = $page->book;
$newBook = Book::where('id', '!=', $currentBook->id)->first();
$viewer = $this->users->viewer();
$resp = $this->actingAs($viewer)->get($page->getUrl());
$resp->assertDontSee($page->getUrl('/copy'));
$newBook->owned_by = $viewer->id;
$newBook->save();
$this->permissions->grantUserRolePermissions($viewer, ['page-create-own']);
$this->permissions->regenerateForEntity($newBook);
$resp = $this->actingAs($viewer)->get($page->getUrl());
$resp->assertSee($page->getUrl('/copy'));
$movePageResp = $this->post($page->getUrl('/copy'), [
'entity_selection' => 'book:' . $newBook->id,
'name' => 'My copied test page',
]);
$movePageResp->assertRedirect();
$this->assertDatabaseHasEntityData('page', [
'name' => 'My copied test page',
'created_by' => $viewer->id,
'book_id' => $newBook->id,
]);
}
}

91
tests/Entity/PageTest.php
View File

@@ -178,97 +178,6 @@ class PageTest extends TestCase
]);
}
public function test_page_copy()
{
$page = $this->entities->page();
$page->html = '<p>This is some test content</p>';
$page->save();
$currentBook = $page->book;
$newBook = Book::where('id', '!=', $currentBook->id)->first();
$resp = $this->asEditor()->get($page->getUrl('/copy'));
$resp->assertSee('Copy Page');
$movePageResp = $this->post($page->getUrl('/copy'), [
'entity_selection' => 'book:' . $newBook->id,
'name' => 'My copied test page',
]);
$pageCopy = Page::where('name', '=', 'My copied test page')->first();
$movePageResp->assertRedirect($pageCopy->getUrl());
$this->assertTrue($pageCopy->book->id == $newBook->id, 'Page was copied to correct book');
$this->assertStringContainsString('This is some test content', $pageCopy->html);
}
public function test_page_copy_with_markdown_has_both_html_and_markdown()
{
$page = $this->entities->page();
$page->html = '<h1>This is some test content</h1>';
$page->markdown = '# This is some test content';
$page->save();
$newBook = Book::where('id', '!=', $page->book->id)->first();
$this->asEditor()->post($page->getUrl('/copy'), [
'entity_selection' => 'book:' . $newBook->id,
'name' => 'My copied test page',
]);
$pageCopy = Page::where('name', '=', 'My copied test page')->first();
$this->assertStringContainsString('This is some test content', $pageCopy->html);
$this->assertEquals('# This is some test content', $pageCopy->markdown);
}
public function test_page_copy_with_no_destination()
{
$page = $this->entities->page();
$currentBook = $page->book;
$resp = $this->asEditor()->get($page->getUrl('/copy'));
$resp->assertSee('Copy Page');
$movePageResp = $this->post($page->getUrl('/copy'), [
'name' => 'My copied test page',
]);
$pageCopy = Page::where('name', '=', 'My copied test page')->first();
$movePageResp->assertRedirect($pageCopy->getUrl());
$this->assertTrue($pageCopy->book->id == $currentBook->id, 'Page was copied to correct book');
$this->assertTrue($pageCopy->id !== $page->id, 'Page copy is not the same instance');
}
public function test_page_can_be_copied_without_edit_permission()
{
$page = $this->entities->page();
$currentBook = $page->book;
$newBook = Book::where('id', '!=', $currentBook->id)->first();
$viewer = $this->users->viewer();
$resp = $this->actingAs($viewer)->get($page->getUrl());
$resp->assertDontSee($page->getUrl('/copy'));
$newBook->owned_by = $viewer->id;
$newBook->save();
$this->permissions->grantUserRolePermissions($viewer, ['page-create-own']);
$this->permissions->regenerateForEntity($newBook);
$resp = $this->actingAs($viewer)->get($page->getUrl());
$resp->assertSee($page->getUrl('/copy'));
$movePageResp = $this->post($page->getUrl('/copy'), [
'entity_selection' => 'book:' . $newBook->id,
'name' => 'My copied test page',
]);
$movePageResp->assertRedirect();
$this->assertDatabaseHasEntityData('page', [
'name' => 'My copied test page',
'created_by' => $viewer->id,
'book_id' => $newBook->id,
]);
}
public function test_page_within_chapter_deletion_returns_to_chapter()
{
$chapter = $this->entities->chapter();