]> BookStack Code Mirror - bookstack/blob - app/Http/Controllers/PageController.php
Add socialite authentication for okta
[bookstack] / app / Http / Controllers / PageController.php
1 <?php namespace BookStack\Http\Controllers;
2
3 use Activity;
4 use BookStack\Exceptions\NotFoundException;
5 use BookStack\Repos\EntityRepo;
6 use BookStack\Repos\UserRepo;
7 use BookStack\Services\ExportService;
8 use Carbon\Carbon;
9 use Illuminate\Http\Request;
10 use Illuminate\Http\Response;
11 use Views;
12 use GatherContent\Htmldiff\Htmldiff;
13
14 class PageController extends Controller
15 {
16
17     protected $entityRepo;
18     protected $exportService;
19     protected $userRepo;
20
21     /**
22      * PageController constructor.
23      * @param EntityRepo $entityRepo
24      * @param ExportService $exportService
25      * @param UserRepo $userRepo
26      */
27     public function __construct(EntityRepo $entityRepo, ExportService $exportService, UserRepo $userRepo)
28     {
29         $this->entityRepo = $entityRepo;
30         $this->exportService = $exportService;
31         $this->userRepo = $userRepo;
32         parent::__construct();
33     }
34
35     /**
36      * Show the form for creating a new page.
37      * @param string $bookSlug
38      * @param string $chapterSlug
39      * @return Response
40      * @internal param bool $pageSlug
41      */
42     public function create($bookSlug, $chapterSlug = null)
43     {
44         $book = $this->entityRepo->getBySlug('book', $bookSlug);
45         $chapter = $chapterSlug ? $this->entityRepo->getBySlug('chapter', $chapterSlug, $bookSlug) : null;
46         $parent = $chapter ? $chapter : $book;
47         $this->checkOwnablePermission('page-create', $parent);
48
49         // Redirect to draft edit screen if signed in
50         if ($this->signedIn) {
51             $draft = $this->entityRepo->getDraftPage($book, $chapter);
52             return redirect($draft->getUrl());
53         }
54
55         // Otherwise show edit view
56         $this->setPageTitle(trans('entities.pages_new'));
57         return view('pages/guest-create', ['parent' => $parent]);
58     }
59
60     /**
61      * Create a new page as a guest user.
62      * @param Request $request
63      * @param string $bookSlug
64      * @param string|null $chapterSlug
65      * @return mixed
66      * @throws NotFoundException
67      */
68     public function createAsGuest(Request $request, $bookSlug, $chapterSlug = null)
69     {
70         $this->validate($request, [
71             'name' => 'required|string|max:255'
72         ]);
73
74         $book = $this->entityRepo->getBySlug('book', $bookSlug);
75         $chapter = $chapterSlug ? $this->entityRepo->getBySlug('chapter', $chapterSlug, $bookSlug) : null;
76         $parent = $chapter ? $chapter : $book;
77         $this->checkOwnablePermission('page-create', $parent);
78
79         $page = $this->entityRepo->getDraftPage($book, $chapter);
80         $this->entityRepo->publishPageDraft($page, [
81             'name' => $request->get('name'),
82             'html' => ''
83         ]);
84         return redirect($page->getUrl('/edit'));
85     }
86
87     /**
88      * Show form to continue editing a draft page.
89      * @param string $bookSlug
90      * @param int $pageId
91      * @return \Illuminate\Contracts\View\Factory|\Illuminate\View\View
92      */
93     public function editDraft($bookSlug, $pageId)
94     {
95         $draft = $this->entityRepo->getById('page', $pageId, true);
96         $this->checkOwnablePermission('page-create', $draft->book);
97         $this->setPageTitle(trans('entities.pages_edit_draft'));
98
99         $draftsEnabled = $this->signedIn;
100         return view('pages/edit', [
101             'page' => $draft,
102             'book' => $draft->book,
103             'isDraft' => true,
104             'draftsEnabled' => $draftsEnabled
105         ]);
106     }
107
108     /**
109      * Store a new page by changing a draft into a page.
110      * @param  Request $request
111      * @param  string $bookSlug
112      * @param  int $pageId
113      * @return Response
114      */
115     public function store(Request $request, $bookSlug, $pageId)
116     {
117         $this->validate($request, [
118             'name' => 'required|string|max:255'
119         ]);
120
121         $input = $request->all();
122         $book = $this->entityRepo->getBySlug('book', $bookSlug);
123
124         $draftPage = $this->entityRepo->getById('page', $pageId, true);
125
126         $chapterId = intval($draftPage->chapter_id);
127         $parent = $chapterId !== 0 ? $this->entityRepo->getById('chapter', $chapterId) : $book;
128         $this->checkOwnablePermission('page-create', $parent);
129
130         if ($parent->isA('chapter')) {
131             $input['priority'] = $this->entityRepo->getNewChapterPriority($parent);
132         } else {
133             $input['priority'] = $this->entityRepo->getNewBookPriority($parent);
134         }
135
136         $page = $this->entityRepo->publishPageDraft($draftPage, $input);
137
138         Activity::add($page, 'page_create', $book->id);
139         return redirect($page->getUrl());
140     }
141
142     /**
143      * Display the specified page.
144      * If the page is not found via the slug the revisions are searched for a match.
145      * @param string $bookSlug
146      * @param string $pageSlug
147      * @return Response
148      */
149     public function show($bookSlug, $pageSlug)
150     {
151         try {
152             $page = $this->entityRepo->getBySlug('page', $pageSlug, $bookSlug);
153         } catch (NotFoundException $e) {
154             $page = $this->entityRepo->getPageByOldSlug($pageSlug, $bookSlug);
155             if ($page === null) abort(404);
156             return redirect($page->getUrl());
157         }
158
159         $this->checkOwnablePermission('page-view', $page);
160
161         $page->html = $this->entityRepo->renderPage($page);
162         $sidebarTree = $this->entityRepo->getBookChildren($page->book);
163         $pageNav = $this->entityRepo->getPageNav($page->html);
164         $page->load(['comments.createdBy']);
165
166         Views::add($page);
167         $this->setPageTitle($page->getShortName());
168         return view('pages/show', [
169             'page' => $page,'book' => $page->book,
170             'current' => $page, 'sidebarTree' => $sidebarTree,
171             'pageNav' => $pageNav]);
172     }
173
174     /**
175      * Get page from an ajax request.
176      * @param int $pageId
177      * @return \Illuminate\Http\JsonResponse
178      */
179     public function getPageAjax($pageId)
180     {
181         $page = $this->entityRepo->getById('page', $pageId);
182         return response()->json($page);
183     }
184
185     /**
186      * Show the form for editing the specified page.
187      * @param string $bookSlug
188      * @param string $pageSlug
189      * @return Response
190      */
191     public function edit($bookSlug, $pageSlug)
192     {
193         $page = $this->entityRepo->getBySlug('page', $pageSlug, $bookSlug);
194         $this->checkOwnablePermission('page-update', $page);
195         $this->setPageTitle(trans('entities.pages_editing_named', ['pageName'=>$page->getShortName()]));
196         $page->isDraft = false;
197
198         // Check for active editing
199         $warnings = [];
200         if ($this->entityRepo->isPageEditingActive($page, 60)) {
201             $warnings[] = $this->entityRepo->getPageEditingActiveMessage($page, 60);
202         }
203
204         // Check for a current draft version for this user
205         if ($this->entityRepo->hasUserGotPageDraft($page, $this->currentUser->id)) {
206             $draft = $this->entityRepo->getUserPageDraft($page, $this->currentUser->id);
207             $page->name = $draft->name;
208             $page->html = $draft->html;
209             $page->markdown = $draft->markdown;
210             $page->isDraft = true;
211             $warnings [] = $this->entityRepo->getUserPageDraftMessage($draft);
212         }
213
214         if (count($warnings) > 0) session()->flash('warning', implode("\n", $warnings));
215
216         $draftsEnabled = $this->signedIn;
217         return view('pages/edit', [
218             'page' => $page,
219             'book' => $page->book,
220             'current' => $page,
221             'draftsEnabled' => $draftsEnabled
222         ]);
223     }
224
225     /**
226      * Update the specified page in storage.
227      * @param  Request $request
228      * @param  string $bookSlug
229      * @param  string $pageSlug
230      * @return Response
231      */
232     public function update(Request $request, $bookSlug, $pageSlug)
233     {
234         $this->validate($request, [
235             'name' => 'required|string|max:255'
236         ]);
237         $page = $this->entityRepo->getBySlug('page', $pageSlug, $bookSlug);
238         $this->checkOwnablePermission('page-update', $page);
239         $this->entityRepo->updatePage($page, $page->book->id, $request->all());
240         Activity::add($page, 'page_update', $page->book->id);
241         return redirect($page->getUrl());
242     }
243
244     /**
245      * Save a draft update as a revision.
246      * @param Request $request
247      * @param int $pageId
248      * @return \Illuminate\Http\JsonResponse
249      */
250     public function saveDraft(Request $request, $pageId)
251     {
252         $page = $this->entityRepo->getById('page', $pageId, true);
253         $this->checkOwnablePermission('page-update', $page);
254
255         if (!$this->signedIn) {
256             return response()->json([
257                 'status' => 'error',
258                 'message' => trans('errors.guests_cannot_save_drafts'),
259             ], 500);
260         }
261
262         $draft = $this->entityRepo->updatePageDraft($page, $request->only(['name', 'html', 'markdown']));
263
264         $updateTime = $draft->updated_at->timestamp;
265         $utcUpdateTimestamp = $updateTime + Carbon::createFromTimestamp(0)->offset;
266         return response()->json([
267             'status'    => 'success',
268             'message'   => trans('entities.pages_edit_draft_save_at'),
269             'timestamp' => $utcUpdateTimestamp
270         ]);
271     }
272
273     /**
274      * Redirect from a special link url which
275      * uses the page id rather than the name.
276      * @param int $pageId
277      * @return \Illuminate\Http\RedirectResponse|\Illuminate\Routing\Redirector
278      */
279     public function redirectFromLink($pageId)
280     {
281         $page = $this->entityRepo->getById('page', $pageId);
282         return redirect($page->getUrl());
283     }
284
285     /**
286      * Show the deletion page for the specified page.
287      * @param string $bookSlug
288      * @param string $pageSlug
289      * @return \Illuminate\View\View
290      */
291     public function showDelete($bookSlug, $pageSlug)
292     {
293         $page = $this->entityRepo->getBySlug('page', $pageSlug, $bookSlug);
294         $this->checkOwnablePermission('page-delete', $page);
295         $this->setPageTitle(trans('entities.pages_delete_named', ['pageName'=>$page->getShortName()]));
296         return view('pages/delete', ['book' => $page->book, 'page' => $page, 'current' => $page]);
297     }
298
299
300     /**
301      * Show the deletion page for the specified page.
302      * @param string $bookSlug
303      * @param int $pageId
304      * @return \Illuminate\View\View
305      * @throws NotFoundException
306      */
307     public function showDeleteDraft($bookSlug, $pageId)
308     {
309         $page = $this->entityRepo->getById('page', $pageId, true);
310         $this->checkOwnablePermission('page-update', $page);
311         $this->setPageTitle(trans('entities.pages_delete_draft_named', ['pageName'=>$page->getShortName()]));
312         return view('pages/delete', ['book' => $page->book, 'page' => $page, 'current' => $page]);
313     }
314
315     /**
316      * Remove the specified page from storage.
317      * @param string $bookSlug
318      * @param string $pageSlug
319      * @return Response
320      * @internal param int $id
321      */
322     public function destroy($bookSlug, $pageSlug)
323     {
324         $page = $this->entityRepo->getBySlug('page', $pageSlug, $bookSlug);
325         $book = $page->book;
326         $this->checkOwnablePermission('page-delete', $page);
327         $this->entityRepo->destroyPage($page);
328
329         Activity::addMessage('page_delete', $book->id, $page->name);
330         session()->flash('success', trans('entities.pages_delete_success'));
331         return redirect($book->getUrl());
332     }
333
334     /**
335      * Remove the specified draft page from storage.
336      * @param string $bookSlug
337      * @param int $pageId
338      * @return Response
339      * @throws NotFoundException
340      */
341     public function destroyDraft($bookSlug, $pageId)
342     {
343         $page = $this->entityRepo->getById('page', $pageId, true);
344         $book = $page->book;
345         $this->checkOwnablePermission('page-update', $page);
346         session()->flash('success', trans('entities.pages_delete_draft_success'));
347         $this->entityRepo->destroyPage($page);
348         return redirect($book->getUrl());
349     }
350
351     /**
352      * Shows the last revisions for this page.
353      * @param string $bookSlug
354      * @param string $pageSlug
355      * @return \Illuminate\View\View
356      */
357     public function showRevisions($bookSlug, $pageSlug)
358     {
359         $page = $this->entityRepo->getBySlug('page', $pageSlug, $bookSlug);
360         $this->setPageTitle(trans('entities.pages_revisions_named', ['pageName'=>$page->getShortName()]));
361         return view('pages/revisions', ['page' => $page, 'book' => $page->book, 'current' => $page]);
362     }
363
364     /**
365      * Shows a preview of a single revision
366      * @param string $bookSlug
367      * @param string $pageSlug
368      * @param int $revisionId
369      * @return \Illuminate\View\View
370      */
371     public function showRevision($bookSlug, $pageSlug, $revisionId)
372     {
373         $page = $this->entityRepo->getBySlug('page', $pageSlug, $bookSlug);
374         $revision = $page->revisions()->where('id', '=', $revisionId)->first();
375         if ($revision === null) {
376             abort(404);
377         }
378
379         $page->fill($revision->toArray());
380         $this->setPageTitle(trans('entities.pages_revision_named', ['pageName' => $page->getShortName()]));
381
382         return view('pages/revision', [
383             'page' => $page,
384             'book' => $page->book,
385             'revision' => $revision
386         ]);
387     }
388
389     /**
390      * Shows the changes of a single revision
391      * @param string $bookSlug
392      * @param string $pageSlug
393      * @param int $revisionId
394      * @return \Illuminate\View\View
395      */
396     public function showRevisionChanges($bookSlug, $pageSlug, $revisionId)
397     {
398         $page = $this->entityRepo->getBySlug('page', $pageSlug, $bookSlug);
399         $revision = $page->revisions()->where('id', '=', $revisionId)->first();
400         if ($revision === null) {
401             abort(404);
402         }
403
404         $prev = $revision->getPrevious();
405         $prevContent = ($prev === null) ? '' : $prev->html;
406         $diff = (new Htmldiff)->diff($prevContent, $revision->html);
407
408         $page->fill($revision->toArray());
409         $this->setPageTitle(trans('entities.pages_revision_named', ['pageName'=>$page->getShortName()]));
410
411         return view('pages/revision', [
412             'page' => $page,
413             'book' => $page->book,
414             'diff' => $diff,
415             'revision' => $revision
416         ]);
417     }
418
419     /**
420      * Restores a page using the content of the specified revision.
421      * @param string $bookSlug
422      * @param string $pageSlug
423      * @param int $revisionId
424      * @return \Illuminate\Http\RedirectResponse|\Illuminate\Routing\Redirector
425      */
426     public function restoreRevision($bookSlug, $pageSlug, $revisionId)
427     {
428         $page = $this->entityRepo->getBySlug('page', $pageSlug, $bookSlug);
429         $this->checkOwnablePermission('page-update', $page);
430         $page = $this->entityRepo->restorePageRevision($page, $page->book, $revisionId);
431         Activity::add($page, 'page_restore', $page->book->id);
432         return redirect($page->getUrl());
433     }
434
435     /**
436      * Exports a page to a PDF.
437      * https://github.com/barryvdh/laravel-dompdf
438      * @param string $bookSlug
439      * @param string $pageSlug
440      * @return \Illuminate\Http\Response
441      */
442     public function exportPdf($bookSlug, $pageSlug)
443     {
444         $page = $this->entityRepo->getBySlug('page', $pageSlug, $bookSlug);
445         $page->html = $this->entityRepo->renderPage($page);
446         $pdfContent = $this->exportService->pageToPdf($page);
447         return response()->make($pdfContent, 200, [
448             'Content-Type'        => 'application/octet-stream',
449             'Content-Disposition' => 'attachment; filename="' . $pageSlug . '.pdf'
450         ]);
451     }
452
453     /**
454      * Export a page to a self-contained HTML file.
455      * @param string $bookSlug
456      * @param string $pageSlug
457      * @return \Illuminate\Http\Response
458      */
459     public function exportHtml($bookSlug, $pageSlug)
460     {
461         $page = $this->entityRepo->getBySlug('page', $pageSlug, $bookSlug);
462         $page->html = $this->entityRepo->renderPage($page);
463         $containedHtml = $this->exportService->pageToContainedHtml($page);
464         return response()->make($containedHtml, 200, [
465             'Content-Type'        => 'application/octet-stream',
466             'Content-Disposition' => 'attachment; filename="' . $pageSlug . '.html'
467         ]);
468     }
469
470     /**
471      * Export a page to a simple plaintext .txt file.
472      * @param string $bookSlug
473      * @param string $pageSlug
474      * @return \Illuminate\Http\Response
475      */
476     public function exportPlainText($bookSlug, $pageSlug)
477     {
478         $page = $this->entityRepo->getBySlug('page', $pageSlug, $bookSlug);
479         $containedHtml = $this->exportService->pageToPlainText($page);
480         return response()->make($containedHtml, 200, [
481             'Content-Type'        => 'application/octet-stream',
482             'Content-Disposition' => 'attachment; filename="' . $pageSlug . '.txt'
483         ]);
484     }
485
486     /**
487      * Show a listing of recently created pages
488      * @return \Illuminate\Contracts\View\Factory|\Illuminate\View\View
489      */
490     public function showRecentlyCreated()
491     {
492         $pages = $this->entityRepo->getRecentlyCreatedPaginated('page', 20)->setPath(baseUrl('/pages/recently-created'));
493         return view('pages/detailed-listing', [
494             'title' => trans('entities.recently_created_pages'),
495             'pages' => $pages
496         ]);
497     }
498
499     /**
500      * Show a listing of recently created pages
501      * @return \Illuminate\Contracts\View\Factory|\Illuminate\View\View
502      */
503     public function showRecentlyUpdated()
504     {
505         $pages = $this->entityRepo->getRecentlyUpdatedPaginated('page', 20)->setPath(baseUrl('/pages/recently-updated'));
506         return view('pages/detailed-listing', [
507             'title' => trans('entities.recently_updated_pages'),
508             'pages' => $pages
509         ]);
510     }
511
512     /**
513      * Show the Restrictions view.
514      * @param string $bookSlug
515      * @param string $pageSlug
516      * @return \Illuminate\Contracts\View\Factory|\Illuminate\View\View
517      */
518     public function showRestrict($bookSlug, $pageSlug)
519     {
520         $page = $this->entityRepo->getBySlug('page', $pageSlug, $bookSlug);
521         $this->checkOwnablePermission('restrictions-manage', $page);
522         $roles = $this->userRepo->getRestrictableRoles();
523         return view('pages/restrictions', [
524             'page'  => $page,
525             'roles' => $roles
526         ]);
527     }
528
529     /**
530      * Show the view to choose a new parent to move a page into.
531      * @param string $bookSlug
532      * @param string $pageSlug
533      * @return mixed
534      * @throws NotFoundException
535      */
536     public function showMove($bookSlug, $pageSlug)
537     {
538         $page = $this->entityRepo->getBySlug('page', $pageSlug, $bookSlug);
539         $this->checkOwnablePermission('page-update', $page);
540         return view('pages/move', [
541             'book' => $page->book,
542             'page' => $page
543         ]);
544     }
545
546     /**
547      * Does the action of moving the location of a page
548      * @param string $bookSlug
549      * @param string $pageSlug
550      * @param Request $request
551      * @return mixed
552      * @throws NotFoundException
553      */
554     public function move($bookSlug, $pageSlug, Request $request)
555     {
556         $page = $this->entityRepo->getBySlug('page', $pageSlug, $bookSlug);
557         $this->checkOwnablePermission('page-update', $page);
558
559         $entitySelection = $request->get('entity_selection', null);
560         if ($entitySelection === null || $entitySelection === '') {
561             return redirect($page->getUrl());
562         }
563
564         $stringExploded = explode(':', $entitySelection);
565         $entityType = $stringExploded[0];
566         $entityId = intval($stringExploded[1]);
567
568
569         try {
570             $parent = $this->entityRepo->getById($entityType, $entityId);
571         } catch (\Exception $e) {
572             session()->flash(trans('entities.selected_book_chapter_not_found'));
573             return redirect()->back();
574         }
575
576         $this->entityRepo->changePageParent($page, $parent);
577         Activity::add($page, 'page_move', $page->book->id);
578         session()->flash('success', trans('entities.pages_move_success', ['parentName' => $parent->name]));
579
580         return redirect($page->getUrl());
581     }
582
583     /**
584      * Set the permissions for this page.
585      * @param string $bookSlug
586      * @param string $pageSlug
587      * @param Request $request
588      * @return \Illuminate\Http\RedirectResponse|\Illuminate\Routing\Redirector
589      */
590     public function restrict($bookSlug, $pageSlug, Request $request)
591     {
592         $page = $this->entityRepo->getBySlug('page', $pageSlug, $bookSlug);
593         $this->checkOwnablePermission('restrictions-manage', $page);
594         $this->entityRepo->updateEntityPermissionsFromRequest($request, $page);
595         session()->flash('success', trans('entities.pages_permissions_success'));
596         return redirect($page->getUrl());
597     }
598
599 }