2021-06-26 11:23:15 -04:00
|
|
|
<?php
|
|
|
|
|
|
|
|
namespace BookStack\Entities\Tools;
|
2019-10-05 07:55:01 -04:00
|
|
|
|
2020-11-21 19:17:45 -05:00
|
|
|
use BookStack\Entities\Models\Book;
|
|
|
|
use BookStack\Entities\Models\BookChild;
|
|
|
|
use BookStack\Entities\Models\Chapter;
|
|
|
|
use BookStack\Entities\Models\Entity;
|
|
|
|
use BookStack\Entities\Models\Page;
|
2019-10-05 07:55:01 -04:00
|
|
|
use BookStack\Exceptions\SortOperationException;
|
|
|
|
use Illuminate\Support\Collection;
|
|
|
|
|
|
|
|
class BookContents
|
|
|
|
{
|
|
|
|
/**
|
|
|
|
* @var Book
|
|
|
|
*/
|
|
|
|
protected $book;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* BookContents constructor.
|
|
|
|
*/
|
|
|
|
public function __construct(Book $book)
|
|
|
|
{
|
|
|
|
$this->book = $book;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the current priority of the last item
|
|
|
|
* at the top-level of the book.
|
|
|
|
*/
|
|
|
|
public function getLastPriority(): int
|
|
|
|
{
|
|
|
|
$maxPage = Page::visible()->where('book_id', '=', $this->book->id)
|
|
|
|
->where('draft', '=', false)
|
|
|
|
->where('chapter_id', '=', 0)->max('priority');
|
|
|
|
$maxChapter = Chapter::visible()->where('book_id', '=', $this->book->id)
|
|
|
|
->max('priority');
|
2021-06-26 11:23:15 -04:00
|
|
|
|
2019-10-05 07:55:01 -04:00
|
|
|
return max($maxChapter, $maxPage, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the contents as a sorted collection tree.
|
|
|
|
*/
|
|
|
|
public function getTree(bool $showDrafts = false, bool $renderPages = false): Collection
|
|
|
|
{
|
2021-08-22 08:15:58 -04:00
|
|
|
$pages = $this->getPages($showDrafts, $renderPages);
|
2019-10-05 07:55:01 -04:00
|
|
|
$chapters = Chapter::visible()->where('book_id', '=', $this->book->id)->get();
|
|
|
|
$all = collect()->concat($pages)->concat($chapters);
|
|
|
|
$chapterMap = $chapters->keyBy('id');
|
|
|
|
$lonePages = collect();
|
|
|
|
|
|
|
|
$pages->groupBy('chapter_id')->each(function ($pages, $chapter_id) use ($chapterMap, &$lonePages) {
|
|
|
|
$chapter = $chapterMap->get($chapter_id);
|
|
|
|
if ($chapter) {
|
2020-12-17 12:31:18 -05:00
|
|
|
$chapter->setAttribute('visible_pages', collect($pages)->sortBy($this->bookChildSortFunc()));
|
2019-10-05 07:55:01 -04:00
|
|
|
} else {
|
|
|
|
$lonePages = $lonePages->concat($pages);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2020-12-17 12:31:18 -05:00
|
|
|
$chapters->whereNull('visible_pages')->each(function (Chapter $chapter) {
|
|
|
|
$chapter->setAttribute('visible_pages', collect([]));
|
|
|
|
});
|
|
|
|
|
2020-08-14 17:13:52 -04:00
|
|
|
$all->each(function (Entity $entity) use ($renderPages) {
|
2019-10-05 07:55:01 -04:00
|
|
|
$entity->setRelation('book', $this->book);
|
2020-08-14 17:13:52 -04:00
|
|
|
|
2021-11-20 09:03:56 -05:00
|
|
|
if ($renderPages && $entity instanceof Page) {
|
2020-08-14 17:13:52 -04:00
|
|
|
$entity->html = (new PageContent($entity))->render();
|
|
|
|
}
|
2019-10-05 07:55:01 -04:00
|
|
|
});
|
|
|
|
|
|
|
|
return collect($chapters)->concat($lonePages)->sortBy($this->bookChildSortFunc());
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Function for providing a sorting score for an entity in relation to the
|
|
|
|
* other items within the book.
|
|
|
|
*/
|
|
|
|
protected function bookChildSortFunc(): callable
|
|
|
|
{
|
|
|
|
return function (Entity $entity) {
|
|
|
|
if (isset($entity['draft']) && $entity['draft']) {
|
|
|
|
return -100;
|
|
|
|
}
|
2021-06-26 11:23:15 -04:00
|
|
|
|
2019-10-05 07:55:01 -04:00
|
|
|
return $entity['priority'] ?? 0;
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the visible pages within this book.
|
|
|
|
*/
|
2021-08-21 14:58:19 -04:00
|
|
|
protected function getPages(bool $showDrafts = false, bool $getPageContent = false): Collection
|
2019-10-05 07:55:01 -04:00
|
|
|
{
|
2021-08-21 14:58:19 -04:00
|
|
|
$query = Page::visible()
|
|
|
|
->select($getPageContent ? Page::$contentAttributes : Page::$listAttributes)
|
|
|
|
->where('book_id', '=', $this->book->id);
|
2019-10-05 07:55:01 -04:00
|
|
|
|
|
|
|
if (!$showDrafts) {
|
|
|
|
$query->where('draft', '=', false);
|
|
|
|
}
|
|
|
|
|
|
|
|
return $query->get();
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2022-01-04 12:31:57 -05:00
|
|
|
* Sort the books content using the given sort map.
|
2019-10-05 07:55:01 -04:00
|
|
|
* Returns a list of books that were involved in the operation.
|
2021-06-26 11:23:15 -04:00
|
|
|
*
|
2019-10-05 07:55:01 -04:00
|
|
|
* @throws SortOperationException
|
|
|
|
*/
|
2022-01-04 12:31:57 -05:00
|
|
|
public function sortUsingMap(BookSortMap $sortMap): Collection
|
2019-10-05 07:55:01 -04:00
|
|
|
{
|
|
|
|
// Load models into map
|
|
|
|
$this->loadModelsIntoSortMap($sortMap);
|
|
|
|
$booksInvolved = $this->getBooksInvolvedInSort($sortMap);
|
|
|
|
|
|
|
|
// Perform the sort
|
2022-01-04 12:31:57 -05:00
|
|
|
foreach ($sortMap->all() as $item) {
|
|
|
|
$this->applySortUpdates($item);
|
|
|
|
}
|
2019-10-05 07:55:01 -04:00
|
|
|
|
|
|
|
// Update permissions and activity.
|
|
|
|
$booksInvolved->each(function (Book $book) {
|
|
|
|
$book->rebuildPermissions();
|
|
|
|
});
|
|
|
|
|
|
|
|
return $booksInvolved;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Using the given sort map item, detect changes for the related model
|
|
|
|
* and update it if required.
|
|
|
|
*/
|
2022-01-04 12:31:57 -05:00
|
|
|
protected function applySortUpdates(BookSortMapItem $sortMapItem): void
|
2019-10-05 07:55:01 -04:00
|
|
|
{
|
|
|
|
$model = $sortMapItem->model;
|
2022-01-04 12:31:57 -05:00
|
|
|
if (!$model) {
|
|
|
|
return;
|
|
|
|
}
|
2019-10-05 07:55:01 -04:00
|
|
|
|
2022-01-04 12:31:57 -05:00
|
|
|
$priorityChanged = $model->priority !== $sortMapItem->sort;
|
|
|
|
$bookChanged = $model->book_id !== $sortMapItem->parentBookId;
|
|
|
|
$chapterChanged = ($model instanceof Page) && $model->chapter_id !== $sortMapItem->parentChapterId;
|
2019-10-05 07:55:01 -04:00
|
|
|
|
|
|
|
if ($bookChanged) {
|
2022-01-04 12:31:57 -05:00
|
|
|
$model->changeBook($sortMapItem->parentBookId);
|
2019-10-05 07:55:01 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
if ($chapterChanged) {
|
2022-01-04 12:31:57 -05:00
|
|
|
$model->chapter_id = intval($sortMapItem->parentChapterId);
|
2019-10-05 07:55:01 -04:00
|
|
|
$model->save();
|
|
|
|
}
|
|
|
|
|
|
|
|
if ($priorityChanged) {
|
2022-01-04 12:31:57 -05:00
|
|
|
$model->priority = $sortMapItem->sort;
|
2019-10-05 07:55:01 -04:00
|
|
|
$model->save();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Load models from the database into the given sort map.
|
|
|
|
*/
|
2022-01-04 12:31:57 -05:00
|
|
|
protected function loadModelsIntoSortMap(BookSortMap $sortMap): void
|
2019-10-05 07:55:01 -04:00
|
|
|
{
|
2022-01-04 12:31:57 -05:00
|
|
|
$collection = collect($sortMap->all());
|
|
|
|
|
|
|
|
$keyMap = $collection->keyBy(function (BookSortMapItem $sortMapItem) {
|
2019-10-05 07:55:01 -04:00
|
|
|
return $sortMapItem->type . ':' . $sortMapItem->id;
|
|
|
|
});
|
2022-01-04 12:31:57 -05:00
|
|
|
|
|
|
|
$pageIds = $collection->where('type', '=', 'page')->pluck('id');
|
|
|
|
$chapterIds = $collection->where('type', '=', 'chapter')->pluck('id');
|
2019-10-05 07:55:01 -04:00
|
|
|
|
|
|
|
$pages = Page::visible()->whereIn('id', $pageIds)->get();
|
|
|
|
$chapters = Chapter::visible()->whereIn('id', $chapterIds)->get();
|
|
|
|
|
|
|
|
foreach ($pages as $page) {
|
2022-01-04 12:31:57 -05:00
|
|
|
/** @var BookSortMapItem $sortItem */
|
2019-10-05 07:55:01 -04:00
|
|
|
$sortItem = $keyMap->get('page:' . $page->id);
|
|
|
|
$sortItem->model = $page;
|
|
|
|
}
|
|
|
|
|
|
|
|
foreach ($chapters as $chapter) {
|
2022-01-04 12:31:57 -05:00
|
|
|
/** @var BookSortMapItem $sortItem */
|
2019-10-05 07:55:01 -04:00
|
|
|
$sortItem = $keyMap->get('chapter:' . $chapter->id);
|
|
|
|
$sortItem->model = $chapter;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the books involved in a sort.
|
|
|
|
* The given sort map should have its models loaded first.
|
2021-06-26 11:23:15 -04:00
|
|
|
*
|
2019-10-05 07:55:01 -04:00
|
|
|
* @throws SortOperationException
|
|
|
|
*/
|
2022-01-04 12:31:57 -05:00
|
|
|
protected function getBooksInvolvedInSort(BookSortMap $sortMap): Collection
|
2019-10-05 07:55:01 -04:00
|
|
|
{
|
2022-01-04 12:31:57 -05:00
|
|
|
$collection = collect($sortMap->all());
|
|
|
|
|
|
|
|
$bookIdsInvolved = array_unique(array_merge(
|
|
|
|
[$this->book->id],
|
|
|
|
$collection->pluck('parentBookId')->values()->all(),
|
|
|
|
$collection->pluck('model.book_id')->values()->all(),
|
|
|
|
));
|
|
|
|
|
2019-10-05 07:55:01 -04:00
|
|
|
$books = Book::hasPermission('update')->whereIn('id', $bookIdsInvolved)->get();
|
|
|
|
|
|
|
|
if (count($books) !== count($bookIdsInvolved)) {
|
2021-06-26 11:23:15 -04:00
|
|
|
throw new SortOperationException('Could not find all books requested in sort operation');
|
2019-10-05 07:55:01 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
return $books;
|
|
|
|
}
|
|
|
|
}
|