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