-<?php namespace BookStack\Entities\Repos;
+<?php
-use BookStack\Actions\ActivityType;
+namespace BookStack\Entities\Repos;
+
+use BookStack\Activity\ActivityType;
use BookStack\Entities\Models\Book;
use BookStack\Entities\Models\Chapter;
use BookStack\Entities\Models\Entity;
+use BookStack\Entities\Models\Page;
+use BookStack\Entities\Models\PageRevision;
use BookStack\Entities\Tools\BookContents;
use BookStack\Entities\Tools\PageContent;
+use BookStack\Entities\Tools\PageEditorData;
use BookStack\Entities\Tools\TrashCan;
-use BookStack\Entities\Models\Page;
-use BookStack\Entities\Models\PageRevision;
use BookStack\Exceptions\MoveOperationException;
use BookStack\Exceptions\NotFoundException;
use BookStack\Exceptions\PermissionsException;
use BookStack\Facades\Activity;
+use BookStack\References\ReferenceStore;
+use BookStack\References\ReferenceUpdater;
use Exception;
-use Illuminate\Database\Eloquent\Builder;
use Illuminate\Pagination\LengthAwarePaginator;
-use Illuminate\Support\Collection;
class PageRepo
{
-
- protected $baseRepo;
-
- /**
- * PageRepo constructor.
- */
- public function __construct(BaseRepo $baseRepo)
- {
- $this->baseRepo = $baseRepo;
+ public function __construct(
+ protected BaseRepo $baseRepo,
+ protected RevisionRepo $revisionRepo,
+ protected ReferenceStore $referenceStore,
+ protected ReferenceUpdater $referenceUpdater
+ ) {
}
/**
* Get a page by ID.
+ *
* @throws NotFoundException
*/
public function getById(int $id, array $relations = ['book']): Page
{
+ /** @var Page $page */
$page = Page::visible()->with($relations)->find($id);
if (!$page) {
/**
* Get a page its book and own slug.
+ *
* @throws NotFoundException
*/
public function getBySlug(string $bookSlug, string $pageSlug): Page
*/
public function getByOldSlug(string $bookSlug, string $pageSlug): ?Page
{
- $revision = PageRevision::query()
- ->whereHas('page', function (Builder $query) {
- $query->visible();
- })
- ->where('slug', '=', $pageSlug)
- ->where('type', '=', 'version')
- ->where('book_slug', '=', $bookSlug)
- ->orderBy('created_at', 'desc')
- ->with('page')
- ->first();
- return $revision ? $revision->page : null;
+ $revision = $this->revisionRepo->getBySlugs($bookSlug, $pageSlug);
+
+ return $revision->page ?? null;
}
/**
public function getParentFromSlugs(string $bookSlug, string $chapterSlug = null): Entity
{
if ($chapterSlug !== null) {
- return $chapter = Chapter::visible()->whereSlugs($bookSlug, $chapterSlug)->firstOrFail();
+ return Chapter::visible()->whereSlugs($bookSlug, $chapterSlug)->firstOrFail();
}
return Book::visible()->where('slug', '=', $bookSlug)->firstOrFail();
*/
public function getUserDraft(Page $page): ?PageRevision
{
- $revision = $this->getUserDraftQuery($page)->first();
- return $revision;
+ return $this->revisionRepo->getLatestDraftForCurrentUser($page);
}
/**
public function getNewDraftPage(Entity $parent)
{
$page = (new Page())->forceFill([
- 'name' => trans('entities.pages_initial_name'),
+ 'name' => trans('entities.pages_initial_name'),
'created_by' => user()->id,
- 'owned_by' => user()->id,
+ 'owned_by' => user()->id,
'updated_by' => user()->id,
- 'draft' => true,
+ 'draft' => true,
]);
if ($parent instanceof Chapter) {
$page->save();
$page->refresh()->rebuildPermissions();
+
return $page;
}
*/
public function publishDraft(Page $draft, array $input): Page
{
- $this->baseRepo->update($draft, $input);
- $this->updateTemplateStatusAndContentFromInput($draft, $input);
-
$draft->draft = false;
$draft->revision_count = 1;
$draft->priority = $this->getNewPriority($draft);
- $draft->refreshSlug();
- $draft->save();
+ $this->updateTemplateStatusAndContentFromInput($draft, $input);
+ $this->baseRepo->update($draft, $input);
- $this->savePageRevision($draft, trans('entities.pages_initial_revision'));
- $draft->indexForSearch();
+ $this->revisionRepo->storeNewForPage($draft, trans('entities.pages_initial_revision'));
+ $this->referenceStore->updateForPage($draft);
$draft->refresh();
- Activity::addForEntity($draft, ActivityType::PAGE_CREATE);
+ Activity::add(ActivityType::PAGE_CREATE, $draft);
+
return $draft;
}
// Hold the old details to compare later
$oldHtml = $page->html;
$oldName = $page->name;
+ $oldMarkdown = $page->markdown;
$this->updateTemplateStatusAndContentFromInput($page, $input);
$this->baseRepo->update($page, $input);
+ $this->referenceStore->updateForPage($page);
// Update with new details
$page->revision_count++;
-
- if (setting('app-editor') !== 'markdown') {
- $page->markdown = '';
- }
-
$page->save();
// Remove all update drafts for this user & page.
- $this->getUserDraftQuery($page)->delete();
+ $this->revisionRepo->deleteDraftsForCurrentUser($page);
// Save a revision after updating
- $summary = $input['summary'] ?? null;
- if ($oldHtml !== $input['html'] || $oldName !== $input['name'] || $summary !== null) {
- $this->savePageRevision($page, $summary);
+ $summary = trim($input['summary'] ?? '');
+ $htmlChanged = isset($input['html']) && $input['html'] !== $oldHtml;
+ $nameChanged = isset($input['name']) && $input['name'] !== $oldName;
+ $markdownChanged = isset($input['markdown']) && $input['markdown'] !== $oldMarkdown;
+ if ($htmlChanged || $nameChanged || $markdownChanged || $summary) {
+ $this->revisionRepo->storeNewForPage($page, $summary);
}
- Activity::addForEntity($page, ActivityType::PAGE_UPDATE);
+ Activity::add(ActivityType::PAGE_UPDATE, $page);
+
return $page;
}
}
$pageContent = new PageContent($page);
- if (!empty($input['markdown'] ?? '')) {
+ $currentEditor = $page->editor ?: PageEditorData::getSystemDefaultEditor();
+ $newEditor = $currentEditor;
+
+ $haveInput = isset($input['markdown']) || isset($input['html']);
+ $inputEmpty = empty($input['markdown']) && empty($input['html']);
+
+ if ($haveInput && $inputEmpty) {
+ $pageContent->setNewHTML('');
+ } elseif (!empty($input['markdown']) && is_string($input['markdown'])) {
+ $newEditor = 'markdown';
$pageContent->setNewMarkdown($input['markdown']);
- } else {
+ } elseif (isset($input['html'])) {
+ $newEditor = 'wysiwyg';
$pageContent->setNewHTML($input['html']);
}
- }
-
- /**
- * Saves a page revision into the system.
- */
- protected function savePageRevision(Page $page, string $summary = null): PageRevision
- {
- $revision = new PageRevision($page->getAttributes());
- if (setting('app-editor') !== 'markdown') {
- $revision->markdown = '';
+ if ($newEditor !== $currentEditor && userCan('editor-change')) {
+ $page->editor = $newEditor;
}
-
- $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();
-
- $this->deleteOldRevisions($page);
- return $revision;
}
/**
{
// If the page itself is a draft simply update that
if ($page->draft) {
- if (isset($input['html'])) {
- (new PageContent($page))->setNewHTML($input['html']);
- }
+ $this->updateTemplateStatusAndContentFromInput($page, $input);
$page->fill($input);
$page->save();
+
return $page;
}
- // Otherwise save the data to a revision
- $draft = $this->getPageRevisionToUpdate($page);
+ // Otherwise, save the data to a revision
+ $draft = $this->revisionRepo->getNewDraftForCurrentUser($page);
$draft->fill($input);
- if (setting('app-editor') !== 'markdown') {
+
+ if (!empty($input['markdown'])) {
+ $draft->markdown = $input['markdown'];
+ $draft->html = '';
+ } else {
+ $draft->html = $input['html'];
$draft->markdown = '';
}
$draft->save();
+
return $draft;
}
/**
* Destroy a page from the system.
+ *
* @throws Exception
*/
public function destroy(Page $page)
{
$trashCan = new TrashCan();
$trashCan->softDestroyPage($page);
- Activity::addForEntity($page, ActivityType::PAGE_DELETE);
+ Activity::add(ActivityType::PAGE_DELETE, $page);
$trashCan->autoClearOld();
}
*/
public function restoreRevision(Page $page, int $revisionId): Page
{
+ $oldUrl = $page->getUrl();
$page->revision_count++;
+
+ /** @var PageRevision $revision */
$revision = $page->revisions()->where('id', '=', $revisionId)->first();
$page->fill($revision->toArray());
$content = new PageContent($page);
- $content->setNewHTML($revision->html);
+
+ if (!empty($revision->markdown)) {
+ $content->setNewMarkdown($revision->markdown);
+ } else {
+ $content->setNewHTML($revision->html);
+ }
+
$page->updated_by = user()->id;
$page->refreshSlug();
$page->save();
$page->indexForSearch();
+ $this->referenceStore->updateForPage($page);
$summary = trans('entities.pages_revision_restored_from', ['id' => strval($revisionId), 'summary' => $revision->summary]);
- $this->savePageRevision($page, $summary);
+ $this->revisionRepo->storeNewForPage($page, $summary);
+
+ if ($oldUrl !== $page->getUrl()) {
+ $this->referenceUpdater->updateEntityPageReferences($page, $oldUrl);
+ }
+
+ Activity::add(ActivityType::PAGE_RESTORE, $page);
+ Activity::add(ActivityType::REVISION_RESTORE, $revision);
- Activity::addForEntity($page, ActivityType::PAGE_RESTORE);
return $page;
}
/**
* 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)
+ * 'book:<id>' (book:5).
+ *
* @throws MoveOperationException
* @throws PermissionsException
*/
public function move(Page $page, string $parentIdentifier): Entity
{
$parent = $this->findParentByIdentifier($parentIdentifier);
- if ($parent === null) {
+ if (is_null($parent)) {
throw new MoveOperationException('Book or chapter to move page into not found');
}
}
$page->chapter_id = ($parent instanceof Chapter) ? $parent->id : null;
- $page->changeBook($parent instanceof Book ? $parent->id : $parent->book->id);
+ $newBookId = ($parent instanceof Chapter) ? $parent->book->id : $parent->id;
+ $page->changeBook($newBookId);
$page->rebuildPermissions();
- Activity::addForEntity($page, ActivityType::PAGE_MOVE);
- return $parent;
- }
-
- /**
- * Copy an existing page in the system.
- * Optionally providing a new parent via string identifier and a new name.
- * @throws MoveOperationException
- * @throws PermissionsException
- */
- public function copy(Page $page, string $parentIdentifier = null, string $newName = null): Page
- {
- $parent = $parentIdentifier ? $this->findParentByIdentifier($parentIdentifier) : $page->getParent();
- 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');
- }
-
- $copyPage = $this->getNewDraftPage($parent);
- $pageData = $page->getAttributes();
-
- // Update name
- if (!empty($newName)) {
- $pageData['name'] = $newName;
- }
-
- // 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];
- }
- }
+ Activity::add(ActivityType::PAGE_MOVE, $page);
- return $this->publishDraft($copyPage, $pageData);
+ return $parent;
}
/**
- * Find a page parent entity via a identifier string in the format:
+ * Find a page parent entity via an identifier string in the format:
* {type}:{id}
- * Example: (book:5)
+ * Example: (book:5).
+ *
* @throws MoveOperationException
*/
- protected function findParentByIdentifier(string $identifier): ?Entity
+ public function findParentByIdentifier(string $identifier): ?Entity
{
$stringExploded = explode(':', $identifier);
$entityType = $stringExploded[0];
}
$parentClass = $entityType === 'book' ? Book::class : Chapter::class;
- return $parentClass::visible()->where('id', '=', $entityId)->first();
- }
-
- /**
- * Change the page's parent to the given entity.
- */
- protected function changeParent(Page $page, Entity $parent)
- {
- $book = ($parent instanceof Book) ? $parent : $parent->book;
- $page->chapter_id = ($parent instanceof Chapter) ? $parent->id : 0;
- $page->save();
-
- if ($page->book->id !== $book->id) {
- $page->changeBook($book->id);
- }
-
- $page->load('book');
- $book->rebuildPermissions();
- }
-
- /**
- * Get a page revision to update for the given page.
- * Checks for an existing revisions before providing a fresh one.
- */
- protected function getPageRevisionToUpdate(Page $page): PageRevision
- {
- $drafts = $this->getUserDraftQuery($page)->get();
- if ($drafts->count() > 0) {
- return $drafts->first();
- }
-
- $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;
- }
-
- /**
- * Delete old revisions, for the given page, from the system.
- */
- protected function deleteOldRevisions(Page $page)
- {
- $revisionLimit = config('app.revision_limit');
- if ($revisionLimit === false) {
- return;
- }
- $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();
- }
+ return $parentClass::visible()->where('id', '=', $entityId)->first();
}
/**
- * Get a new priority for a page
+ * Get a new priority for a page.
*/
protected function getNewPriority(Page $page): int
{
$parent = $page->getParent();
if ($parent instanceof Chapter) {
+ /** @var ?Page $lastPage */
$lastPage = $parent->pages('desc')->first();
+
return $lastPage ? $lastPage->priority + 1 : 0;
}
return (new BookContents($page->book))->getLastPriority() + 1;
}
-
- /**
- * 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');
- }
}
projects / bookstack / blobdiff