BookStack Code Mirror - bookstack/blob - app/Http/Controllers/PageController.php

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