BookStack Code Mirror - bookstack/blob - app/Repos/PageRepo.php

   1 <?php namespace BookStack\Repos;
   2
   3
   4 use Activity;
   5 use BookStack\Book;
   6 use BookStack\Chapter;
   7 use Illuminate\Http\Request;
   8 use Illuminate\Support\Facades\Auth;
   9 use Illuminate\Support\Facades\Log;
  10 use Illuminate\Support\Str;
  11 use BookStack\Page;
  12 use BookStack\PageRevision;
  13
  14 class PageRepo
  15 {
  16     protected $page;
  17     protected $pageRevision;
  18
  19     /**
  20      * PageRepo constructor.
  21      * @param Page         $page
  22      * @param PageRevision $pageRevision
  23      */
  24     public function __construct(Page $page, PageRevision $pageRevision)
  25     {
  26         $this->page = $page;
  27         $this->pageRevision = $pageRevision;
  28     }
  29
  30     /**
  31      * Check if a page id exists.
  32      * @param $id
  33      * @return bool
  34      */
  35     public function idExists($id)
  36     {
  37         return $this->page->where('page_id', '=', $id)->count() > 0;
  38     }
  39
  40     /**
  41      * Get a page via a specific ID.
  42      * @param $id
  43      * @return mixed
  44      */
  45     public function getById($id)
  46     {
  47         return $this->page->findOrFail($id);
  48     }
  49
  50     /**
  51      * Get all pages.
  52      * @return \Illuminate\Database\Eloquent\Collection|static[]
  53      */
  54     public function getAll()
  55     {
  56         return $this->page->all();
  57     }
  58
  59     /**
  60      * Get a page identified by the given slug.
  61      * @param $slug
  62      * @param $bookId
  63      * @return mixed
  64      */
  65     public function getBySlug($slug, $bookId)
  66     {
  67         $page = $this->page->where('slug', '=', $slug)->where('book_id', '=', $bookId)->first();
  68         if ($page === null) abort(404);
  69         return $page;
  70     }
  71
  72     /**
  73      * @param $input
  74      * @return Page
  75      */
  76     public function newFromInput($input)
  77     {
  78         $page = $this->page->fill($input);
  79         return $page;
  80     }
  81
  82     /**
  83      * Count the pages with a particular slug within a book.
  84      * @param $slug
  85      * @param $bookId
  86      * @return mixed
  87      */
  88     public function countBySlug($slug, $bookId)
  89     {
  90         return $this->page->where('slug', '=', $slug)->where('book_id', '=', $bookId)->count();
  91     }
  92
  93     /**
  94      * Save a new page into the system.
  95      * Input validation must be done beforehand.
  96      * @param array $input
  97      * @param Book  $book
  98      * @param int   $chapterId
  99      * @return Page
 100      */
 101     public function saveNew(array $input, Book $book, $chapterId = null)
 102     {
 103         $page = $this->newFromInput($input);
 104         $page->slug = $this->findSuitableSlug($page->name, $book->id);
 105
 106         if ($chapterId) $page->chapter_id = $chapterId;
 107
 108         $page->html = $this->formatHtml($input['html']);
 109         $page->text = strip_tags($page->html);
 110         $page->created_by = auth()->user()->id;
 111         $page->updated_by = auth()->user()->id;
 112
 113         $book->pages()->save($page);
 114         return $page;
 115     }
 116
 117     /**
 118      * Formats a page's html to be tagged correctly
 119      * within the system.
 120      * @param string $htmlText
 121      * @return string
 122      */
 123     protected function formatHtml($htmlText)
 124     {
 125         if($htmlText == '') return $htmlText;
 126         libxml_use_internal_errors(true);
 127         $doc = new \DOMDocument();
 128         $doc->loadHTML(mb_convert_encoding($htmlText, 'HTML-ENTITIES', 'UTF-8'));
 129
 130         $container = $doc->documentElement;
 131         $body = $container->childNodes->item(0);
 132         $childNodes = $body->childNodes;
 133
 134         // Ensure no duplicate ids are used
 135         $idArray = [];
 136
 137         foreach ($childNodes as $index => $childNode) {
 138             /** @var \DOMElement $childNode */
 139             if (get_class($childNode) !== 'DOMElement') continue;
 140
 141             // Overwrite id if not a BookStack custom id
 142             if ($childNode->hasAttribute('id')) {
 143                 $id = $childNode->getAttribute('id');
 144                 if (strpos($id, 'bkmrk') === 0 && array_search($id, $idArray) === false) {
 145                     $idArray[] = $id;
 146                     continue;
 147                 };
 148             }
 149
 150             // Create an unique id for the element
 151             // Uses the content as a basis to ensure output is the same every time
 152             // the same content is passed through.
 153             $contentId = 'bkmrk-' . substr(strtolower(preg_replace('/\s+/', '-', trim($childNode->nodeValue))), 0, 20);
 154             $newId = urlencode($contentId);
 155             $loopIndex = 0;
 156             while (in_array($newId, $idArray)) {
 157                 $newId = urlencode($contentId . '-' . $loopIndex);
 158                 $loopIndex++;
 159             }
 160
 161             $childNode->setAttribute('id', $newId);
 162             $idArray[] = $newId;
 163         }
 164
 165         // Generate inner html as a string
 166         $html = '';
 167         foreach ($childNodes as $childNode) {
 168             $html .= $doc->saveHTML($childNode);
 169         }
 170
 171         return $html;
 172     }
 173
 174
 175     /**
 176      * Gets pages by a search term.
 177      * Highlights page content for showing in results.
 178      * @param string      $term
 179      * @param array $whereTerms
 180      * @return mixed
 181      */
 182     public function getBySearch($term, $whereTerms = [])
 183     {
 184         $terms = explode(' ', $term);
 185         $pages = $this->page->fullTextSearch(['name', 'text'], $terms, $whereTerms);
 186
 187         // Add highlights to page text.
 188         $words = join('|', explode(' ', preg_quote(trim($term), '/')));
 189         //lookahead/behind assertions ensures cut between words
 190         $s = '\s\x00-/:-@\[-`{-~'; //character set for start/end of words
 191
 192         foreach ($pages as $page) {
 193             preg_match_all('#(?<=[' . $s . ']).{1,30}((' . $words . ').{1,30})+(?=[' . $s . '])#uis', $page->text, $matches, PREG_SET_ORDER);
 194             //delimiter between occurrences
 195             $results = [];
 196             foreach ($matches as $line) {
 197                 $results[] = htmlspecialchars($line[0], 0, 'UTF-8');
 198             }
 199             $matchLimit = 6;
 200             if (count($results) > $matchLimit) {
 201                 $results = array_slice($results, 0, $matchLimit);
 202             }
 203             $result = join('... ', $results);
 204
 205             //highlight
 206             $result = preg_replace('#' . $words . '#iu', "<span class=\"highlight\">\$0</span>", $result);
 207             if (strlen($result) < 5) {
 208                 $result = $page->getExcerpt(80);
 209             }
 210             $page->searchSnippet = $result;
 211         }
 212         return $pages;
 213     }
 214
 215     /**
 216      * Search for image usage.
 217      * @param $imageString
 218      * @return mixed
 219      */
 220     public function searchForImage($imageString)
 221     {
 222         $pages = $this->page->where('html', 'like', '%' . $imageString . '%')->get();
 223         foreach ($pages as $page) {
 224             $page->url = $page->getUrl();
 225             $page->html = '';
 226             $page->text = '';
 227         }
 228         return count($pages) > 0 ? $pages : false;
 229     }
 230
 231     /**
 232      * Updates a page with any fillable data and saves it into the database.
 233      * @param Page   $page
 234      * @param int    $book_id
 235      * @param string $input
 236      * @return Page
 237      */
 238     public function updatePage(Page $page, $book_id, $input)
 239     {
 240         // Save a revision before updating
 241         if ($page->html !== $input['html'] || $page->name !== $input['name']) {
 242             $this->saveRevision($page);
 243         }
 244
 245         // Update with new details
 246         $page->fill($input);
 247         $page->slug = $this->findSuitableSlug($page->name, $book_id, $page->id);
 248         $page->html = $this->formatHtml($input['html']);
 249         $page->text = strip_tags($page->html);
 250         $page->updated_by = auth()->user()->id;
 251         $page->save();
 252         return $page;
 253     }
 254
 255     /**
 256      * Restores a revision's content back into a page.
 257      * @param Page $page
 258      * @param Book $book
 259      * @param  int $revisionId
 260      * @return Page
 261      */
 262     public function restoreRevision(Page $page, Book $book, $revisionId)
 263     {
 264         $this->saveRevision($page);
 265         $revision = $this->getRevisionById($revisionId);
 266         $page->fill($revision->toArray());
 267         $page->slug = $this->findSuitableSlug($page->name, $book->id, $page->id);
 268         $page->text = strip_tags($page->html);
 269         $page->updated_by = auth()->user()->id;
 270         $page->save();
 271         return $page;
 272     }
 273
 274     /**
 275      * Saves a page revision into the system.
 276      * @param Page $page
 277      * @return $this
 278      */
 279     public function saveRevision(Page $page)
 280     {
 281         $revision = $this->pageRevision->fill($page->toArray());
 282         $revision->page_id = $page->id;
 283         $revision->created_by = auth()->user()->id;
 284         $revision->created_at = $page->updated_at;
 285         $revision->save();
 286         // Clear old revisions
 287         if ($this->pageRevision->where('page_id', '=', $page->id)->count() > 50) {
 288             $this->pageRevision->where('page_id', '=', $page->id)
 289                 ->orderBy('created_at', 'desc')->skip(50)->take(5)->delete();
 290         }
 291         return $revision;
 292     }
 293
 294     /**
 295      * Gets a single revision via it's id.
 296      * @param $id
 297      * @return mixed
 298      */
 299     public function getRevisionById($id)
 300     {
 301         return $this->pageRevision->findOrFail($id);
 302     }
 303
 304     /**
 305      * Checks if a slug exists within a book already.
 306      * @param            $slug
 307      * @param            $bookId
 308      * @param bool|false $currentId
 309      * @return bool
 310      */
 311     public function doesSlugExist($slug, $bookId, $currentId = false)
 312     {
 313         $query = $this->page->where('slug', '=', $slug)->where('book_id', '=', $bookId);
 314         if ($currentId) $query = $query->where('id', '!=', $currentId);
 315         return $query->count() > 0;
 316     }
 317
 318     /**
 319      * Changes the related book for the specified page.
 320      * Changes the book id of any relations to the page that store the book id.
 321      * @param int  $bookId
 322      * @param Page $page
 323      * @return Page
 324      */
 325     public function changeBook($bookId, Page $page)
 326     {
 327         $page->book_id = $bookId;
 328         foreach ($page->activity as $activity) {
 329             $activity->book_id = $bookId;
 330             $activity->save();
 331         }
 332         $page->slug = $this->findSuitableSlug($page->name, $bookId, $page->id);
 333         $page->save();
 334         return $page;
 335     }
 336
 337     /**
 338      * Gets a suitable slug for the resource
 339      * @param            $name
 340      * @param            $bookId
 341      * @param bool|false $currentId
 342      * @return string
 343      */
 344     public function findSuitableSlug($name, $bookId, $currentId = false)
 345     {
 346         $slug = Str::slug($name);
 347         while ($this->doesSlugExist($slug, $bookId, $currentId)) {
 348             $slug .= '-' . substr(md5(rand(1, 500)), 0, 3);
 349         }
 350         return $slug;
 351     }
 352
 353     /**
 354      * Destroy a given page along with its dependencies.
 355      * @param $page
 356      */
 357     public function destroy($page)
 358     {
 359         Activity::removeEntity($page);
 360         $page->views()->delete();
 361         $page->revisions()->delete();
 362         $page->delete();
 363     }
 364
 365     /**
 366      * Get the latest pages added to the system.
 367      * @param $count
 368      */
 369     public function getRecentlyCreatedPaginated($count = 20)
 370     {
 371         return $this->page->orderBy('created_at', 'desc')->paginate($count);
 372     }
 373
 374     /**
 375      * Get the latest pages added to the system.
 376      * @param $count
 377      */
 378     public function getRecentlyUpdatedPaginated($count = 20)
 379     {
 380         return $this->page->orderBy('updated_at', 'desc')->paginate($count);
 381     }
 382
 383 }