]> BookStack Code Mirror - bookstack/blob - app/Entities/Controllers/PageController.php
Merge branch 'add-priority' into development
[bookstack] / app / Entities / Controllers / PageController.php
1 <?php
2
3 namespace BookStack\Entities\Controllers;
4
5 use BookStack\Activity\Models\View;
6 use BookStack\Activity\Tools\CommentTree;
7 use BookStack\Activity\Tools\UserEntityWatchOptions;
8 use BookStack\Entities\Models\Page;
9 use BookStack\Entities\Repos\PageRepo;
10 use BookStack\Entities\Tools\BookContents;
11 use BookStack\Entities\Tools\Cloner;
12 use BookStack\Entities\Tools\NextPreviousContentLocator;
13 use BookStack\Entities\Tools\PageContent;
14 use BookStack\Entities\Tools\PageEditActivity;
15 use BookStack\Entities\Tools\PageEditorData;
16 use BookStack\Exceptions\NotFoundException;
17 use BookStack\Exceptions\PermissionsException;
18 use BookStack\Http\Controller;
19 use BookStack\References\ReferenceFetcher;
20 use Exception;
21 use Illuminate\Database\Eloquent\Relations\BelongsTo;
22 use Illuminate\Http\Request;
23 use Illuminate\Validation\ValidationException;
24 use Throwable;
25
26 class PageController extends Controller
27 {
28     public function __construct(
29         protected PageRepo $pageRepo,
30         protected ReferenceFetcher $referenceFetcher
31     ) {
32     }
33
34     /**
35      * Show the form for creating a new page.
36      *
37      * @throws Throwable
38      */
39     public function create(string $bookSlug, string $chapterSlug = null)
40     {
41         $parent = $this->pageRepo->getParentFromSlugs($bookSlug, $chapterSlug);
42         $this->checkOwnablePermission('page-create', $parent);
43
44         // Redirect to draft edit screen if signed in
45         if ($this->isSignedIn()) {
46             $draft = $this->pageRepo->getNewDraftPage($parent);
47
48             return redirect($draft->getUrl());
49         }
50
51         // Otherwise show the edit view if they're a guest
52         $this->setPageTitle(trans('entities.pages_new'));
53
54         return view('pages.guest-create', ['parent' => $parent]);
55     }
56
57     /**
58      * Create a new page as a guest user.
59      *
60      * @throws ValidationException
61      */
62     public function createAsGuest(Request $request, string $bookSlug, string $chapterSlug = null)
63     {
64         $this->validate($request, [
65             'name' => ['required', 'string', 'max:255'],
66         ]);
67
68         $parent = $this->pageRepo->getParentFromSlugs($bookSlug, $chapterSlug);
69         $this->checkOwnablePermission('page-create', $parent);
70
71         $page = $this->pageRepo->getNewDraftPage($parent);
72         $this->pageRepo->publishDraft($page, [
73             'name' => $request->get('name'),
74             'html' => '',
75         ]);
76
77         return redirect($page->getUrl('/edit'));
78     }
79
80     /**
81      * Show form to continue editing a draft page.
82      *
83      * @throws NotFoundException
84      */
85     public function editDraft(Request $request, string $bookSlug, int $pageId)
86     {
87         $draft = $this->pageRepo->getById($pageId);
88         $this->checkOwnablePermission('page-create', $draft->getParent());
89
90         $editorData = new PageEditorData($draft, $this->pageRepo, $request->query('editor', ''));
91         $this->setPageTitle(trans('entities.pages_edit_draft'));
92
93         return view('pages.edit', $editorData->getViewData());
94     }
95
96     /**
97      * Store a new page by changing a draft into a page.
98      *
99      * @throws NotFoundException
100      * @throws ValidationException
101      */
102     public function store(Request $request, string $bookSlug, int $pageId)
103     {
104         $this->validate($request, [
105             'name' => ['required', 'string', 'max:255'],
106         ]);
107         $draftPage = $this->pageRepo->getById($pageId);
108         $this->checkOwnablePermission('page-create', $draftPage->getParent());
109
110         $page = $this->pageRepo->publishDraft($draftPage, $request->all());
111
112         return redirect($page->getUrl());
113     }
114
115     /**
116      * Display the specified page.
117      * If the page is not found via the slug the revisions are searched for a match.
118      *
119      * @throws NotFoundException
120      */
121     public function show(string $bookSlug, string $pageSlug)
122     {
123         try {
124             $page = $this->pageRepo->getBySlug($bookSlug, $pageSlug);
125         } catch (NotFoundException $e) {
126             $page = $this->pageRepo->getByOldSlug($bookSlug, $pageSlug);
127
128             if ($page === null) {
129                 throw $e;
130             }
131
132             return redirect($page->getUrl());
133         }
134
135         $this->checkOwnablePermission('page-view', $page);
136
137         $pageContent = (new PageContent($page));
138         $page->html = $pageContent->render();
139         $pageNav = $pageContent->getNavigation($page->html);
140
141         $sidebarTree = (new BookContents($page->book))->getTree();
142         $commentTree = (new CommentTree($page));
143         $nextPreviousLocator = new NextPreviousContentLocator($page, $sidebarTree);
144
145         View::incrementFor($page);
146         $this->setPageTitle($page->getShortName());
147
148         return view('pages.show', [
149             'page'            => $page,
150             'book'            => $page->book,
151             'current'         => $page,
152             'sidebarTree'     => $sidebarTree,
153             'commentTree'     => $commentTree,
154             'pageNav'         => $pageNav,
155             'watchOptions'    => new UserEntityWatchOptions(user(), $page),
156             'next'            => $nextPreviousLocator->getNext(),
157             'previous'        => $nextPreviousLocator->getPrevious(),
158             'referenceCount'  => $this->referenceFetcher->getPageReferenceCountToEntity($page),
159         ]);
160     }
161
162     /**
163      * Get page from an ajax request.
164      *
165      * @throws NotFoundException
166      */
167     public function getPageAjax(int $pageId)
168     {
169         $page = $this->pageRepo->getById($pageId);
170         $page->setHidden(array_diff($page->getHidden(), ['html', 'markdown']));
171         $page->makeHidden(['book']);
172
173         return response()->json($page);
174     }
175
176     /**
177      * Show the form for editing the specified page.
178      *
179      * @throws NotFoundException
180      */
181     public function edit(Request $request, string $bookSlug, string $pageSlug)
182     {
183         $page = $this->pageRepo->getBySlug($bookSlug, $pageSlug);
184         $this->checkOwnablePermission('page-update', $page);
185
186         $editorData = new PageEditorData($page, $this->pageRepo, $request->query('editor', ''));
187         if ($editorData->getWarnings()) {
188             $this->showWarningNotification(implode("\n", $editorData->getWarnings()));
189         }
190
191         $this->setPageTitle(trans('entities.pages_editing_named', ['pageName' => $page->getShortName()]));
192
193         return view('pages.edit', $editorData->getViewData());
194     }
195
196     /**
197      * Update the specified page in storage.
198      *
199      * @throws ValidationException
200      * @throws NotFoundException
201      */
202     public function update(Request $request, string $bookSlug, string $pageSlug)
203     {
204         $this->validate($request, [
205             'name' => ['required', 'string', 'max:255'],
206         ]);
207         $page = $this->pageRepo->getBySlug($bookSlug, $pageSlug);
208         $this->checkOwnablePermission('page-update', $page);
209
210         $this->pageRepo->update($page, $request->all());
211
212         return redirect($page->getUrl());
213     }
214
215     /**
216      * Save a draft update as a revision.
217      *
218      * @throws NotFoundException
219      */
220     public function saveDraft(Request $request, int $pageId)
221     {
222         $page = $this->pageRepo->getById($pageId);
223         $this->checkOwnablePermission('page-update', $page);
224
225         if (!$this->isSignedIn()) {
226             return $this->jsonError(trans('errors.guests_cannot_save_drafts'), 500);
227         }
228
229         $draft = $this->pageRepo->updatePageDraft($page, $request->only(['name', 'html', 'markdown']));
230         $warnings = (new PageEditActivity($page))->getWarningMessagesForDraft($draft);
231
232         return response()->json([
233             'status'    => 'success',
234             'message'   => trans('entities.pages_edit_draft_save_at'),
235             'warning'   => implode("\n", $warnings),
236             'timestamp' => $draft->updated_at->timestamp,
237         ]);
238     }
239
240     /**
241      * Redirect from a special link url which uses the page id rather than the name.
242      *
243      * @throws NotFoundException
244      */
245     public function redirectFromLink(int $pageId)
246     {
247         $page = $this->pageRepo->getById($pageId);
248
249         return redirect($page->getUrl());
250     }
251
252     /**
253      * Show the deletion page for the specified page.
254      *
255      * @throws NotFoundException
256      */
257     public function showDelete(string $bookSlug, string $pageSlug)
258     {
259         $page = $this->pageRepo->getBySlug($bookSlug, $pageSlug);
260         $this->checkOwnablePermission('page-delete', $page);
261         $this->setPageTitle(trans('entities.pages_delete_named', ['pageName' => $page->getShortName()]));
262
263         return view('pages.delete', [
264             'book'    => $page->book,
265             'page'    => $page,
266             'current' => $page,
267         ]);
268     }
269
270     /**
271      * Show the deletion page for the specified page.
272      *
273      * @throws NotFoundException
274      */
275     public function showDeleteDraft(string $bookSlug, int $pageId)
276     {
277         $page = $this->pageRepo->getById($pageId);
278         $this->checkOwnablePermission('page-update', $page);
279         $this->setPageTitle(trans('entities.pages_delete_draft_named', ['pageName' => $page->getShortName()]));
280
281         return view('pages.delete', [
282             'book'    => $page->book,
283             'page'    => $page,
284             'current' => $page,
285         ]);
286     }
287
288     /**
289      * Remove the specified page from storage.
290      *
291      * @throws NotFoundException
292      * @throws Throwable
293      */
294     public function destroy(string $bookSlug, string $pageSlug)
295     {
296         $page = $this->pageRepo->getBySlug($bookSlug, $pageSlug);
297         $this->checkOwnablePermission('page-delete', $page);
298         $parent = $page->getParent();
299
300         $this->pageRepo->destroy($page);
301
302         return redirect($parent->getUrl());
303     }
304
305     /**
306      * Remove the specified draft page from storage.
307      *
308      * @throws NotFoundException
309      * @throws Throwable
310      */
311     public function destroyDraft(string $bookSlug, int $pageId)
312     {
313         $page = $this->pageRepo->getById($pageId);
314         $book = $page->book;
315         $chapter = $page->chapter;
316         $this->checkOwnablePermission('page-update', $page);
317
318         $this->pageRepo->destroy($page);
319
320         $this->showSuccessNotification(trans('entities.pages_delete_draft_success'));
321
322         if ($chapter && userCan('view', $chapter)) {
323             return redirect($chapter->getUrl());
324         }
325
326         return redirect($book->getUrl());
327     }
328
329     /**
330      * Show a listing of recently created pages.
331      */
332     public function showRecentlyUpdated()
333     {
334         $visibleBelongsScope = function (BelongsTo $query) {
335             $query->scopes('visible');
336         };
337
338         $pages = Page::visible()->with(['updatedBy', 'book' => $visibleBelongsScope, 'chapter' => $visibleBelongsScope])
339             ->orderBy('updated_at', 'desc')
340             ->paginate(20)
341             ->setPath(url('/pages/recently-updated'));
342
343         $this->setPageTitle(trans('entities.recently_updated_pages'));
344
345         return view('common.detailed-listing-paginated', [
346             'title'         => trans('entities.recently_updated_pages'),
347             'entities'      => $pages,
348             'showUpdatedBy' => true,
349             'showPath'      => true,
350         ]);
351     }
352
353     /**
354      * Show the view to choose a new parent to move a page into.
355      *
356      * @throws NotFoundException
357      */
358     public function showMove(string $bookSlug, string $pageSlug)
359     {
360         $page = $this->pageRepo->getBySlug($bookSlug, $pageSlug);
361         $this->checkOwnablePermission('page-update', $page);
362         $this->checkOwnablePermission('page-delete', $page);
363
364         return view('pages.move', [
365             'book' => $page->book,
366             'page' => $page,
367         ]);
368     }
369
370     /**
371      * Does the action of moving the location of a page.
372      *
373      * @throws NotFoundException
374      * @throws Throwable
375      */
376     public function move(Request $request, string $bookSlug, string $pageSlug)
377     {
378         $page = $this->pageRepo->getBySlug($bookSlug, $pageSlug);
379         $this->checkOwnablePermission('page-update', $page);
380         $this->checkOwnablePermission('page-delete', $page);
381
382         $entitySelection = $request->get('entity_selection', null);
383         if ($entitySelection === null || $entitySelection === '') {
384             return redirect($page->getUrl());
385         }
386
387         try {
388             $this->pageRepo->move($page, $entitySelection);
389         } catch (PermissionsException $exception) {
390             $this->showPermissionError();
391         } catch (Exception $exception) {
392             $this->showErrorNotification(trans('errors.selected_book_chapter_not_found'));
393
394             return redirect()->back();
395         }
396
397         return redirect($page->getUrl());
398     }
399
400     /**
401      * Show the view to copy a page.
402      *
403      * @throws NotFoundException
404      */
405     public function showCopy(string $bookSlug, string $pageSlug)
406     {
407         $page = $this->pageRepo->getBySlug($bookSlug, $pageSlug);
408         $this->checkOwnablePermission('page-view', $page);
409         session()->flashInput(['name' => $page->name]);
410
411         return view('pages.copy', [
412             'book' => $page->book,
413             'page' => $page,
414         ]);
415     }
416
417     /**
418      * Create a copy of a page within the requested target destination.
419      *
420      * @throws NotFoundException
421      * @throws Throwable
422      */
423     public function copy(Request $request, Cloner $cloner, string $bookSlug, string $pageSlug)
424     {
425         $page = $this->pageRepo->getBySlug($bookSlug, $pageSlug);
426         $this->checkOwnablePermission('page-view', $page);
427
428         $entitySelection = $request->get('entity_selection') ?: null;
429         $newParent = $entitySelection ? $this->pageRepo->findParentByIdentifier($entitySelection) : $page->getParent();
430
431         if (is_null($newParent)) {
432             $this->showErrorNotification(trans('errors.selected_book_chapter_not_found'));
433
434             return redirect()->back();
435         }
436
437         $this->checkOwnablePermission('page-create', $newParent);
438
439         $newName = $request->get('name') ?: $page->name;
440         $pageCopy = $cloner->clonePage($page, $newParent, $newName);
441         $this->showSuccessNotification(trans('entities.pages_copy_success'));
442
443         return redirect($pageCopy->getUrl());
444     }
445 }