]> BookStack Code Mirror - bookstack/blob - app/Repos/EntityRepo.php
Fixed model extending mis-use
[bookstack] / app / Repos / EntityRepo.php
1 <?php namespace BookStack\Repos;
2
3 use BookStack\Book;
4 use BookStack\Chapter;
5 use BookStack\Entity;
6 use BookStack\Exceptions\NotFoundException;
7 use BookStack\Page;
8 use BookStack\PageRevision;
9 use BookStack\Services\AttachmentService;
10 use BookStack\Services\PermissionService;
11 use BookStack\Services\SearchService;
12 use BookStack\Services\ViewService;
13 use Carbon\Carbon;
14 use DOMDocument;
15 use DOMXPath;
16 use Illuminate\Support\Collection;
17
18 class EntityRepo
19 {
20
21     /**
22      * @var Book $book
23      */
24     public $book;
25
26     /**
27      * @var Chapter
28      */
29     public $chapter;
30
31     /**
32      * @var Page
33      */
34     public $page;
35
36     /**
37      * @var PageRevision
38      */
39     protected $pageRevision;
40
41     /**
42      * Base entity instances keyed by type
43      * @var []Entity
44      */
45     protected $entities;
46
47     /**
48      * @var PermissionService
49      */
50     protected $permissionService;
51
52     /**
53      * @var ViewService
54      */
55     protected $viewService;
56
57     /**
58      * @var TagRepo
59      */
60     protected $tagRepo;
61
62     /**
63      * @var SearchService
64      */
65     protected $searchService;
66
67     /**
68      * EntityRepo constructor.
69      * @param Book $book
70      * @param Chapter $chapter
71      * @param Page $page
72      * @param PageRevision $pageRevision
73      * @param ViewService $viewService
74      * @param PermissionService $permissionService
75      * @param TagRepo $tagRepo
76      * @param SearchService $searchService
77      */
78     public function __construct(
79         Book $book, Chapter $chapter, Page $page, PageRevision $pageRevision,
80         ViewService $viewService, PermissionService $permissionService,
81         TagRepo $tagRepo, SearchService $searchService
82     )
83     {
84         $this->book = $book;
85         $this->chapter = $chapter;
86         $this->page = $page;
87         $this->pageRevision = $pageRevision;
88         $this->entities = [
89             'page' => $this->page,
90             'chapter' => $this->chapter,
91             'book' => $this->book
92         ];
93         $this->viewService = $viewService;
94         $this->permissionService = $permissionService;
95         $this->tagRepo = $tagRepo;
96         $this->searchService = $searchService;
97     }
98
99     /**
100      * Get an entity instance via type.
101      * @param $type
102      * @return Entity
103      */
104     protected function getEntity($type)
105     {
106         return $this->entities[strtolower($type)];
107     }
108
109     /**
110      * Base query for searching entities via permission system
111      * @param string $type
112      * @param bool $allowDrafts
113      * @return \Illuminate\Database\Query\Builder
114      */
115     protected function entityQuery($type, $allowDrafts = false)
116     {
117         $q = $this->permissionService->enforceEntityRestrictions($type, $this->getEntity($type), 'view');
118         if (strtolower($type) === 'page' && !$allowDrafts) {
119             $q = $q->where('draft', '=', false);
120         }
121         return $q;
122     }
123
124     /**
125      * Check if an entity with the given id exists.
126      * @param $type
127      * @param $id
128      * @return bool
129      */
130     public function exists($type, $id)
131     {
132         return $this->entityQuery($type)->where('id', '=', $id)->exists();
133     }
134
135     /**
136      * Get an entity by ID
137      * @param string $type
138      * @param integer $id
139      * @param bool $allowDrafts
140      * @return Entity
141      */
142     public function getById($type, $id, $allowDrafts = false)
143     {
144         return $this->entityQuery($type, $allowDrafts)->find($id);
145     }
146
147     /**
148      * Get an entity by its url slug.
149      * @param string $type
150      * @param string $slug
151      * @param string|bool $bookSlug
152      * @return Entity
153      * @throws NotFoundException
154      */
155     public function getBySlug($type, $slug, $bookSlug = false)
156     {
157         $q = $this->entityQuery($type)->where('slug', '=', $slug);
158
159         if (strtolower($type) === 'chapter' || strtolower($type) === 'page') {
160             $q = $q->where('book_id', '=', function($query) use ($bookSlug) {
161                 $query->select('id')
162                     ->from($this->book->getTable())
163                     ->where('slug', '=', $bookSlug)->limit(1);
164             });
165         }
166         $entity = $q->first();
167         if ($entity === null) throw new NotFoundException(trans('errors.' . strtolower($type) . '_not_found'));
168         return $entity;
169     }
170
171
172     /**
173      * Search through page revisions and retrieve the last page in the
174      * current book that has a slug equal to the one given.
175      * @param string $pageSlug
176      * @param string $bookSlug
177      * @return null|Page
178      */
179     public function getPageByOldSlug($pageSlug, $bookSlug)
180     {
181         $revision = $this->pageRevision->where('slug', '=', $pageSlug)
182             ->whereHas('page', function ($query) {
183                 $this->permissionService->enforceEntityRestrictions('page', $query);
184             })
185             ->where('type', '=', 'version')
186             ->where('book_slug', '=', $bookSlug)
187             ->orderBy('created_at', 'desc')
188             ->with('page')->first();
189         return $revision !== null ? $revision->page : null;
190     }
191
192     /**
193      * Get all entities of a type limited by count unless count if false.
194      * @param string $type
195      * @param integer|bool $count
196      * @return Collection
197      */
198     public function getAll($type, $count = 20)
199     {
200         $q = $this->entityQuery($type)->orderBy('name', 'asc');
201         if ($count !== false) $q = $q->take($count);
202         return $q->get();
203     }
204
205     /**
206      * Get all entities in a paginated format
207      * @param $type
208      * @param int $count
209      * @return \Illuminate\Contracts\Pagination\LengthAwarePaginator
210      */
211     public function getAllPaginated($type, $count = 10)
212     {
213         return $this->entityQuery($type)->orderBy('name', 'asc')->paginate($count);
214     }
215
216     /**
217      * Get the most recently created entities of the given type.
218      * @param string $type
219      * @param int $count
220      * @param int $page
221      * @param bool|callable $additionalQuery
222      * @return Collection
223      */
224     public function getRecentlyCreated($type, $count = 20, $page = 0, $additionalQuery = false)
225     {
226         $query = $this->permissionService->enforceEntityRestrictions($type, $this->getEntity($type))
227             ->orderBy('created_at', 'desc');
228         if (strtolower($type) === 'page') $query = $query->where('draft', '=', false);
229         if ($additionalQuery !== false && is_callable($additionalQuery)) {
230             $additionalQuery($query);
231         }
232         return $query->skip($page * $count)->take($count)->get();
233     }
234
235     /**
236      * Get the most recently updated entities of the given type.
237      * @param string $type
238      * @param int $count
239      * @param int $page
240      * @param bool|callable $additionalQuery
241      * @return Collection
242      */
243     public function getRecentlyUpdated($type, $count = 20, $page = 0, $additionalQuery = false)
244     {
245         $query = $this->permissionService->enforceEntityRestrictions($type, $this->getEntity($type))
246             ->orderBy('updated_at', 'desc');
247         if (strtolower($type) === 'page') $query = $query->where('draft', '=', false);
248         if ($additionalQuery !== false && is_callable($additionalQuery)) {
249             $additionalQuery($query);
250         }
251         return $query->skip($page * $count)->take($count)->get();
252     }
253
254     /**
255      * Get the most recently viewed entities.
256      * @param string|bool $type
257      * @param int $count
258      * @param int $page
259      * @return mixed
260      */
261     public function getRecentlyViewed($type, $count = 10, $page = 0)
262     {
263         $filter = is_bool($type) ? false : $this->getEntity($type);
264         return $this->viewService->getUserRecentlyViewed($count, $page, $filter);
265     }
266
267     /**
268      * Get the latest pages added to the system with pagination.
269      * @param string $type
270      * @param int $count
271      * @return mixed
272      */
273     public function getRecentlyCreatedPaginated($type, $count = 20)
274     {
275         return $this->entityQuery($type)->orderBy('created_at', 'desc')->paginate($count);
276     }
277
278     /**
279      * Get the latest pages added to the system with pagination.
280      * @param string $type
281      * @param int $count
282      * @return mixed
283      */
284     public function getRecentlyUpdatedPaginated($type, $count = 20)
285     {
286         return $this->entityQuery($type)->orderBy('updated_at', 'desc')->paginate($count);
287     }
288
289     /**
290      * Get the most popular entities base on all views.
291      * @param string|bool $type
292      * @param int $count
293      * @param int $page
294      * @return mixed
295      */
296     public function getPopular($type, $count = 10, $page = 0)
297     {
298         $filter = is_bool($type) ? false : $this->getEntity($type);
299         return $this->viewService->getPopular($count, $page, $filter);
300     }
301
302     /**
303      * Get draft pages owned by the current user.
304      * @param int $count
305      * @param int $page
306      */
307     public function getUserDraftPages($count = 20, $page = 0)
308     {
309         return $this->page->where('draft', '=', true)
310             ->where('created_by', '=', user()->id)
311             ->orderBy('updated_at', 'desc')
312             ->skip($count * $page)->take($count)->get();
313     }
314
315     /**
316      * Get all child objects of a book.
317      * Returns a sorted collection of Pages and Chapters.
318      * Loads the book slug onto child elements to prevent access database access for getting the slug.
319      * @param Book $book
320      * @param bool $filterDrafts
321      * @param bool $renderPages
322      * @return mixed
323      */
324     public function getBookChildren(Book $book, $filterDrafts = false, $renderPages = false)
325     {
326         $q = $this->permissionService->bookChildrenQuery($book->id, $filterDrafts, $renderPages)->get();
327         $entities = [];
328         $parents = [];
329         $tree = [];
330
331         foreach ($q as $index => $rawEntity) {
332             if ($rawEntity->entity_type === 'BookStack\\Page') {
333                 $entities[$index] = $this->page->newFromBuilder($rawEntity);
334                 if ($renderPages) {
335                     $entities[$index]->html = $rawEntity->html;
336                     $entities[$index]->html = $this->renderPage($entities[$index]);
337                 };
338             } else if ($rawEntity->entity_type === 'BookStack\\Chapter') {
339                 $entities[$index] = $this->chapter->newFromBuilder($rawEntity);
340                 $key = $entities[$index]->entity_type . ':' . $entities[$index]->id;
341                 $parents[$key] = $entities[$index];
342                 $parents[$key]->setAttribute('pages', collect());
343             }
344             if ($entities[$index]->chapter_id === 0 || $entities[$index]->chapter_id === '0') $tree[] = $entities[$index];
345             $entities[$index]->book = $book;
346         }
347
348         foreach ($entities as $entity) {
349             if ($entity->chapter_id === 0 || $entity->chapter_id === '0') continue;
350             $parentKey = 'BookStack\\Chapter:' . $entity->chapter_id;
351             $chapter = $parents[$parentKey];
352             $chapter->pages->push($entity);
353         }
354
355         return collect($tree);
356     }
357
358     /**
359      * Get the child items for a chapter sorted by priority but
360      * with draft items floated to the top.
361      * @param Chapter $chapter
362      * @return \Illuminate\Database\Eloquent\Collection|static[]
363      */
364     public function getChapterChildren(Chapter $chapter)
365     {
366         return $this->permissionService->enforceEntityRestrictions('page', $chapter->pages())
367             ->orderBy('draft', 'DESC')->orderBy('priority', 'ASC')->get();
368     }
369
370
371     /**
372      * Get the next sequential priority for a new child element in the given book.
373      * @param Book $book
374      * @return int
375      */
376     public function getNewBookPriority(Book $book)
377     {
378         $lastElem = $this->getBookChildren($book)->pop();
379         return $lastElem ? $lastElem->priority + 1 : 0;
380     }
381
382     /**
383      * Get a new priority for a new page to be added to the given chapter.
384      * @param Chapter $chapter
385      * @return int
386      */
387     public function getNewChapterPriority(Chapter $chapter)
388     {
389         $lastPage = $chapter->pages('DESC')->first();
390         return $lastPage !== null ? $lastPage->priority + 1 : 0;
391     }
392
393     /**
394      * Find a suitable slug for an entity.
395      * @param string $type
396      * @param string $name
397      * @param bool|integer $currentId
398      * @param bool|integer $bookId Only pass if type is not a book
399      * @return string
400      */
401     public function findSuitableSlug($type, $name, $currentId = false, $bookId = false)
402     {
403         $slug = $this->nameToSlug($name);
404         while ($this->slugExists($type, $slug, $currentId, $bookId)) {
405             $slug .= '-' . substr(md5(rand(1, 500)), 0, 3);
406         }
407         return $slug;
408     }
409
410     /**
411      * Check if a slug already exists in the database.
412      * @param string $type
413      * @param string $slug
414      * @param bool|integer $currentId
415      * @param bool|integer $bookId
416      * @return bool
417      */
418     protected function slugExists($type, $slug, $currentId = false, $bookId = false)
419     {
420         $query = $this->getEntity($type)->where('slug', '=', $slug);
421         if (strtolower($type) === 'page' || strtolower($type) === 'chapter') {
422             $query = $query->where('book_id', '=', $bookId);
423         }
424         if ($currentId) $query = $query->where('id', '!=', $currentId);
425         return $query->count() > 0;
426     }
427
428     /**
429      * Updates entity restrictions from a request
430      * @param $request
431      * @param Entity $entity
432      */
433     public function updateEntityPermissionsFromRequest($request, Entity $entity)
434     {
435         $entity->restricted = $request->has('restricted') && $request->get('restricted') === 'true';
436         $entity->permissions()->delete();
437         if ($request->has('restrictions')) {
438             foreach ($request->get('restrictions') as $roleId => $restrictions) {
439                 foreach ($restrictions as $action => $value) {
440                     $entity->permissions()->create([
441                         'role_id' => $roleId,
442                         'action'  => strtolower($action)
443                     ]);
444                 }
445             }
446         }
447         $entity->save();
448         $this->permissionService->buildJointPermissionsForEntity($entity);
449     }
450
451
452
453     /**
454      * Create a new entity from request input.
455      * Used for books and chapters.
456      * @param string $type
457      * @param array $input
458      * @param bool|Book $book
459      * @return Entity
460      */
461     public function createFromInput($type, $input = [], $book = false)
462     {
463         $isChapter = strtolower($type) === 'chapter';
464         $entity = $this->getEntity($type)->newInstance($input);
465         $entity->slug = $this->findSuitableSlug($type, $entity->name, false, $isChapter ? $book->id : false);
466         $entity->created_by = user()->id;
467         $entity->updated_by = user()->id;
468         $isChapter ? $book->chapters()->save($entity) : $entity->save();
469         $this->permissionService->buildJointPermissionsForEntity($entity);
470         $this->searchService->indexEntity($entity);
471         return $entity;
472     }
473
474     /**
475      * Update entity details from request input.
476      * Used for books and chapters
477      * @param string $type
478      * @param Entity $entityModel
479      * @param array $input
480      * @return Entity
481      */
482     public function updateFromInput($type, Entity $entityModel, $input = [])
483     {
484         if ($entityModel->name !== $input['name']) {
485             $entityModel->slug = $this->findSuitableSlug($type, $input['name'], $entityModel->id);
486         }
487         $entityModel->fill($input);
488         $entityModel->updated_by = user()->id;
489         $entityModel->save();
490         $this->permissionService->buildJointPermissionsForEntity($entityModel);
491         $this->searchService->indexEntity($entityModel);
492         return $entityModel;
493     }
494
495     /**
496      * Change the book that an entity belongs to.
497      * @param string $type
498      * @param integer $newBookId
499      * @param Entity $entity
500      * @param bool $rebuildPermissions
501      * @return Entity
502      */
503     public function changeBook($type, $newBookId, Entity $entity, $rebuildPermissions = false)
504     {
505         $entity->book_id = $newBookId;
506         // Update related activity
507         foreach ($entity->activity as $activity) {
508             $activity->book_id = $newBookId;
509             $activity->save();
510         }
511         $entity->slug = $this->findSuitableSlug($type, $entity->name, $entity->id, $newBookId);
512         $entity->save();
513
514         // Update all child pages if a chapter
515         if (strtolower($type) === 'chapter') {
516             foreach ($entity->pages as $page) {
517                 $this->changeBook('page', $newBookId, $page, false);
518             }
519         }
520
521         // Update permissions if applicable
522         if ($rebuildPermissions) {
523             $entity->load('book');
524             $this->permissionService->buildJointPermissionsForEntity($entity->book);
525         }
526
527         return $entity;
528     }
529
530     /**
531      * Alias method to update the book jointPermissions in the PermissionService.
532      * @param Collection $collection collection on entities
533      */
534     public function buildJointPermissions(Collection $collection)
535     {
536         $this->permissionService->buildJointPermissionsForEntities($collection);
537     }
538
539     /**
540      * Format a name as a url slug.
541      * @param $name
542      * @return string
543      */
544     protected function nameToSlug($name)
545     {
546         $slug = str_replace(' ', '-', strtolower($name));
547         $slug = preg_replace('/[\+\/\\\?\@\}\{\.\,\=\[\]\#\&\!\*\'\;\:\$\%]/', '', $slug);
548         if ($slug === "") $slug = substr(md5(rand(1, 500)), 0, 5);
549         return $slug;
550     }
551
552     /**
553      * Publish a draft page to make it a normal page.
554      * Sets the slug and updates the content.
555      * @param Page $draftPage
556      * @param array $input
557      * @return Page
558      */
559     public function publishPageDraft(Page $draftPage, array $input)
560     {
561         $draftPage->fill($input);
562
563         // Save page tags if present
564         if (isset($input['tags'])) {
565             $this->tagRepo->saveTagsToEntity($draftPage, $input['tags']);
566         }
567
568         $draftPage->slug = $this->findSuitableSlug('page', $draftPage->name, false, $draftPage->book->id);
569         $draftPage->html = $this->formatHtml($input['html']);
570         $draftPage->text = strip_tags($draftPage->html);
571         $draftPage->draft = false;
572
573         $draftPage->save();
574         $this->savePageRevision($draftPage, trans('entities.pages_initial_revision'));
575         $this->searchService->indexEntity($draftPage);
576         return $draftPage;
577     }
578
579     /**
580      * Saves a page revision into the system.
581      * @param Page $page
582      * @param null|string $summary
583      * @return PageRevision
584      */
585     public function savePageRevision(Page $page, $summary = null)
586     {
587         $revision = $this->pageRevision->newInstance($page->toArray());
588         if (setting('app-editor') !== 'markdown') $revision->markdown = '';
589         $revision->page_id = $page->id;
590         $revision->slug = $page->slug;
591         $revision->book_slug = $page->book->slug;
592         $revision->created_by = user()->id;
593         $revision->created_at = $page->updated_at;
594         $revision->type = 'version';
595         $revision->summary = $summary;
596         $revision->save();
597
598         // Clear old revisions
599         if ($this->pageRevision->where('page_id', '=', $page->id)->count() > 50) {
600             $this->pageRevision->where('page_id', '=', $page->id)
601                 ->orderBy('created_at', 'desc')->skip(50)->take(5)->delete();
602         }
603
604         return $revision;
605     }
606
607     /**
608      * Formats a page's html to be tagged correctly
609      * within the system.
610      * @param string $htmlText
611      * @return string
612      */
613     protected function formatHtml($htmlText)
614     {
615         if ($htmlText == '') return $htmlText;
616         libxml_use_internal_errors(true);
617         $doc = new DOMDocument();
618         $doc->loadHTML(mb_convert_encoding($htmlText, 'HTML-ENTITIES', 'UTF-8'));
619
620         $container = $doc->documentElement;
621         $body = $container->childNodes->item(0);
622         $childNodes = $body->childNodes;
623
624         // Ensure no duplicate ids are used
625         $idArray = [];
626
627         foreach ($childNodes as $index => $childNode) {
628             /** @var \DOMElement $childNode */
629             if (get_class($childNode) !== 'DOMElement') continue;
630
631             // Overwrite id if not a BookStack custom id
632             if ($childNode->hasAttribute('id')) {
633                 $id = $childNode->getAttribute('id');
634                 if (strpos($id, 'bkmrk') === 0 && array_search($id, $idArray) === false) {
635                     $idArray[] = $id;
636                     continue;
637                 };
638             }
639
640             // Create an unique id for the element
641             // Uses the content as a basis to ensure output is the same every time
642             // the same content is passed through.
643             $contentId = 'bkmrk-' . substr(strtolower(preg_replace('/\s+/', '-', trim($childNode->nodeValue))), 0, 20);
644             $newId = urlencode($contentId);
645             $loopIndex = 0;
646             while (in_array($newId, $idArray)) {
647                 $newId = urlencode($contentId . '-' . $loopIndex);
648                 $loopIndex++;
649             }
650
651             $childNode->setAttribute('id', $newId);
652             $idArray[] = $newId;
653         }
654
655         // Generate inner html as a string
656         $html = '';
657         foreach ($childNodes as $childNode) {
658             $html .= $doc->saveHTML($childNode);
659         }
660
661         return $html;
662     }
663
664
665     /**
666      * Render the page for viewing, Parsing and performing features such as page transclusion.
667      * @param Page $page
668      * @return mixed|string
669      */
670     public function renderPage(Page $page)
671     {
672         $content = $page->html;
673         $matches = [];
674         preg_match_all("/{{@\s?([0-9].*?)}}/", $content, $matches);
675         if (count($matches[0]) === 0) return $content;
676
677         foreach ($matches[1] as $index => $includeId) {
678             $splitInclude = explode('#', $includeId, 2);
679             $pageId = intval($splitInclude[0]);
680             if (is_nan($pageId)) continue;
681
682             $page = $this->getById('page', $pageId);
683             if ($page === null) {
684                 $content = str_replace($matches[0][$index], '', $content);
685                 continue;
686             }
687
688             if (count($splitInclude) === 1) {
689                 $content = str_replace($matches[0][$index], $page->html, $content);
690                 continue;
691             }
692
693             $doc = new DOMDocument();
694             $doc->loadHTML(mb_convert_encoding('<body>'.$page->html.'</body>', 'HTML-ENTITIES', 'UTF-8'));
695             $matchingElem = $doc->getElementById($splitInclude[1]);
696             if ($matchingElem === null) {
697                 $content = str_replace($matches[0][$index], '', $content);
698                 continue;
699             }
700             $innerContent = '';
701             foreach ($matchingElem->childNodes as $childNode) {
702                 $innerContent .= $doc->saveHTML($childNode);
703             }
704             $content = str_replace($matches[0][$index], trim($innerContent), $content);
705         }
706
707         return $content;
708     }
709
710     /**
711      * Get a new draft page instance.
712      * @param Book $book
713      * @param Chapter|bool $chapter
714      * @return Page
715      */
716     public function getDraftPage(Book $book, $chapter = false)
717     {
718         $page = $this->page->newInstance();
719         $page->name = trans('entities.pages_initial_name');
720         $page->created_by = user()->id;
721         $page->updated_by = user()->id;
722         $page->draft = true;
723
724         if ($chapter) $page->chapter_id = $chapter->id;
725
726         $book->pages()->save($page);
727         $this->permissionService->buildJointPermissionsForEntity($page);
728         return $page;
729     }
730
731     /**
732      * Search for image usage within page content.
733      * @param $imageString
734      * @return mixed
735      */
736     public function searchForImage($imageString)
737     {
738         $pages = $this->entityQuery('page')->where('html', 'like', '%' . $imageString . '%')->get();
739         foreach ($pages as $page) {
740             $page->url = $page->getUrl();
741             $page->html = '';
742             $page->text = '';
743         }
744         return count($pages) > 0 ? $pages : false;
745     }
746
747     /**
748      * Parse the headers on the page to get a navigation menu
749      * @param String $pageContent
750      * @return array
751      */
752     public function getPageNav($pageContent)
753     {
754         if ($pageContent == '') return [];
755         libxml_use_internal_errors(true);
756         $doc = new DOMDocument();
757         $doc->loadHTML(mb_convert_encoding($pageContent, 'HTML-ENTITIES', 'UTF-8'));
758         $xPath = new DOMXPath($doc);
759         $headers = $xPath->query("//h1|//h2|//h3|//h4|//h5|//h6");
760
761         if (is_null($headers)) return [];
762
763         $tree = collect([]);
764         foreach ($headers as $header) {
765             $text = $header->nodeValue;
766             $tree->push([
767                 'nodeName' => strtolower($header->nodeName),
768                 'level' => intval(str_replace('h', '', $header->nodeName)),
769                 'link' => '#' . $header->getAttribute('id'),
770                 'text' => strlen($text) > 30 ? substr($text, 0, 27) . '...' : $text
771             ]);
772         }
773
774         // Normalise headers if only smaller headers have been used
775         if (count($tree) > 0) {
776             $minLevel = $tree->pluck('level')->min();
777             $tree = $tree->map(function($header) use ($minLevel) {
778                 $header['level'] -= ($minLevel - 2);
779                 return $header;
780             });
781         }
782         return $tree->toArray();
783     }
784
785     /**
786      * Updates a page with any fillable data and saves it into the database.
787      * @param Page $page
788      * @param int $book_id
789      * @param array $input
790      * @return Page
791      */
792     public function updatePage(Page $page, $book_id, $input)
793     {
794         // Hold the old details to compare later
795         $oldHtml = $page->html;
796         $oldName = $page->name;
797
798         // Prevent slug being updated if no name change
799         if ($page->name !== $input['name']) {
800             $page->slug = $this->findSuitableSlug('page', $input['name'], $page->id, $book_id);
801         }
802
803         // Save page tags if present
804         if (isset($input['tags'])) {
805             $this->tagRepo->saveTagsToEntity($page, $input['tags']);
806         }
807
808         // Update with new details
809         $userId = user()->id;
810         $page->fill($input);
811         $page->html = $this->formatHtml($input['html']);
812         $page->text = strip_tags($page->html);
813         if (setting('app-editor') !== 'markdown') $page->markdown = '';
814         $page->updated_by = $userId;
815         $page->save();
816
817         // Remove all update drafts for this user & page.
818         $this->userUpdatePageDraftsQuery($page, $userId)->delete();
819
820         // Save a revision after updating
821         if ($oldHtml !== $input['html'] || $oldName !== $input['name'] || $input['summary'] !== null) {
822             $this->savePageRevision($page, $input['summary']);
823         }
824
825         $this->searchService->indexEntity($page);
826
827         return $page;
828     }
829
830     /**
831      * The base query for getting user update drafts.
832      * @param Page $page
833      * @param $userId
834      * @return mixed
835      */
836     protected function userUpdatePageDraftsQuery(Page $page, $userId)
837     {
838         return $this->pageRevision->where('created_by', '=', $userId)
839             ->where('type', 'update_draft')
840             ->where('page_id', '=', $page->id)
841             ->orderBy('created_at', 'desc');
842     }
843
844     /**
845      * Checks whether a user has a draft version of a particular page or not.
846      * @param Page $page
847      * @param $userId
848      * @return bool
849      */
850     public function hasUserGotPageDraft(Page $page, $userId)
851     {
852         return $this->userUpdatePageDraftsQuery($page, $userId)->count() > 0;
853     }
854
855     /**
856      * Get the latest updated draft revision for a particular page and user.
857      * @param Page $page
858      * @param $userId
859      * @return mixed
860      */
861     public function getUserPageDraft(Page $page, $userId)
862     {
863         return $this->userUpdatePageDraftsQuery($page, $userId)->first();
864     }
865
866     /**
867      * Get the notification message that informs the user that they are editing a draft page.
868      * @param PageRevision $draft
869      * @return string
870      */
871     public function getUserPageDraftMessage(PageRevision $draft)
872     {
873         $message = trans('entities.pages_editing_draft_notification', ['timeDiff' => $draft->updated_at->diffForHumans()]);
874         if ($draft->page->updated_at->timestamp <= $draft->updated_at->timestamp) return $message;
875         return $message . "\n" . trans('entities.pages_draft_edited_notification');
876     }
877
878     /**
879      * Check if a page is being actively editing.
880      * Checks for edits since last page updated.
881      * Passing in a minuted range will check for edits
882      * within the last x minutes.
883      * @param Page $page
884      * @param null $minRange
885      * @return bool
886      */
887     public function isPageEditingActive(Page $page, $minRange = null)
888     {
889         $draftSearch = $this->activePageEditingQuery($page, $minRange);
890         return $draftSearch->count() > 0;
891     }
892
893     /**
894      * A query to check for active update drafts on a particular page.
895      * @param Page $page
896      * @param null $minRange
897      * @return mixed
898      */
899     protected function activePageEditingQuery(Page $page, $minRange = null)
900     {
901         $query = $this->pageRevision->where('type', '=', 'update_draft')
902             ->where('page_id', '=', $page->id)
903             ->where('updated_at', '>', $page->updated_at)
904             ->where('created_by', '!=', user()->id)
905             ->with('createdBy');
906
907         if ($minRange !== null) {
908             $query = $query->where('updated_at', '>=', Carbon::now()->subMinutes($minRange));
909         }
910
911         return $query;
912     }
913
914     /**
915      * Restores a revision's content back into a page.
916      * @param Page $page
917      * @param Book $book
918      * @param  int $revisionId
919      * @return Page
920      */
921     public function restorePageRevision(Page $page, Book $book, $revisionId)
922     {
923         $this->savePageRevision($page);
924         $revision = $this->getById('page_revision', $revisionId);
925         $page->fill($revision->toArray());
926         $page->slug = $this->findSuitableSlug('page', $page->name, $page->id, $book->id);
927         $page->text = strip_tags($page->html);
928         $page->updated_by = user()->id;
929         $page->save();
930         $this->searchService->indexEntity($page);
931         return $page;
932     }
933
934
935     /**
936      * Save a page update draft.
937      * @param Page $page
938      * @param array $data
939      * @return PageRevision|Page
940      */
941     public function updatePageDraft(Page $page, $data = [])
942     {
943         // If the page itself is a draft simply update that
944         if ($page->draft) {
945             $page->fill($data);
946             if (isset($data['html'])) {
947                 $page->text = strip_tags($data['html']);
948             }
949             $page->save();
950             return $page;
951         }
952
953         // Otherwise save the data to a revision
954         $userId = user()->id;
955         $drafts = $this->userUpdatePageDraftsQuery($page, $userId)->get();
956
957         if ($drafts->count() > 0) {
958             $draft = $drafts->first();
959         } else {
960             $draft = $this->pageRevision->newInstance();
961             $draft->page_id = $page->id;
962             $draft->slug = $page->slug;
963             $draft->book_slug = $page->book->slug;
964             $draft->created_by = $userId;
965             $draft->type = 'update_draft';
966         }
967
968         $draft->fill($data);
969         if (setting('app-editor') !== 'markdown') $draft->markdown = '';
970
971         $draft->save();
972         return $draft;
973     }
974
975     /**
976      * Get a notification message concerning the editing activity on a particular page.
977      * @param Page $page
978      * @param null $minRange
979      * @return string
980      */
981     public function getPageEditingActiveMessage(Page $page, $minRange = null)
982     {
983         $pageDraftEdits = $this->activePageEditingQuery($page, $minRange)->get();
984
985         $userMessage = $pageDraftEdits->count() > 1 ? trans('entities.pages_draft_edit_active.start_a', ['count' => $pageDraftEdits->count()]): trans('entities.pages_draft_edit_active.start_b', ['userName' => $pageDraftEdits->first()->createdBy->name]);
986         $timeMessage = $minRange === null ? trans('entities.pages_draft_edit_active.time_a') : trans('entities.pages_draft_edit_active.time_b', ['minCount'=>$minRange]);
987         return trans('entities.pages_draft_edit_active.message', ['start' => $userMessage, 'time' => $timeMessage]);
988     }
989
990     /**
991      * Change the page's parent to the given entity.
992      * @param Page $page
993      * @param Entity $parent
994      */
995     public function changePageParent(Page $page, Entity $parent)
996     {
997         $book = $parent->isA('book') ? $parent : $parent->book;
998         $page->chapter_id = $parent->isA('chapter') ? $parent->id : 0;
999         $page->save();
1000         if ($page->book->id !== $book->id) {
1001             $page = $this->changeBook('page', $book->id, $page);
1002         }
1003         $page->load('book');
1004         $this->permissionService->buildJointPermissionsForEntity($book);
1005     }
1006
1007     /**
1008      * Destroy the provided book and all its child entities.
1009      * @param Book $book
1010      */
1011     public function destroyBook(Book $book)
1012     {
1013         foreach ($book->pages as $page) {
1014             $this->destroyPage($page);
1015         }
1016         foreach ($book->chapters as $chapter) {
1017             $this->destroyChapter($chapter);
1018         }
1019         \Activity::removeEntity($book);
1020         $book->views()->delete();
1021         $book->permissions()->delete();
1022         $this->permissionService->deleteJointPermissionsForEntity($book);
1023         $this->searchService->deleteEntityTerms($book);
1024         $book->delete();
1025     }
1026
1027     /**
1028      * Destroy a chapter and its relations.
1029      * @param Chapter $chapter
1030      */
1031     public function destroyChapter(Chapter $chapter)
1032     {
1033         if (count($chapter->pages) > 0) {
1034             foreach ($chapter->pages as $page) {
1035                 $page->chapter_id = 0;
1036                 $page->save();
1037             }
1038         }
1039         \Activity::removeEntity($chapter);
1040         $chapter->views()->delete();
1041         $chapter->permissions()->delete();
1042         $this->permissionService->deleteJointPermissionsForEntity($chapter);
1043         $this->searchService->deleteEntityTerms($chapter);
1044         $chapter->delete();
1045     }
1046
1047     /**
1048      * Destroy a given page along with its dependencies.
1049      * @param Page $page
1050      */
1051     public function destroyPage(Page $page)
1052     {
1053         \Activity::removeEntity($page);
1054         $page->views()->delete();
1055         $page->tags()->delete();
1056         $page->revisions()->delete();
1057         $page->permissions()->delete();
1058         $this->permissionService->deleteJointPermissionsForEntity($page);
1059         $this->searchService->deleteEntityTerms($page);
1060
1061         // Delete Attached Files
1062         $attachmentService = app(AttachmentService::class);
1063         foreach ($page->attachments as $attachment) {
1064             $attachmentService->deleteFile($attachment);
1065         }
1066
1067         $page->delete();
1068     }
1069
1070 }
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082