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\Tools\BookContents;
  12 use BookStack\Entities\Tools\PageContent;
  13 use BookStack\Entities\Tools\PageEditorData;
  14 use BookStack\Entities\Tools\TrashCan;
  15 use BookStack\Exceptions\MoveOperationException;
  16 use BookStack\Exceptions\NotFoundException;
  17 use BookStack\Exceptions\PermissionsException;
  18 use BookStack\Facades\Activity;
  19 use BookStack\References\ReferenceStore;
  20 use BookStack\References\ReferenceUpdater;
  21 use Exception;
  22 use Illuminate\Pagination\LengthAwarePaginator;
  23
  24 class PageRepo
  25 {
  26     public function __construct(
  27         protected BaseRepo $baseRepo,
  28         protected RevisionRepo $revisionRepo,
  29         protected ReferenceStore $referenceStore,
  30         protected ReferenceUpdater $referenceUpdater
  31     ) {
  32     }
  33
  34     /**
  35      * Get a page by ID.
  36      *
  37      * @throws NotFoundException
  38      */
  39     public function getById(int $id, array $relations = ['book']): Page
  40     {
  41         /** @var Page $page */
  42         $page = Page::visible()->with($relations)->find($id);
  43
  44         if (!$page) {
  45             throw new NotFoundException(trans('errors.page_not_found'));
  46         }
  47
  48         return $page;
  49     }
  50
  51     /**
  52      * Get a page its book and own slug.
  53      *
  54      * @throws NotFoundException
  55      */
  56     public function getBySlug(string $bookSlug, string $pageSlug): Page
  57     {
  58         $page = Page::visible()->whereSlugs($bookSlug, $pageSlug)->first();
  59
  60         if (!$page) {
  61             throw new NotFoundException(trans('errors.page_not_found'));
  62         }
  63
  64         return $page;
  65     }
  66
  67     /**
  68      * Get a page by its old slug but checking the revisions table
  69      * for the last revision that matched the given page and book slug.
  70      */
  71     public function getByOldSlug(string $bookSlug, string $pageSlug): ?Page
  72     {
  73         $revision = $this->revisionRepo->getBySlugs($bookSlug, $pageSlug);
  74
  75         return $revision->page ?? null;
  76     }
  77
  78     /**
  79      * Get pages that have been marked as a template.
  80      */
  81     public function getTemplates(int $count = 10, int $page = 1, string $search = ''): LengthAwarePaginator
  82     {
  83         $query = Page::visible()
  84             ->where('template', '=', true)
  85             ->orderBy('name', 'asc')
  86             ->skip(($page - 1) * $count)
  87             ->take($count);
  88
  89         if ($search) {
  90             $query->where('name', 'like', '%' . $search . '%');
  91         }
  92
  93         $paginator = $query->paginate($count, ['*'], 'page', $page);
  94         $paginator->withPath('/templates');
  95
  96         return $paginator;
  97     }
  98
  99     /**
 100      * Get a parent item via slugs.
 101      */
 102     public function getParentFromSlugs(string $bookSlug, string $chapterSlug = null): Entity
 103     {
 104         if ($chapterSlug !== null) {
 105             return Chapter::visible()->whereSlugs($bookSlug, $chapterSlug)->firstOrFail();
 106         }
 107
 108         return Book::visible()->where('slug', '=', $bookSlug)->firstOrFail();
 109     }
 110
 111     /**
 112      * Get the draft copy of the given page for the current user.
 113      */
 114     public function getUserDraft(Page $page): ?PageRevision
 115     {
 116         return $this->revisionRepo->getLatestDraftForCurrentUser($page);
 117     }
 118
 119     /**
 120      * Get a new draft page belonging to the given parent entity.
 121      */
 122     public function getNewDraftPage(Entity $parent)
 123     {
 124         $page = (new Page())->forceFill([
 125             'name'       => trans('entities.pages_initial_name'),
 126             'created_by' => user()->id,
 127             'owned_by'   => user()->id,
 128             'updated_by' => user()->id,
 129             'draft'      => true,
 130         ]);
 131
 132         if ($parent instanceof Chapter) {
 133             $page->chapter_id = $parent->id;
 134             $page->book_id = $parent->book_id;
 135         } else {
 136             $page->book_id = $parent->id;
 137         }
 138
 139         // check for chapter
 140         if ($page->chapter_id) {
 141             $defaultTemplate = $page->chapter->defaultTemplate;
 142         } else {
 143             $defaultTemplate = $page->book->defaultTemplate;
 144         }
 145
 146         if ($defaultTemplate && userCan('view', $defaultTemplate)) {
 147             $page->forceFill([
 148                 'html'  => $defaultTemplate->html,
 149                 'markdown' => $defaultTemplate->markdown,
 150             ]);
 151         }
 152
 153         $page->save();
 154         $page->refresh()->rebuildPermissions();
 155
 156         return $page;
 157     }
 158
 159     /**
 160      * Publish a draft page to make it a live, non-draft page.
 161      */
 162     public function publishDraft(Page $draft, array $input): Page
 163     {
 164         $draft->draft = false;
 165         $draft->revision_count = 1;
 166         $draft->priority = $this->getNewPriority($draft);
 167         $this->updateTemplateStatusAndContentFromInput($draft, $input);
 168         $this->baseRepo->update($draft, $input);
 169
 170         $this->revisionRepo->storeNewForPage($draft, trans('entities.pages_initial_revision'));
 171         $draft->refresh();
 172
 173         Activity::add(ActivityType::PAGE_CREATE, $draft);
 174
 175         return $draft;
 176     }
 177
 178     /**
 179      * Update a page in the system.
 180      */
 181     public function update(Page $page, array $input): Page
 182     {
 183         // Hold the old details to compare later
 184         $oldHtml = $page->html;
 185         $oldName = $page->name;
 186         $oldMarkdown = $page->markdown;
 187
 188         $this->updateTemplateStatusAndContentFromInput($page, $input);
 189         $this->baseRepo->update($page, $input);
 190
 191         // Update with new details
 192         $page->revision_count++;
 193         $page->save();
 194
 195         // Remove all update drafts for this user & page.
 196         $this->revisionRepo->deleteDraftsForCurrentUser($page);
 197
 198         // Save a revision after updating
 199         $summary = trim($input['summary'] ?? '');
 200         $htmlChanged = isset($input['html']) && $input['html'] !== $oldHtml;
 201         $nameChanged = isset($input['name']) && $input['name'] !== $oldName;
 202         $markdownChanged = isset($input['markdown']) && $input['markdown'] !== $oldMarkdown;
 203         if ($htmlChanged || $nameChanged || $markdownChanged || $summary) {
 204             $this->revisionRepo->storeNewForPage($page, $summary);
 205         }
 206
 207         Activity::add(ActivityType::PAGE_UPDATE, $page);
 208
 209         return $page;
 210     }
 211
 212     protected function updateTemplateStatusAndContentFromInput(Page $page, array $input)
 213     {
 214         if (isset($input['template']) && userCan('templates-manage')) {
 215             $page->template = ($input['template'] === 'true');
 216         }
 217
 218         $pageContent = new PageContent($page);
 219         $currentEditor = $page->editor ?: PageEditorData::getSystemDefaultEditor();
 220         $newEditor = $currentEditor;
 221
 222         $haveInput = isset($input['markdown']) || isset($input['html']);
 223         $inputEmpty = empty($input['markdown']) && empty($input['html']);
 224
 225         if ($haveInput && $inputEmpty) {
 226             $pageContent->setNewHTML('', user());
 227         } elseif (!empty($input['markdown']) && is_string($input['markdown'])) {
 228             $newEditor = 'markdown';
 229             $pageContent->setNewMarkdown($input['markdown'], user());
 230         } elseif (isset($input['html'])) {
 231             $newEditor = 'wysiwyg';
 232             $pageContent->setNewHTML($input['html'], user());
 233         }
 234
 235         if ($newEditor !== $currentEditor && userCan('editor-change')) {
 236             $page->editor = $newEditor;
 237         }
 238     }
 239
 240     /**
 241      * Save a page update draft.
 242      */
 243     public function updatePageDraft(Page $page, array $input)
 244     {
 245         // If the page itself is a draft simply update that
 246         if ($page->draft) {
 247             $this->updateTemplateStatusAndContentFromInput($page, $input);
 248             $page->fill($input);
 249             $page->save();
 250
 251             return $page;
 252         }
 253
 254         // Otherwise, save the data to a revision
 255         $draft = $this->revisionRepo->getNewDraftForCurrentUser($page);
 256         $draft->fill($input);
 257
 258         if (!empty($input['markdown'])) {
 259             $draft->markdown = $input['markdown'];
 260             $draft->html = '';
 261         } else {
 262             $draft->html = $input['html'];
 263             $draft->markdown = '';
 264         }
 265
 266         $draft->save();
 267
 268         return $draft;
 269     }
 270
 271     /**
 272      * Destroy a page from the system.
 273      *
 274      * @throws Exception
 275      */
 276     public function destroy(Page $page)
 277     {
 278         $trashCan = new TrashCan();
 279         $trashCan->softDestroyPage($page);
 280         Activity::add(ActivityType::PAGE_DELETE, $page);
 281         $trashCan->autoClearOld();
 282     }
 283
 284     /**
 285      * Restores a revision's content back into a page.
 286      */
 287     public function restoreRevision(Page $page, int $revisionId): Page
 288     {
 289         $oldUrl = $page->getUrl();
 290         $page->revision_count++;
 291
 292         /** @var PageRevision $revision */
 293         $revision = $page->revisions()->where('id', '=', $revisionId)->first();
 294
 295         $page->fill($revision->toArray());
 296         $content = new PageContent($page);
 297
 298         if (!empty($revision->markdown)) {
 299             $content->setNewMarkdown($revision->markdown, user());
 300         } else {
 301             $content->setNewHTML($revision->html, user());
 302         }
 303
 304         $page->updated_by = user()->id;
 305         $page->refreshSlug();
 306         $page->save();
 307         $page->indexForSearch();
 308         $this->referenceStore->updateForEntity($page);
 309
 310         $summary = trans('entities.pages_revision_restored_from', ['id' => strval($revisionId), 'summary' => $revision->summary]);
 311         $this->revisionRepo->storeNewForPage($page, $summary);
 312
 313         if ($oldUrl !== $page->getUrl()) {
 314             $this->referenceUpdater->updateEntityReferences($page, $oldUrl);
 315         }
 316
 317         Activity::add(ActivityType::PAGE_RESTORE, $page);
 318         Activity::add(ActivityType::REVISION_RESTORE, $revision);
 319
 320         return $page;
 321     }
 322
 323     /**
 324      * Move the given page into a new parent book or chapter.
 325      * The $parentIdentifier must be a string of the following format:
 326      * 'book:<id>' (book:5).
 327      *
 328      * @throws MoveOperationException
 329      * @throws PermissionsException
 330      */
 331     public function move(Page $page, string $parentIdentifier): Entity
 332     {
 333         $parent = $this->findParentByIdentifier($parentIdentifier);
 334         if (is_null($parent)) {
 335             throw new MoveOperationException('Book or chapter to move page into not found');
 336         }
 337
 338         if (!userCan('page-create', $parent)) {
 339             throw new PermissionsException('User does not have permission to create a page within the new parent');
 340         }
 341
 342         $page->chapter_id = ($parent instanceof Chapter) ? $parent->id : null;
 343         $newBookId = ($parent instanceof Chapter) ? $parent->book->id : $parent->id;
 344         $page->changeBook($newBookId);
 345         $page->rebuildPermissions();
 346
 347         Activity::add(ActivityType::PAGE_MOVE, $page);
 348
 349         return $parent;
 350     }
 351
 352     /**
 353      * Find a page parent entity via an identifier string in the format:
 354      * {type}:{id}
 355      * Example: (book:5).
 356      *
 357      * @throws MoveOperationException
 358      */
 359     public function findParentByIdentifier(string $identifier): ?Entity
 360     {
 361         $stringExploded = explode(':', $identifier);
 362         $entityType = $stringExploded[0];
 363         $entityId = intval($stringExploded[1]);
 364
 365         if ($entityType !== 'book' && $entityType !== 'chapter') {
 366             throw new MoveOperationException('Pages can only be in books or chapters');
 367         }
 368
 369         $parentClass = $entityType === 'book' ? Book::class : Chapter::class;
 370
 371         return $parentClass::visible()->where('id', '=', $entityId)->first();
 372     }
 373
 374     /**
 375      * Get a new priority for a page.
 376      */
 377     protected function getNewPriority(Page $page): int
 378     {
 379         $parent = $page->getParent();
 380         if ($parent instanceof Chapter) {
 381             /** @var ?Page $lastPage */
 382             $lastPage = $parent->pages('desc')->first();
 383
 384             return $lastPage ? $lastPage->priority + 1 : 0;
 385         }
 386
 387         return (new BookContents($page->book))->getLastPriority() + 1;
 388     }
 389 }