BookStack Code Mirror - bookstack/blob - app/Entities/Repos/PageRepo.php

   1 <?php
   2
   3 namespace BookStack\Entities\Repos;
   4
   5 use BookStack\Activity\ActivityType;
   6 use BookStack\Entities\Models\Book;
   7 use BookStack\Entities\Models\Chapter;
   8 use BookStack\Entities\Models\Entity;
   9 use BookStack\Entities\Models\Page;
  10 use BookStack\Entities\Models\PageRevision;
  11 use BookStack\Entities\Queries\EntityQueries;
  12 use BookStack\Entities\Tools\BookContents;
  13 use BookStack\Entities\Tools\PageContent;
  14 use BookStack\Entities\Tools\PageEditorData;
  15 use BookStack\Entities\Tools\TrashCan;
  16 use BookStack\Exceptions\MoveOperationException;
  17 use BookStack\Exceptions\PermissionsException;
  18 use BookStack\Facades\Activity;
  19 use BookStack\References\ReferenceStore;
  20 use BookStack\References\ReferenceUpdater;
  21 use Exception;
  22
  23 class PageRepo
  24 {
  25     public function __construct(
  26         protected BaseRepo $baseRepo,
  27         protected RevisionRepo $revisionRepo,
  28         protected EntityQueries $entityQueries,
  29         protected ReferenceStore $referenceStore,
  30         protected ReferenceUpdater $referenceUpdater
  31     ) {
  32     }
  33
  34     /**
  35      * Get a new draft page belonging to the given parent entity.
  36      */
  37     public function getNewDraftPage(Entity $parent)
  38     {
  39         $page = (new Page())->forceFill([
  40             'name'       => trans('entities.pages_initial_name'),
  41             'created_by' => user()->id,
  42             'owned_by'   => user()->id,
  43             'updated_by' => user()->id,
  44             'draft'      => true,
  45         ]);
  46
  47         if ($parent instanceof Chapter) {
  48             $page->chapter_id = $parent->id;
  49             $page->book_id = $parent->book_id;
  50         } else {
  51             $page->book_id = $parent->id;
  52         }
  53
  54         $defaultTemplate = $page->chapter->defaultTemplate ?? $page->book->defaultTemplate;
  55         if ($defaultTemplate && userCan('view', $defaultTemplate)) {
  56             $page->forceFill([
  57                 'html'  => $defaultTemplate->html,
  58                 'markdown' => $defaultTemplate->markdown,
  59             ]);
  60         }
  61
  62         $page->save();
  63         $page->refresh()->rebuildPermissions();
  64
  65         return $page;
  66     }
  67
  68     /**
  69      * Publish a draft page to make it a live, non-draft page.
  70      */
  71     public function publishDraft(Page $draft, array $input): Page
  72     {
  73         $draft->draft = false;
  74         $draft->revision_count = 1;
  75         $draft->priority = $this->getNewPriority($draft);
  76         $this->updateTemplateStatusAndContentFromInput($draft, $input);
  77         $this->baseRepo->update($draft, $input);
  78
  79         $this->revisionRepo->storeNewForPage($draft, trans('entities.pages_initial_revision'));
  80         $draft->refresh();
  81
  82         Activity::add(ActivityType::PAGE_CREATE, $draft);
  83
  84         return $draft;
  85     }
  86
  87     /**
  88      * Update a page in the system.
  89      */
  90     public function update(Page $page, array $input): Page
  91     {
  92         // Hold the old details to compare later
  93         $oldHtml = $page->html;
  94         $oldName = $page->name;
  95         $oldMarkdown = $page->markdown;
  96
  97         $this->updateTemplateStatusAndContentFromInput($page, $input);
  98         $this->baseRepo->update($page, $input);
  99
 100         // Update with new details
 101         $page->revision_count++;
 102         $page->save();
 103
 104         // Remove all update drafts for this user & page.
 105         $this->revisionRepo->deleteDraftsForCurrentUser($page);
 106
 107         // Save a revision after updating
 108         $summary = trim($input['summary'] ?? '');
 109         $htmlChanged = isset($input['html']) && $input['html'] !== $oldHtml;
 110         $nameChanged = isset($input['name']) && $input['name'] !== $oldName;
 111         $markdownChanged = isset($input['markdown']) && $input['markdown'] !== $oldMarkdown;
 112         if ($htmlChanged || $nameChanged || $markdownChanged || $summary) {
 113             $this->revisionRepo->storeNewForPage($page, $summary);
 114         }
 115
 116         Activity::add(ActivityType::PAGE_UPDATE, $page);
 117
 118         return $page;
 119     }
 120
 121     protected function updateTemplateStatusAndContentFromInput(Page $page, array $input)
 122     {
 123         if (isset($input['template']) && userCan('templates-manage')) {
 124             $page->template = ($input['template'] === 'true');
 125         }
 126
 127         $pageContent = new PageContent($page);
 128         $currentEditor = $page->editor ?: PageEditorData::getSystemDefaultEditor();
 129         $newEditor = $currentEditor;
 130
 131         $haveInput = isset($input['markdown']) || isset($input['html']);
 132         $inputEmpty = empty($input['markdown']) && empty($input['html']);
 133
 134         if ($haveInput && $inputEmpty) {
 135             $pageContent->setNewHTML('', user());
 136         } elseif (!empty($input['markdown']) && is_string($input['markdown'])) {
 137             $newEditor = 'markdown';
 138             $pageContent->setNewMarkdown($input['markdown'], user());
 139         } elseif (isset($input['html'])) {
 140             $newEditor = 'wysiwyg';
 141             $pageContent->setNewHTML($input['html'], user());
 142         }
 143
 144         if ($newEditor !== $currentEditor && userCan('editor-change')) {
 145             $page->editor = $newEditor;
 146         }
 147     }
 148
 149     /**
 150      * Save a page update draft.
 151      */
 152     public function updatePageDraft(Page $page, array $input)
 153     {
 154         // If the page itself is a draft simply update that
 155         if ($page->draft) {
 156             $this->updateTemplateStatusAndContentFromInput($page, $input);
 157             $page->fill($input);
 158             $page->save();
 159
 160             return $page;
 161         }
 162
 163         // Otherwise, save the data to a revision
 164         $draft = $this->revisionRepo->getNewDraftForCurrentUser($page);
 165         $draft->fill($input);
 166
 167         if (!empty($input['markdown'])) {
 168             $draft->markdown = $input['markdown'];
 169             $draft->html = '';
 170         } else {
 171             $draft->html = $input['html'];
 172             $draft->markdown = '';
 173         }
 174
 175         $draft->save();
 176
 177         return $draft;
 178     }
 179
 180     /**
 181      * Destroy a page from the system.
 182      *
 183      * @throws Exception
 184      */
 185     public function destroy(Page $page)
 186     {
 187         $trashCan = new TrashCan();
 188         $trashCan->softDestroyPage($page);
 189         Activity::add(ActivityType::PAGE_DELETE, $page);
 190         $trashCan->autoClearOld();
 191     }
 192
 193     /**
 194      * Restores a revision's content back into a page.
 195      */
 196     public function restoreRevision(Page $page, int $revisionId): Page
 197     {
 198         $oldUrl = $page->getUrl();
 199         $page->revision_count++;
 200
 201         /** @var PageRevision $revision */
 202         $revision = $page->revisions()->where('id', '=', $revisionId)->first();
 203
 204         $page->fill($revision->toArray());
 205         $content = new PageContent($page);
 206
 207         if (!empty($revision->markdown)) {
 208             $content->setNewMarkdown($revision->markdown, user());
 209         } else {
 210             $content->setNewHTML($revision->html, user());
 211         }
 212
 213         $page->updated_by = user()->id;
 214         $page->refreshSlug();
 215         $page->save();
 216         $page->indexForSearch();
 217         $this->referenceStore->updateForEntity($page);
 218
 219         $summary = trans('entities.pages_revision_restored_from', ['id' => strval($revisionId), 'summary' => $revision->summary]);
 220         $this->revisionRepo->storeNewForPage($page, $summary);
 221
 222         if ($oldUrl !== $page->getUrl()) {
 223             $this->referenceUpdater->updateEntityReferences($page, $oldUrl);
 224         }
 225
 226         Activity::add(ActivityType::PAGE_RESTORE, $page);
 227         Activity::add(ActivityType::REVISION_RESTORE, $revision);
 228
 229         return $page;
 230     }
 231
 232     /**
 233      * Move the given page into a new parent book or chapter.
 234      * The $parentIdentifier must be a string of the following format:
 235      * 'book:<id>' (book:5).
 236      *
 237      * @throws MoveOperationException
 238      * @throws PermissionsException
 239      */
 240     public function move(Page $page, string $parentIdentifier): Entity
 241     {
 242         $parent = $this->entityQueries->findVisibleByStringIdentifier($parentIdentifier);
 243         if (!$parent instanceof Chapter && !$parent instanceof Book) {
 244             throw new MoveOperationException('Book or chapter to move page into not found');
 245         }
 246
 247         if (!userCan('page-create', $parent)) {
 248             throw new PermissionsException('User does not have permission to create a page within the new parent');
 249         }
 250
 251         $page->chapter_id = ($parent instanceof Chapter) ? $parent->id : null;
 252         $newBookId = ($parent instanceof Chapter) ? $parent->book->id : $parent->id;
 253         $page->changeBook($newBookId);
 254         $page->rebuildPermissions();
 255
 256         Activity::add(ActivityType::PAGE_MOVE, $page);
 257
 258         return $parent;
 259     }
 260
 261     /**
 262      * Get a new priority for a page.
 263      */
 264     protected function getNewPriority(Page $page): int
 265     {
 266         $parent = $page->getParent();
 267         if ($parent instanceof Chapter) {
 268             /** @var ?Page $lastPage */
 269             $lastPage = $parent->pages('desc')->first();
 270
 271             return $lastPage ? $lastPage->priority + 1 : 0;
 272         }
 273
 274         return (new BookContents($page->book))->getLastPriority() + 1;
 275     }
 276 }