2018-10-13 06:27:55 -04:00
|
|
|
<?php namespace BookStack\Entities\Repos;
|
|
|
|
|
2020-11-07 17:37:27 -05:00
|
|
|
use BookStack\Actions\ActivityType;
|
2020-11-21 19:17:45 -05:00
|
|
|
use BookStack\Entities\Models\Book;
|
|
|
|
use BookStack\Entities\Models\Chapter;
|
|
|
|
use BookStack\Entities\Models\Entity;
|
2020-11-21 18:20:54 -05:00
|
|
|
use BookStack\Entities\Tools\BookContents;
|
|
|
|
use BookStack\Entities\Tools\PageContent;
|
|
|
|
use BookStack\Entities\Tools\TrashCan;
|
2020-11-21 19:17:45 -05:00
|
|
|
use BookStack\Entities\Models\Page;
|
|
|
|
use BookStack\Entities\Models\PageRevision;
|
2019-10-05 07:55:01 -04:00
|
|
|
use BookStack\Exceptions\MoveOperationException;
|
|
|
|
use BookStack\Exceptions\NotFoundException;
|
|
|
|
use BookStack\Exceptions\PermissionsException;
|
2020-11-07 17:37:27 -05:00
|
|
|
use BookStack\Facades\Activity;
|
2020-09-27 18:24:33 -04:00
|
|
|
use Exception;
|
2019-10-05 07:55:01 -04:00
|
|
|
use Illuminate\Database\Eloquent\Builder;
|
|
|
|
use Illuminate\Pagination\LengthAwarePaginator;
|
|
|
|
use Illuminate\Support\Collection;
|
|
|
|
|
|
|
|
class PageRepo
|
2018-10-13 06:27:55 -04:00
|
|
|
{
|
|
|
|
|
2019-10-05 07:55:01 -04:00
|
|
|
protected $baseRepo;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* PageRepo constructor.
|
|
|
|
*/
|
|
|
|
public function __construct(BaseRepo $baseRepo)
|
|
|
|
{
|
|
|
|
$this->baseRepo = $baseRepo;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get a page by ID.
|
|
|
|
* @throws NotFoundException
|
|
|
|
*/
|
2020-11-22 09:56:19 -05:00
|
|
|
public function getById(int $id, array $relations = ['book']): Page
|
2019-10-05 07:55:01 -04:00
|
|
|
{
|
2020-11-22 09:56:19 -05:00
|
|
|
$page = Page::visible()->with($relations)->find($id);
|
2019-10-05 07:55:01 -04:00
|
|
|
|
|
|
|
if (!$page) {
|
|
|
|
throw new NotFoundException(trans('errors.page_not_found'));
|
|
|
|
}
|
|
|
|
|
|
|
|
return $page;
|
|
|
|
}
|
|
|
|
|
2018-10-13 06:27:55 -04:00
|
|
|
/**
|
2019-10-05 07:55:01 -04:00
|
|
|
* Get a page its book and own slug.
|
|
|
|
* @throws NotFoundException
|
2018-10-13 06:27:55 -04:00
|
|
|
*/
|
2019-10-05 07:55:01 -04:00
|
|
|
public function getBySlug(string $bookSlug, string $pageSlug): Page
|
2018-10-13 06:27:55 -04:00
|
|
|
{
|
2019-10-05 07:55:01 -04:00
|
|
|
$page = Page::visible()->whereSlugs($bookSlug, $pageSlug)->first();
|
|
|
|
|
|
|
|
if (!$page) {
|
|
|
|
throw new NotFoundException(trans('errors.page_not_found'));
|
|
|
|
}
|
|
|
|
|
|
|
|
return $page;
|
2018-10-13 06:27:55 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2019-10-05 07:55:01 -04:00
|
|
|
* Get a page by its old slug but checking the revisions table
|
|
|
|
* for the last revision that matched the given page and book slug.
|
2018-10-13 06:27:55 -04:00
|
|
|
*/
|
2019-10-05 07:55:01 -04:00
|
|
|
public function getByOldSlug(string $bookSlug, string $pageSlug): ?Page
|
2018-10-13 06:27:55 -04:00
|
|
|
{
|
2019-10-05 07:55:01 -04:00
|
|
|
$revision = PageRevision::query()
|
|
|
|
->whereHas('page', function (Builder $query) {
|
|
|
|
$query->visible();
|
2018-10-13 06:27:55 -04:00
|
|
|
})
|
2019-10-05 07:55:01 -04:00
|
|
|
->where('slug', '=', $pageSlug)
|
2018-10-13 06:27:55 -04:00
|
|
|
->where('type', '=', 'version')
|
|
|
|
->where('book_slug', '=', $bookSlug)
|
|
|
|
->orderBy('created_at', 'desc')
|
2019-10-05 07:55:01 -04:00
|
|
|
->with('page')
|
|
|
|
->first();
|
|
|
|
return $revision ? $revision->page : null;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get pages that have been marked as a template.
|
|
|
|
*/
|
|
|
|
public function getTemplates(int $count = 10, int $page = 1, string $search = ''): LengthAwarePaginator
|
|
|
|
{
|
|
|
|
$query = Page::visible()
|
|
|
|
->where('template', '=', true)
|
|
|
|
->orderBy('name', 'asc')
|
|
|
|
->skip(($page - 1) * $count)
|
|
|
|
->take($count);
|
|
|
|
|
|
|
|
if ($search) {
|
|
|
|
$query->where('name', 'like', '%' . $search . '%');
|
|
|
|
}
|
|
|
|
|
|
|
|
$paginator = $query->paginate($count, ['*'], 'page', $page);
|
|
|
|
$paginator->withPath('/templates');
|
|
|
|
|
|
|
|
return $paginator;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get a parent item via slugs.
|
|
|
|
*/
|
|
|
|
public function getParentFromSlugs(string $bookSlug, string $chapterSlug = null): Entity
|
|
|
|
{
|
|
|
|
if ($chapterSlug !== null) {
|
|
|
|
return $chapter = Chapter::visible()->whereSlugs($bookSlug, $chapterSlug)->firstOrFail();
|
|
|
|
}
|
|
|
|
|
|
|
|
return Book::visible()->where('slug', '=', $bookSlug)->firstOrFail();
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the draft copy of the given page for the current user.
|
|
|
|
*/
|
|
|
|
public function getUserDraft(Page $page): ?PageRevision
|
|
|
|
{
|
|
|
|
$revision = $this->getUserDraftQuery($page)->first();
|
|
|
|
return $revision;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get a new draft page belonging to the given parent entity.
|
|
|
|
*/
|
|
|
|
public function getNewDraftPage(Entity $parent)
|
|
|
|
{
|
|
|
|
$page = (new Page())->forceFill([
|
|
|
|
'name' => trans('entities.pages_initial_name'),
|
|
|
|
'created_by' => user()->id,
|
|
|
|
'updated_by' => user()->id,
|
|
|
|
'draft' => true,
|
|
|
|
]);
|
|
|
|
|
|
|
|
if ($parent instanceof Chapter) {
|
|
|
|
$page->chapter_id = $parent->id;
|
|
|
|
$page->book_id = $parent->book_id;
|
|
|
|
} else {
|
|
|
|
$page->book_id = $parent->id;
|
|
|
|
}
|
|
|
|
|
|
|
|
$page->save();
|
|
|
|
$page->refresh()->rebuildPermissions();
|
|
|
|
return $page;
|
2018-10-13 06:27:55 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2019-10-05 07:55:01 -04:00
|
|
|
* Publish a draft page to make it a live, non-draft page.
|
2018-10-13 06:27:55 -04:00
|
|
|
*/
|
2019-10-05 07:55:01 -04:00
|
|
|
public function publishDraft(Page $draft, array $input): Page
|
|
|
|
{
|
|
|
|
$this->baseRepo->update($draft, $input);
|
2020-11-22 09:56:19 -05:00
|
|
|
$this->updateTemplateStatusAndContentFromInput($draft, $input);
|
2019-10-05 07:55:01 -04:00
|
|
|
|
|
|
|
$draft->draft = false;
|
|
|
|
$draft->revision_count = 1;
|
|
|
|
$draft->priority = $this->getNewPriority($draft);
|
|
|
|
$draft->refreshSlug();
|
|
|
|
$draft->save();
|
|
|
|
|
|
|
|
$this->savePageRevision($draft, trans('entities.pages_initial_revision'));
|
|
|
|
$draft->indexForSearch();
|
2020-11-07 17:37:27 -05:00
|
|
|
$draft->refresh();
|
|
|
|
|
2020-11-07 18:15:13 -05:00
|
|
|
Activity::addForEntity($draft, ActivityType::PAGE_CREATE);
|
2020-11-07 17:37:27 -05:00
|
|
|
return $draft;
|
2019-10-05 07:55:01 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Update a page in the system.
|
|
|
|
*/
|
|
|
|
public function update(Page $page, array $input): Page
|
2018-10-13 06:27:55 -04:00
|
|
|
{
|
|
|
|
// Hold the old details to compare later
|
|
|
|
$oldHtml = $page->html;
|
|
|
|
$oldName = $page->name;
|
|
|
|
|
2020-11-22 09:56:19 -05:00
|
|
|
$this->updateTemplateStatusAndContentFromInput($page, $input);
|
2019-10-05 07:55:01 -04:00
|
|
|
$this->baseRepo->update($page, $input);
|
|
|
|
|
2018-10-13 06:27:55 -04:00
|
|
|
// Update with new details
|
2019-09-19 19:18:28 -04:00
|
|
|
$page->revision_count++;
|
|
|
|
|
2018-10-13 06:27:55 -04:00
|
|
|
if (setting('app-editor') !== 'markdown') {
|
|
|
|
$page->markdown = '';
|
|
|
|
}
|
2019-09-19 19:18:28 -04:00
|
|
|
|
2018-10-13 06:27:55 -04:00
|
|
|
$page->save();
|
|
|
|
|
|
|
|
// Remove all update drafts for this user & page.
|
2019-10-05 07:55:01 -04:00
|
|
|
$this->getUserDraftQuery($page)->delete();
|
2018-10-13 06:27:55 -04:00
|
|
|
|
|
|
|
// Save a revision after updating
|
2019-07-07 08:45:46 -04:00
|
|
|
$summary = $input['summary'] ?? null;
|
|
|
|
if ($oldHtml !== $input['html'] || $oldName !== $input['name'] || $summary !== null) {
|
|
|
|
$this->savePageRevision($page, $summary);
|
2018-10-13 06:27:55 -04:00
|
|
|
}
|
|
|
|
|
2020-11-07 18:15:13 -05:00
|
|
|
Activity::addForEntity($page, ActivityType::PAGE_UPDATE);
|
2018-10-13 06:27:55 -04:00
|
|
|
return $page;
|
|
|
|
}
|
|
|
|
|
2020-11-22 09:56:19 -05:00
|
|
|
protected function updateTemplateStatusAndContentFromInput(Page $page, array $input)
|
|
|
|
{
|
|
|
|
if (isset($input['template']) && userCan('templates-manage')) {
|
|
|
|
$page->template = ($input['template'] === 'true');
|
|
|
|
}
|
|
|
|
|
|
|
|
$pageContent = new PageContent($page);
|
|
|
|
if (isset($input['html'])) {
|
|
|
|
$pageContent->setNewHTML($input['html']);
|
|
|
|
} else {
|
|
|
|
$pageContent->setNewMarkdown($input['markdown']);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-10-13 06:27:55 -04:00
|
|
|
/**
|
|
|
|
* Saves a page revision into the system.
|
|
|
|
*/
|
2019-10-05 07:55:01 -04:00
|
|
|
protected function savePageRevision(Page $page, string $summary = null)
|
2018-10-13 06:27:55 -04:00
|
|
|
{
|
2020-05-22 19:28:41 -04:00
|
|
|
$revision = new PageRevision($page->getAttributes());
|
2019-10-05 07:55:01 -04:00
|
|
|
|
2018-10-13 06:27:55 -04:00
|
|
|
if (setting('app-editor') !== 'markdown') {
|
|
|
|
$revision->markdown = '';
|
|
|
|
}
|
2019-10-05 07:55:01 -04:00
|
|
|
|
2018-10-13 06:27:55 -04:00
|
|
|
$revision->page_id = $page->id;
|
|
|
|
$revision->slug = $page->slug;
|
|
|
|
$revision->book_slug = $page->book->slug;
|
|
|
|
$revision->created_by = user()->id;
|
|
|
|
$revision->created_at = $page->updated_at;
|
|
|
|
$revision->type = 'version';
|
|
|
|
$revision->summary = $summary;
|
|
|
|
$revision->revision_number = $page->revision_count;
|
|
|
|
$revision->save();
|
|
|
|
|
2019-10-05 07:55:01 -04:00
|
|
|
$this->deleteOldRevisions($page);
|
2018-10-13 06:27:55 -04:00
|
|
|
return $revision;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Save a page update draft.
|
|
|
|
*/
|
2019-10-05 07:55:01 -04:00
|
|
|
public function updatePageDraft(Page $page, array $input)
|
2018-10-13 06:27:55 -04:00
|
|
|
{
|
|
|
|
// If the page itself is a draft simply update that
|
|
|
|
if ($page->draft) {
|
2019-10-05 07:55:01 -04:00
|
|
|
if (isset($input['html'])) {
|
2020-11-22 09:56:19 -05:00
|
|
|
(new PageContent($page))->setNewHTML($input['html']);
|
2018-10-13 06:27:55 -04:00
|
|
|
}
|
2020-11-22 09:56:19 -05:00
|
|
|
$page->fill($input);
|
2018-10-13 06:27:55 -04:00
|
|
|
$page->save();
|
|
|
|
return $page;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Otherwise save the data to a revision
|
2019-10-05 07:55:01 -04:00
|
|
|
$draft = $this->getPageRevisionToUpdate($page);
|
|
|
|
$draft->fill($input);
|
2018-10-13 06:27:55 -04:00
|
|
|
if (setting('app-editor') !== 'markdown') {
|
|
|
|
$draft->markdown = '';
|
|
|
|
}
|
|
|
|
|
|
|
|
$draft->save();
|
|
|
|
return $draft;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2019-10-05 07:55:01 -04:00
|
|
|
* Destroy a page from the system.
|
2020-09-27 18:24:33 -04:00
|
|
|
* @throws Exception
|
2018-10-13 06:27:55 -04:00
|
|
|
*/
|
2019-10-05 07:55:01 -04:00
|
|
|
public function destroy(Page $page)
|
2018-10-13 06:27:55 -04:00
|
|
|
{
|
2019-10-05 07:55:01 -04:00
|
|
|
$trashCan = new TrashCan();
|
2020-09-27 18:24:33 -04:00
|
|
|
$trashCan->softDestroyPage($page);
|
2020-11-07 18:15:13 -05:00
|
|
|
Activity::addForEntity($page, ActivityType::PAGE_DELETE);
|
2020-11-07 08:58:23 -05:00
|
|
|
$trashCan->autoClearOld();
|
2018-10-13 06:27:55 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2019-10-05 07:55:01 -04:00
|
|
|
* Restores a revision's content back into a page.
|
2018-10-13 06:27:55 -04:00
|
|
|
*/
|
2019-10-05 07:55:01 -04:00
|
|
|
public function restoreRevision(Page $page, int $revisionId): Page
|
2018-10-13 06:27:55 -04:00
|
|
|
{
|
2019-10-05 07:55:01 -04:00
|
|
|
$page->revision_count++;
|
|
|
|
$this->savePageRevision($page);
|
2018-10-13 06:27:55 -04:00
|
|
|
|
2019-10-05 07:55:01 -04:00
|
|
|
$revision = $page->revisions()->where('id', '=', $revisionId)->first();
|
|
|
|
$page->fill($revision->toArray());
|
|
|
|
$content = new PageContent($page);
|
2020-05-23 07:28:14 -04:00
|
|
|
$content->setNewHTML($revision->html);
|
2019-10-05 07:55:01 -04:00
|
|
|
$page->updated_by = user()->id;
|
|
|
|
$page->refreshSlug();
|
|
|
|
$page->save();
|
|
|
|
|
|
|
|
$page->indexForSearch();
|
2020-11-07 18:15:13 -05:00
|
|
|
Activity::addForEntity($page, ActivityType::PAGE_RESTORE);
|
2019-10-05 07:55:01 -04:00
|
|
|
return $page;
|
2018-10-13 06:27:55 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2019-10-05 07:55:01 -04:00
|
|
|
* Move the given page into a new parent book or chapter.
|
|
|
|
* The $parentIdentifier must be a string of the following format:
|
|
|
|
* 'book:<id>' (book:5)
|
|
|
|
* @throws MoveOperationException
|
|
|
|
* @throws PermissionsException
|
2018-10-13 06:27:55 -04:00
|
|
|
*/
|
2020-11-07 17:37:27 -05:00
|
|
|
public function move(Page $page, string $parentIdentifier): Entity
|
2018-10-13 06:27:55 -04:00
|
|
|
{
|
2019-10-05 07:55:01 -04:00
|
|
|
$parent = $this->findParentByIdentifier($parentIdentifier);
|
|
|
|
if ($parent === null) {
|
|
|
|
throw new MoveOperationException('Book or chapter to move page into not found');
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!userCan('page-create', $parent)) {
|
|
|
|
throw new PermissionsException('User does not have permission to create a page within the new parent');
|
2018-10-13 06:27:55 -04:00
|
|
|
}
|
2019-10-05 07:55:01 -04:00
|
|
|
|
2019-10-29 18:33:09 -04:00
|
|
|
$page->chapter_id = ($parent instanceof Chapter) ? $parent->id : null;
|
2019-10-05 07:55:01 -04:00
|
|
|
$page->changeBook($parent instanceof Book ? $parent->id : $parent->book->id);
|
|
|
|
$page->rebuildPermissions();
|
2019-10-28 11:53:48 -04:00
|
|
|
|
2020-11-07 18:15:13 -05:00
|
|
|
Activity::addForEntity($page, ActivityType::PAGE_MOVE);
|
2020-11-07 17:37:27 -05:00
|
|
|
return $parent;
|
2018-10-13 06:27:55 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2019-10-05 07:55:01 -04:00
|
|
|
* Copy an existing page in the system.
|
|
|
|
* Optionally providing a new parent via string identifier and a new name.
|
|
|
|
* @throws MoveOperationException
|
|
|
|
* @throws PermissionsException
|
2018-10-13 06:27:55 -04:00
|
|
|
*/
|
2019-10-05 07:55:01 -04:00
|
|
|
public function copy(Page $page, string $parentIdentifier = null, string $newName = null): Page
|
2018-10-13 06:27:55 -04:00
|
|
|
{
|
2020-11-02 17:47:48 -05:00
|
|
|
$parent = $parentIdentifier ? $this->findParentByIdentifier($parentIdentifier) : $page->getParent();
|
2019-10-05 07:55:01 -04:00
|
|
|
if ($parent === null) {
|
|
|
|
throw new MoveOperationException('Book or chapter to move page into not found');
|
|
|
|
}
|
2018-10-13 06:27:55 -04:00
|
|
|
|
2019-10-05 07:55:01 -04:00
|
|
|
if (!userCan('page-create', $parent)) {
|
|
|
|
throw new PermissionsException('User does not have permission to create a page within the new parent');
|
2018-10-13 06:27:55 -04:00
|
|
|
}
|
|
|
|
|
2019-10-05 07:55:01 -04:00
|
|
|
$copyPage = $this->getNewDraftPage($parent);
|
|
|
|
$pageData = $page->getAttributes();
|
2018-10-13 06:27:55 -04:00
|
|
|
|
2019-10-05 07:55:01 -04:00
|
|
|
// Update name
|
|
|
|
if (!empty($newName)) {
|
|
|
|
$pageData['name'] = $newName;
|
|
|
|
}
|
2018-10-13 06:27:55 -04:00
|
|
|
|
2019-10-05 07:55:01 -04:00
|
|
|
// Copy tags from previous page if set
|
|
|
|
if ($page->tags) {
|
|
|
|
$pageData['tags'] = [];
|
|
|
|
foreach ($page->tags as $tag) {
|
|
|
|
$pageData['tags'][] = ['name' => $tag->name, 'value' => $tag->value];
|
|
|
|
}
|
|
|
|
}
|
2018-10-13 06:27:55 -04:00
|
|
|
|
2019-10-05 07:55:01 -04:00
|
|
|
return $this->publishDraft($copyPage, $pageData);
|
2018-10-13 06:27:55 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2019-10-05 07:55:01 -04:00
|
|
|
* Find a page parent entity via a identifier string in the format:
|
|
|
|
* {type}:{id}
|
|
|
|
* Example: (book:5)
|
|
|
|
* @throws MoveOperationException
|
2018-10-13 06:27:55 -04:00
|
|
|
*/
|
2019-10-05 07:55:01 -04:00
|
|
|
protected function findParentByIdentifier(string $identifier): ?Entity
|
2018-10-13 06:27:55 -04:00
|
|
|
{
|
2019-10-05 07:55:01 -04:00
|
|
|
$stringExploded = explode(':', $identifier);
|
|
|
|
$entityType = $stringExploded[0];
|
|
|
|
$entityId = intval($stringExploded[1]);
|
|
|
|
|
|
|
|
if ($entityType !== 'book' && $entityType !== 'chapter') {
|
|
|
|
throw new MoveOperationException('Pages can only be in books or chapters');
|
2018-10-13 06:27:55 -04:00
|
|
|
}
|
|
|
|
|
2019-10-05 07:55:01 -04:00
|
|
|
$parentClass = $entityType === 'book' ? Book::class : Chapter::class;
|
|
|
|
return $parentClass::visible()->where('id', '=', $entityId)->first();
|
2018-10-13 06:27:55 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2019-10-05 07:55:01 -04:00
|
|
|
* Update the permissions of a page.
|
2018-10-13 06:27:55 -04:00
|
|
|
*/
|
2019-10-05 07:55:01 -04:00
|
|
|
public function updatePermissions(Page $page, bool $restricted, Collection $permissions = null)
|
2018-10-13 06:27:55 -04:00
|
|
|
{
|
2019-10-05 07:55:01 -04:00
|
|
|
$this->baseRepo->updatePermissions($page, $restricted, $permissions);
|
2018-10-13 06:27:55 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Change the page's parent to the given entity.
|
|
|
|
*/
|
2019-10-05 07:55:01 -04:00
|
|
|
protected function changeParent(Page $page, Entity $parent)
|
2018-10-13 06:27:55 -04:00
|
|
|
{
|
2019-10-05 07:55:01 -04:00
|
|
|
$book = ($parent instanceof Book) ? $parent : $parent->book;
|
|
|
|
$page->chapter_id = ($parent instanceof Chapter) ? $parent->id : 0;
|
2018-10-13 06:27:55 -04:00
|
|
|
$page->save();
|
2019-09-19 19:18:28 -04:00
|
|
|
|
2018-10-13 06:27:55 -04:00
|
|
|
if ($page->book->id !== $book->id) {
|
2019-10-05 07:55:01 -04:00
|
|
|
$page->changeBook($book->id);
|
2018-10-13 06:27:55 -04:00
|
|
|
}
|
2019-09-19 19:18:28 -04:00
|
|
|
|
2018-10-13 06:27:55 -04:00
|
|
|
$page->load('book');
|
2019-09-19 19:18:28 -04:00
|
|
|
$book->rebuildPermissions();
|
2018-10-13 06:27:55 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2019-10-05 07:55:01 -04:00
|
|
|
* Get a page revision to update for the given page.
|
|
|
|
* Checks for an existing revisions before providing a fresh one.
|
2018-10-13 06:27:55 -04:00
|
|
|
*/
|
2019-10-05 07:55:01 -04:00
|
|
|
protected function getPageRevisionToUpdate(Page $page): PageRevision
|
2018-10-13 06:27:55 -04:00
|
|
|
{
|
2019-10-05 07:55:01 -04:00
|
|
|
$drafts = $this->getUserDraftQuery($page)->get();
|
|
|
|
if ($drafts->count() > 0) {
|
|
|
|
return $drafts->first();
|
2018-10-13 06:27:55 -04:00
|
|
|
}
|
|
|
|
|
2019-10-05 07:55:01 -04:00
|
|
|
$draft = new PageRevision();
|
|
|
|
$draft->page_id = $page->id;
|
|
|
|
$draft->slug = $page->slug;
|
|
|
|
$draft->book_slug = $page->book->slug;
|
|
|
|
$draft->created_by = user()->id;
|
|
|
|
$draft->type = 'update_draft';
|
|
|
|
return $draft;
|
|
|
|
}
|
2018-10-13 06:27:55 -04:00
|
|
|
|
2019-10-05 07:55:01 -04:00
|
|
|
/**
|
|
|
|
* Delete old revisions, for the given page, from the system.
|
|
|
|
*/
|
|
|
|
protected function deleteOldRevisions(Page $page)
|
|
|
|
{
|
|
|
|
$revisionLimit = config('app.revision_limit');
|
|
|
|
if ($revisionLimit === false) {
|
|
|
|
return;
|
2018-10-13 06:27:55 -04:00
|
|
|
}
|
|
|
|
|
2019-10-05 07:55:01 -04:00
|
|
|
$revisionsToDelete = PageRevision::query()
|
|
|
|
->where('page_id', '=', $page->id)
|
|
|
|
->orderBy('created_at', 'desc')
|
|
|
|
->skip(intval($revisionLimit))
|
|
|
|
->take(10)
|
|
|
|
->get(['id']);
|
|
|
|
if ($revisionsToDelete->count() > 0) {
|
|
|
|
PageRevision::query()->whereIn('id', $revisionsToDelete->pluck('id'))->delete();
|
|
|
|
}
|
2018-10-13 06:27:55 -04:00
|
|
|
}
|
2019-08-11 15:04:43 -04:00
|
|
|
|
|
|
|
/**
|
2019-10-05 07:55:01 -04:00
|
|
|
* Get a new priority for a page
|
2019-08-11 15:04:43 -04:00
|
|
|
*/
|
2019-10-05 07:55:01 -04:00
|
|
|
protected function getNewPriority(Page $page): int
|
2019-08-11 15:04:43 -04:00
|
|
|
{
|
2020-11-02 17:47:48 -05:00
|
|
|
$parent = $page->getParent();
|
|
|
|
if ($parent instanceof Chapter) {
|
|
|
|
$lastPage = $parent->pages('desc')->first();
|
2019-10-05 07:55:01 -04:00
|
|
|
return $lastPage ? $lastPage->priority + 1 : 0;
|
2019-08-11 15:04:43 -04:00
|
|
|
}
|
|
|
|
|
2019-10-05 07:55:01 -04:00
|
|
|
return (new BookContents($page->book))->getLastPriority() + 1;
|
|
|
|
}
|
2019-08-11 15:04:43 -04:00
|
|
|
|
2019-10-05 07:55:01 -04:00
|
|
|
/**
|
|
|
|
* Get the query to find the user's draft copies of the given page.
|
|
|
|
*/
|
|
|
|
protected function getUserDraftQuery(Page $page)
|
|
|
|
{
|
|
|
|
return PageRevision::query()->where('created_by', '=', user()->id)
|
|
|
|
->where('type', 'update_draft')
|
|
|
|
->where('page_id', '=', $page->id)
|
|
|
|
->orderBy('created_at', 'desc');
|
2019-08-11 15:04:43 -04:00
|
|
|
}
|
2019-01-27 05:29:23 -05:00
|
|
|
}
|