BookStack Code Mirror - bookstack/blob - app/Entities/Tools/TrashCan.php

   1 <?php
   2
   3 namespace BookStack\Entities\Tools;
   4
   5 use BookStack\Entities\EntityProvider;
   6 use BookStack\Entities\Models\Book;
   7 use BookStack\Entities\Models\Bookshelf;
   8 use BookStack\Entities\Models\Chapter;
   9 use BookStack\Entities\Models\Deletion;
  10 use BookStack\Entities\Models\Entity;
  11 use BookStack\Entities\Models\HasCoverImage;
  12 use BookStack\Entities\Models\Page;
  13 use BookStack\Exceptions\NotifyException;
  14 use BookStack\Facades\Activity;
  15 use BookStack\Uploads\AttachmentService;
  16 use BookStack\Uploads\ImageService;
  17 use Exception;
  18 use Illuminate\Database\Eloquent\Builder;
  19 use Illuminate\Support\Carbon;
  20
  21 class TrashCan
  22 {
  23     /**
  24      * Send a shelf to the recycle bin.
  25      *
  26      * @throws NotifyException
  27      */
  28     public function softDestroyShelf(Bookshelf $shelf)
  29     {
  30         $this->ensureDeletable($shelf);
  31         Deletion::createForEntity($shelf);
  32         $shelf->delete();
  33     }
  34
  35     /**
  36      * Send a book to the recycle bin.
  37      *
  38      * @throws Exception
  39      */
  40     public function softDestroyBook(Book $book)
  41     {
  42         $this->ensureDeletable($book);
  43         Deletion::createForEntity($book);
  44
  45         foreach ($book->pages as $page) {
  46             $this->softDestroyPage($page, false);
  47         }
  48
  49         foreach ($book->chapters as $chapter) {
  50             $this->softDestroyChapter($chapter, false);
  51         }
  52
  53         $book->delete();
  54     }
  55
  56     /**
  57      * Send a chapter to the recycle bin.
  58      *
  59      * @throws Exception
  60      */
  61     public function softDestroyChapter(Chapter $chapter, bool $recordDelete = true)
  62     {
  63         if ($recordDelete) {
  64             $this->ensureDeletable($chapter);
  65             Deletion::createForEntity($chapter);
  66         }
  67
  68         if (count($chapter->pages) > 0) {
  69             foreach ($chapter->pages as $page) {
  70                 $this->softDestroyPage($page, false);
  71             }
  72         }
  73
  74         $chapter->delete();
  75     }
  76
  77     /**
  78      * Send a page to the recycle bin.
  79      *
  80      * @throws Exception
  81      */
  82     public function softDestroyPage(Page $page, bool $recordDelete = true)
  83     {
  84         if ($recordDelete) {
  85             $this->ensureDeletable($page);
  86             Deletion::createForEntity($page);
  87         }
  88
  89         $page->delete();
  90     }
  91
  92     /**
  93      * Ensure the given entity is deletable.
  94      * Is not for permissions, but logical conditions within the application.
  95      * Will throw if not deletable.
  96      *
  97      * @throws NotifyException
  98      */
  99     protected function ensureDeletable(Entity $entity): void
 100     {
 101         $customHomeId = intval(explode(':', setting('app-homepage', '0:'))[0]);
 102         $customHomeActive = setting('app-homepage-type') === 'page';
 103         $removeCustomHome = false;
 104
 105         // Check custom homepage usage for pages
 106         if ($entity instanceof Page && $entity->id === $customHomeId) {
 107             if ($customHomeActive) {
 108                 throw new NotifyException(trans('errors.page_custom_home_deletion'), $entity->getUrl());
 109             }
 110             $removeCustomHome = true;
 111         }
 112
 113         // Check custom homepage usage within chapters or books
 114         if ($entity instanceof Chapter || $entity instanceof Book) {
 115             if ($entity->pages()->where('id', '=', $customHomeId)->exists()) {
 116                 if ($customHomeActive) {
 117                     throw new NotifyException(trans('errors.page_custom_home_deletion'), $entity->getUrl());
 118                 }
 119                 $removeCustomHome = true;
 120             }
 121         }
 122
 123         if ($removeCustomHome) {
 124             setting()->remove('app-homepage');
 125         }
 126     }
 127
 128     /**
 129      * Remove a bookshelf from the system.
 130      *
 131      * @throws Exception
 132      */
 133     protected function destroyShelf(Bookshelf $shelf): int
 134     {
 135         $this->destroyCommonRelations($shelf);
 136         $shelf->forceDelete();
 137
 138         return 1;
 139     }
 140
 141     /**
 142      * Remove a book from the system.
 143      * Destroys any child chapters and pages.
 144      *
 145      * @throws Exception
 146      */
 147     protected function destroyBook(Book $book): int
 148     {
 149         $count = 0;
 150         $pages = $book->pages()->withTrashed()->get();
 151         foreach ($pages as $page) {
 152             $this->destroyPage($page);
 153             $count++;
 154         }
 155
 156         $chapters = $book->chapters()->withTrashed()->get();
 157         foreach ($chapters as $chapter) {
 158             $this->destroyChapter($chapter);
 159             $count++;
 160         }
 161
 162         $this->destroyCommonRelations($book);
 163         $book->forceDelete();
 164
 165         return $count + 1;
 166     }
 167
 168     /**
 169      * Remove a chapter from the system.
 170      * Destroys all pages within.
 171      *
 172      * @throws Exception
 173      */
 174     protected function destroyChapter(Chapter $chapter): int
 175     {
 176         $count = 0;
 177         $pages = $chapter->pages()->withTrashed()->get();
 178         foreach ($pages as $page) {
 179             $this->destroyPage($page);
 180             $count++;
 181         }
 182
 183         $this->destroyCommonRelations($chapter);
 184         $chapter->forceDelete();
 185
 186         return $count + 1;
 187     }
 188
 189     /**
 190      * Remove a page from the system.
 191      *
 192      * @throws Exception
 193      */
 194     protected function destroyPage(Page $page): int
 195     {
 196         $this->destroyCommonRelations($page);
 197         $page->allRevisions()->delete();
 198
 199         // Delete Attached Files
 200         $attachmentService = app()->make(AttachmentService::class);
 201         foreach ($page->attachments as $attachment) {
 202             $attachmentService->deleteFile($attachment);
 203         }
 204
 205         // Remove book template usages
 206         Book::query()->where('default_template', '=', $page->id)
 207             ->update(['default_template' => null]);
 208
 209         $page->forceDelete();
 210
 211         return 1;
 212     }
 213
 214     /**
 215      * Get the total counts of those that have been trashed
 216      * but not yet fully deleted (In recycle bin).
 217      */
 218     public function getTrashedCounts(): array
 219     {
 220         $counts = [];
 221
 222         foreach ((new EntityProvider())->all() as $key => $instance) {
 223             /** @var Builder<Entity> $query */
 224             $query = $instance->newQuery();
 225             $counts[$key] = $query->onlyTrashed()->count();
 226         }
 227
 228         return $counts;
 229     }
 230
 231     /**
 232      * Destroy all items that have pending deletions.
 233      *
 234      * @throws Exception
 235      */
 236     public function empty(): int
 237     {
 238         $deletions = Deletion::all();
 239         $deleteCount = 0;
 240         foreach ($deletions as $deletion) {
 241             $deleteCount += $this->destroyFromDeletion($deletion);
 242         }
 243
 244         return $deleteCount;
 245     }
 246
 247     /**
 248      * Destroy an element from the given deletion model.
 249      *
 250      * @throws Exception
 251      */
 252     public function destroyFromDeletion(Deletion $deletion): int
 253     {
 254         // We directly load the deletable element here just to ensure it still
 255         // exists in the event it has already been destroyed during this request.
 256         $entity = $deletion->deletable()->first();
 257         $count = 0;
 258         if ($entity) {
 259             $count = $this->destroyEntity($deletion->deletable);
 260         }
 261         $deletion->delete();
 262
 263         return $count;
 264     }
 265
 266     /**
 267      * Restore the content within the given deletion.
 268      *
 269      * @throws Exception
 270      */
 271     public function restoreFromDeletion(Deletion $deletion): int
 272     {
 273         $shouldRestore = true;
 274         $restoreCount = 0;
 275
 276         if ($deletion->deletable instanceof Entity) {
 277             $parent = $deletion->deletable->getParent();
 278             if ($parent && $parent->trashed()) {
 279                 $shouldRestore = false;
 280             }
 281         }
 282
 283         if ($deletion->deletable instanceof Entity && $shouldRestore) {
 284             $restoreCount = $this->restoreEntity($deletion->deletable);
 285         }
 286
 287         $deletion->delete();
 288
 289         return $restoreCount;
 290     }
 291
 292     /**
 293      * Automatically clear old content from the recycle bin
 294      * depending on the configured lifetime.
 295      * Returns the total number of deleted elements.
 296      *
 297      * @throws Exception
 298      */
 299     public function autoClearOld(): int
 300     {
 301         $lifetime = intval(config('app.recycle_bin_lifetime'));
 302         if ($lifetime < 0) {
 303             return 0;
 304         }
 305
 306         $clearBeforeDate = Carbon::now()->addSeconds(10)->subDays($lifetime);
 307         $deleteCount = 0;
 308
 309         $deletionsToRemove = Deletion::query()->where('created_at', '<', $clearBeforeDate)->get();
 310         foreach ($deletionsToRemove as $deletion) {
 311             $deleteCount += $this->destroyFromDeletion($deletion);
 312         }
 313
 314         return $deleteCount;
 315     }
 316
 317     /**
 318      * Restore an entity so it is essentially un-deleted.
 319      * Deletions on restored child elements will be removed during this restoration.
 320      */
 321     protected function restoreEntity(Entity $entity): int
 322     {
 323         $count = 1;
 324         $entity->restore();
 325
 326         $restoreAction = function ($entity) use (&$count) {
 327             if ($entity->deletions_count > 0) {
 328                 $entity->deletions()->delete();
 329             }
 330
 331             $entity->restore();
 332             $count++;
 333         };
 334
 335         if ($entity instanceof Chapter || $entity instanceof Book) {
 336             $entity->pages()->withTrashed()->withCount('deletions')->get()->each($restoreAction);
 337         }
 338
 339         if ($entity instanceof Book) {
 340             $entity->chapters()->withTrashed()->withCount('deletions')->get()->each($restoreAction);
 341         }
 342
 343         return $count;
 344     }
 345
 346     /**
 347      * Destroy the given entity.
 348      *
 349      * @throws Exception
 350      */
 351     public function destroyEntity(Entity $entity): int
 352     {
 353         if ($entity instanceof Page) {
 354             return $this->destroyPage($entity);
 355         }
 356         if ($entity instanceof Chapter) {
 357             return $this->destroyChapter($entity);
 358         }
 359         if ($entity instanceof Book) {
 360             return $this->destroyBook($entity);
 361         }
 362         if ($entity instanceof Bookshelf) {
 363             return $this->destroyShelf($entity);
 364         }
 365
 366         return 0;
 367     }
 368
 369     /**
 370      * Update entity relations to remove or update outstanding connections.
 371      */
 372     protected function destroyCommonRelations(Entity $entity)
 373     {
 374         Activity::removeEntity($entity);
 375         $entity->views()->delete();
 376         $entity->permissions()->delete();
 377         $entity->tags()->delete();
 378         $entity->comments()->delete();
 379         $entity->jointPermissions()->delete();
 380         $entity->searchTerms()->delete();
 381         $entity->deletions()->delete();
 382         $entity->favourites()->delete();
 383         $entity->watches()->delete();
 384         $entity->referencesTo()->delete();
 385         $entity->referencesFrom()->delete();
 386
 387         if ($entity instanceof HasCoverImage && $entity->cover()->exists()) {
 388             $imageService = app()->make(ImageService::class);
 389             $imageService->destroy($entity->cover()->first());
 390         }
 391     }
 392 }