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