Re-structured the app code to be feature based rather than code type based

app/Uploads/Attachment.php

@@ -0,0 +1,42 @@
+<?php namespace BookStack\Uploads;
+
+use BookStack\Entities\Page;
+use BookStack\Ownable;
+
+class Attachment extends Ownable
+{
+    protected $fillable = ['name', 'order'];
+
+    /**
+     * Get the downloadable file name for this upload.
+     * @return mixed|string
+     */
+    public function getFileName()
+    {
+        if (str_contains($this->name, '.')) {
+            return $this->name;
+        }
+        return $this->name . '.' . $this->extension;
+    }
+
+    /**
+     * Get the page this file was uploaded to.
+     * @return Page
+     */
+    public function page()
+    {
+        return $this->belongsTo(Page::class, 'uploaded_to');
+    }
+
+    /**
+     * Get the url of this file.
+     * @return string
+     */
+    public function getUrl()
+    {
+        if ($this->external && strpos($this->path, 'http') !== 0) {
+            return $this->path;
+        }
+        return baseUrl('/attachments/' . $this->id);
+    }
+}

app/Uploads/AttachmentService.php

@@ -0,0 +1,205 @@
+<?php namespace BookStack\Uploads;
+
+use BookStack\Exceptions\FileUploadException;
+use BookStack\Uploads\Attachment;
+use BookStack\Uploads\UploadService;
+use Exception;
+use Symfony\Component\HttpFoundation\File\UploadedFile;
+
+class AttachmentService extends UploadService
+{
+
+    /**
+     * Get the storage that will be used for storing files.
+     * @return \Illuminate\Contracts\Filesystem\Filesystem
+     */
+    protected function getStorage()
+    {
+        $storageType = config('filesystems.default');
+
+        // Override default location if set to local public to ensure not visible.
+        if ($storageType === 'local') {
+            $storageType = 'local_secure';
+        }
+
+        return $this->fileSystem->disk($storageType);
+    }
+
+    /**
+     * Get an attachment from storage.
+     * @param Attachment $attachment
+     * @return string
+     * @throws \Illuminate\Contracts\Filesystem\FileNotFoundException
+     */
+    public function getAttachmentFromStorage(Attachment $attachment)
+    {
+        return $this->getStorage()->get($attachment->path);
+    }
+
+    /**
+     * Store a new attachment upon user upload.
+     * @param UploadedFile $uploadedFile
+     * @param int $page_id
+     * @return Attachment
+     * @throws FileUploadException
+     */
+    public function saveNewUpload(UploadedFile $uploadedFile, $page_id)
+    {
+        $attachmentName = $uploadedFile->getClientOriginalName();
+        $attachmentPath = $this->putFileInStorage($attachmentName, $uploadedFile);
+        $largestExistingOrder = Attachment::where('uploaded_to', '=', $page_id)->max('order');
+
+        $attachment = Attachment::forceCreate([
+            'name' => $attachmentName,
+            'path' => $attachmentPath,
+            'extension' => $uploadedFile->getClientOriginalExtension(),
+            'uploaded_to' => $page_id,
+            'created_by' => user()->id,
+            'updated_by' => user()->id,
+            'order' => $largestExistingOrder + 1
+        ]);
+
+        return $attachment;
+    }
+
+    /**
+     * Store a upload, saving to a file and deleting any existing uploads
+     * attached to that file.
+     * @param UploadedFile $uploadedFile
+     * @param Attachment $attachment
+     * @return Attachment
+     * @throws FileUploadException
+     */
+    public function saveUpdatedUpload(UploadedFile $uploadedFile, Attachment $attachment)
+    {
+        if (!$attachment->external) {
+            $this->deleteFileInStorage($attachment);
+        }
+
+        $attachmentName = $uploadedFile->getClientOriginalName();
+        $attachmentPath = $this->putFileInStorage($attachmentName, $uploadedFile);
+
+        $attachment->name = $attachmentName;
+        $attachment->path = $attachmentPath;
+        $attachment->external = false;
+        $attachment->extension = $uploadedFile->getClientOriginalExtension();
+        $attachment->save();
+        return $attachment;
+    }
+
+    /**
+     * Save a new File attachment from a given link and name.
+     * @param string $name
+     * @param string $link
+     * @param int $page_id
+     * @return Attachment
+     */
+    public function saveNewFromLink($name, $link, $page_id)
+    {
+        $largestExistingOrder = Attachment::where('uploaded_to', '=', $page_id)->max('order');
+        return Attachment::forceCreate([
+            'name' => $name,
+            'path' => $link,
+            'external' => true,
+            'extension' => '',
+            'uploaded_to' => $page_id,
+            'created_by' => user()->id,
+            'updated_by' => user()->id,
+            'order' => $largestExistingOrder + 1
+        ]);
+    }
+
+    /**
+     * Updates the file ordering for a listing of attached files.
+     * @param array $attachmentList
+     * @param $pageId
+     */
+    public function updateFileOrderWithinPage($attachmentList, $pageId)
+    {
+        foreach ($attachmentList as $index => $attachment) {
+            Attachment::where('uploaded_to', '=', $pageId)->where('id', '=', $attachment['id'])->update(['order' => $index]);
+        }
+    }
+
+
+    /**
+     * Update the details of a file.
+     * @param Attachment $attachment
+     * @param $requestData
+     * @return Attachment
+     */
+    public function updateFile(Attachment $attachment, $requestData)
+    {
+        $attachment->name = $requestData['name'];
+        if (isset($requestData['link']) && trim($requestData['link']) !== '') {
+            $attachment->path = $requestData['link'];
+            if (!$attachment->external) {
+                $this->deleteFileInStorage($attachment);
+                $attachment->external = true;
+            }
+        }
+        $attachment->save();
+        return $attachment;
+    }
+
+    /**
+     * Delete a File from the database and storage.
+     * @param Attachment $attachment
+     * @throws Exception
+     */
+    public function deleteFile(Attachment $attachment)
+    {
+        if ($attachment->external) {
+            $attachment->delete();
+            return;
+        }
+        
+        $this->deleteFileInStorage($attachment);
+        $attachment->delete();
+    }
+
+    /**
+     * Delete a file from the filesystem it sits on.
+     * Cleans any empty leftover folders.
+     * @param Attachment $attachment
+     */
+    protected function deleteFileInStorage(Attachment $attachment)
+    {
+        $storage = $this->getStorage();
+        $dirPath = dirname($attachment->path);
+
+        $storage->delete($attachment->path);
+        if (count($storage->allFiles($dirPath)) === 0) {
+            $storage->deleteDirectory($dirPath);
+        }
+    }
+
+    /**
+     * Store a file in storage with the given filename
+     * @param $attachmentName
+     * @param UploadedFile $uploadedFile
+     * @return string
+     * @throws FileUploadException
+     */
+    protected function putFileInStorage($attachmentName, UploadedFile $uploadedFile)
+    {
+        $attachmentData = file_get_contents($uploadedFile->getRealPath());
+
+        $storage = $this->getStorage();
+        $basePath = 'uploads/files/' . Date('Y-m-M') . '/';
+
+        $uploadFileName = $attachmentName;
+        while ($storage->exists($basePath . $uploadFileName)) {
+            $uploadFileName = str_random(3) . $uploadFileName;
+        }
+
+        $attachmentPath = $basePath . $uploadFileName;
+        try {
+            $storage->put($attachmentPath, $attachmentData);
+        } catch (Exception $e) {
+            throw new FileUploadException(trans('errors.path_not_writable', ['filePath' => $attachmentPath]));
+        }
+
+        return $attachmentPath;
+    }
+}

app/Uploads/Image.php

@@ -0,0 +1,23 @@
+<?php namespace BookStack\Uploads;
+
+use BookStack\Ownable;
+use Images;
+
+class Image extends Ownable
+{
+
+    protected $fillable = ['name'];
+
+    /**
+     * Get a thumbnail for this image.
+     * @param  int $width
+     * @param  int $height
+     * @param bool|false $keepRatio
+     * @return string
+     * @throws \Exception
+     */
+    public function getThumb($width, $height, $keepRatio = false)
+    {
+        return Images::getThumbnail($this, $width, $height, $keepRatio);
+    }
+}

app/Uploads/ImageRepo.php

@@ -0,0 +1,246 @@
+<?php namespace BookStack\Uploads;
+
+use BookStack\Uploads\Image;
+use BookStack\Entities\Page;
+use BookStack\Uploads\ImageService;
+use BookStack\Auth\Permissions\PermissionService;
+use Symfony\Component\HttpFoundation\File\UploadedFile;
+
+class ImageRepo
+{
+
+    protected $image;
+    protected $imageService;
+    protected $restrictionService;
+    protected $page;
+
+    /**
+     * ImageRepo constructor.
+     * @param Image $image
+     * @param ImageService $imageService
+     * @param \BookStack\Auth\\BookStack\Auth\Permissions\PermissionService $permissionService
+     * @param \BookStack\Entities\Page $page
+     */
+    public function __construct(Image $image, ImageService $imageService, PermissionService $permissionService, Page $page)
+    {
+        $this->image = $image;
+        $this->imageService = $imageService;
+        $this->restrictionService = $permissionService;
+        $this->page = $page;
+    }
+
+
+    /**
+     * Get an image with the given id.
+     * @param $id
+     * @return mixed
+     */
+    public function getById($id)
+    {
+        return $this->image->findOrFail($id);
+    }
+
+    /**
+     * Execute a paginated query, returning in a standard format.
+     * Also runs the query through the restriction system.
+     * @param $query
+     * @param int $page
+     * @param int $pageSize
+     * @return array
+     */
+    private function returnPaginated($query, $page = 0, $pageSize = 24)
+    {
+        $images = $this->restrictionService->filterRelatedPages($query, 'images', 'uploaded_to');
+        $images = $images->orderBy('created_at', 'desc')->skip($pageSize * $page)->take($pageSize + 1)->get();
+        $hasMore = count($images) > $pageSize;
+
+        $returnImages = $images->take(24);
+        $returnImages->each(function ($image) {
+            $this->loadThumbs($image);
+        });
+
+        return [
+            'images'  => $returnImages,
+            'hasMore' => $hasMore
+        ];
+    }
+
+    /**
+     * Gets a load images paginated, filtered by image type.
+     * @param string $type
+     * @param int $page
+     * @param int $pageSize
+     * @param bool|int $userFilter
+     * @return array
+     */
+    public function getPaginatedByType($type, $page = 0, $pageSize = 24, $userFilter = false)
+    {
+        $images = $this->image->where('type', '=', strtolower($type));
+
+        if ($userFilter !== false) {
+            $images = $images->where('created_by', '=', $userFilter);
+        }
+
+        return $this->returnPaginated($images, $page, $pageSize);
+    }
+
+    /**
+     * Search for images by query, of a particular type.
+     * @param string $type
+     * @param int $page
+     * @param int $pageSize
+     * @param string $searchTerm
+     * @return array
+     */
+    public function searchPaginatedByType($type, $searchTerm, $page = 0, $pageSize = 24)
+    {
+        $images = $this->image->where('type', '=', strtolower($type))->where('name', 'LIKE', '%' . $searchTerm . '%');
+        return $this->returnPaginated($images, $page, $pageSize);
+    }
+
+    /**
+     * Get gallery images with a particular filter criteria such as
+     * being within the current book or page.
+     * @param $filter
+     * @param $pageId
+     * @param int $pageNum
+     * @param int $pageSize
+     * @return array
+     */
+    public function getGalleryFiltered($filter, $pageId, $pageNum = 0, $pageSize = 24)
+    {
+        $images = $this->image->where('type', '=', 'gallery');
+
+        $page = $this->page->findOrFail($pageId);
+
+        if ($filter === 'page') {
+            $images = $images->where('uploaded_to', '=', $page->id);
+        } elseif ($filter === 'book') {
+            $validPageIds = $page->book->pages->pluck('id')->toArray();
+            $images = $images->whereIn('uploaded_to', $validPageIds);
+        }
+
+        return $this->returnPaginated($images, $pageNum, $pageSize);
+    }
+
+    /**
+     * Save a new image into storage and return the new image.
+     * @param UploadedFile $uploadFile
+     * @param  string $type
+     * @param int $uploadedTo
+     * @return Image
+     * @throws \BookStack\Exceptions\ImageUploadException
+     * @throws \Exception
+     */
+    public function saveNew(UploadedFile $uploadFile, $type, $uploadedTo = 0)
+    {
+        $image = $this->imageService->saveNewFromUpload($uploadFile, $type, $uploadedTo);
+        $this->loadThumbs($image);
+        return $image;
+    }
+
+    /**
+     * Save a drawing the the database;
+     * @param string $base64Uri
+     * @param int $uploadedTo
+     * @return Image
+     * @throws \BookStack\Exceptions\ImageUploadException
+     */
+    public function saveDrawing(string $base64Uri, int $uploadedTo)
+    {
+        $name = 'Drawing-' . user()->getShortName(40) . '-' . strval(time()) . '.png';
+        $image = $this->imageService->saveNewFromBase64Uri($base64Uri, $name, 'drawio', $uploadedTo);
+        return $image;
+    }
+
+
+    /**
+     * Update the details of an image via an array of properties.
+     * @param Image $image
+     * @param array $updateDetails
+     * @return Image
+     * @throws \BookStack\Exceptions\ImageUploadException
+     * @throws \Exception
+     */
+    public function updateImageDetails(Image $image, $updateDetails)
+    {
+        $image->fill($updateDetails);
+        $image->save();
+        $this->loadThumbs($image);
+        return $image;
+    }
+
+
+    /**
+     * Destroys an Image object along with its revisions, files and thumbnails.
+     * @param Image $image
+     * @return bool
+     * @throws \Exception
+     */
+    public function destroyImage(Image $image)
+    {
+        $this->imageService->destroy($image);
+        return true;
+    }
+
+
+    /**
+     * Load thumbnails onto an image object.
+     * @param Image $image
+     * @throws \BookStack\Exceptions\ImageUploadException
+     * @throws \Exception
+     */
+    protected function loadThumbs(Image $image)
+    {
+        $image->thumbs = [
+            'gallery' => $this->getThumbnail($image, 150, 150),
+            'display' => $this->getThumbnail($image, 840, 0, true)
+        ];
+    }
+
+    /**
+     * Get the thumbnail for an image.
+     * If $keepRatio is true only the width will be used.
+     * Checks the cache then storage to avoid creating / accessing the filesystem on every check.
+     * @param Image $image
+     * @param int $width
+     * @param int $height
+     * @param bool $keepRatio
+     * @return string
+     * @throws \BookStack\Exceptions\ImageUploadException
+     * @throws \Exception
+     */
+    public function getThumbnail(Image $image, $width = 220, $height = 220, $keepRatio = false)
+    {
+        try {
+            return $this->imageService->getThumbnail($image, $width, $height, $keepRatio);
+        } catch (\Exception $exception) {
+            return null;
+        }
+    }
+
+    /**
+     * Get the raw image data from an Image.
+     * @param Image $image
+     * @return null|string
+     */
+    public function getImageData(Image $image)
+    {
+        try {
+            return $this->imageService->getImageData($image);
+        } catch (\Exception $exception) {
+            return null;
+        }
+    }
+
+    /**
+     * Check if the provided image type is valid.
+     * @param $type
+     * @return bool
+     */
+    public function isValidType($type)
+    {
+        $validTypes = ['gallery', 'cover', 'system', 'user'];
+        return in_array($type, $validTypes);
+    }
+}

app/Uploads/ImageService.php

@@ -0,0 +1,416 @@
+<?php namespace BookStack\Uploads;
+
+use BookStack\Exceptions\ImageUploadException;
+use BookStack\Uploads\Image;
+use BookStack\Auth\User;
+use BookStack\Uploads\UploadService;
+use DB;
+use Exception;
+use Intervention\Image\Exception\NotSupportedException;
+use Intervention\Image\ImageManager;
+use Illuminate\Contracts\Filesystem\Factory as FileSystem;
+use Illuminate\Contracts\Cache\Repository as Cache;
+use Symfony\Component\HttpFoundation\File\UploadedFile;
+
+class ImageService extends UploadService
+{
+
+    protected $imageTool;
+    protected $cache;
+    protected $storageUrl;
+    protected $image;
+
+    /**
+     * ImageService constructor.
+     * @param Image $image
+     * @param ImageManager $imageTool
+     * @param FileSystem $fileSystem
+     * @param Cache $cache
+     */
+    public function __construct(Image $image, ImageManager $imageTool, FileSystem $fileSystem, Cache $cache)
+    {
+        $this->image = $image;
+        $this->imageTool = $imageTool;
+        $this->cache = $cache;
+        parent::__construct($fileSystem);
+    }
+
+    /**
+     * Get the storage that will be used for storing images.
+     * @param string $type
+     * @return \Illuminate\Contracts\Filesystem\Filesystem
+     */
+    protected function getStorage($type = '')
+    {
+        $storageType = config('filesystems.default');
+
+        // Override default location if set to local public to ensure not visible.
+        if ($type === 'system' && $storageType === 'local_secure') {
+            $storageType = 'local';
+        }
+
+        return $this->fileSystem->disk($storageType);
+    }
+
+    /**
+     * Saves a new image from an upload.
+     * @param UploadedFile $uploadedFile
+     * @param  string $type
+     * @param int $uploadedTo
+     * @return mixed
+     * @throws ImageUploadException
+     */
+    public function saveNewFromUpload(UploadedFile $uploadedFile, $type, $uploadedTo = 0)
+    {
+        $imageName = $uploadedFile->getClientOriginalName();
+        $imageData = file_get_contents($uploadedFile->getRealPath());
+        return $this->saveNew($imageName, $imageData, $type, $uploadedTo);
+    }
+
+    /**
+     * Save a new image from a uri-encoded base64 string of data.
+     * @param string $base64Uri
+     * @param string $name
+     * @param string $type
+     * @param int $uploadedTo
+     * @return Image
+     * @throws ImageUploadException
+     */
+    public function saveNewFromBase64Uri(string $base64Uri, string $name, string $type, $uploadedTo = 0)
+    {
+        $splitData = explode(';base64,', $base64Uri);
+        if (count($splitData) < 2) {
+            throw new ImageUploadException("Invalid base64 image data provided");
+        }
+        $data = base64_decode($splitData[1]);
+        return $this->saveNew($name, $data, $type, $uploadedTo);
+    }
+
+    /**
+     * Gets an image from url and saves it to the database.
+     * @param             $url
+     * @param string      $type
+     * @param bool|string $imageName
+     * @return mixed
+     * @throws \Exception
+     */
+    private function saveNewFromUrl($url, $type, $imageName = false)
+    {
+        $imageName = $imageName ? $imageName : basename($url);
+        $imageData = file_get_contents($url);
+        if ($imageData === false) {
+            throw new \Exception(trans('errors.cannot_get_image_from_url', ['url' => $url]));
+        }
+        return $this->saveNew($imageName, $imageData, $type);
+    }
+
+    /**
+     * Saves a new image
+     * @param string $imageName
+     * @param string $imageData
+     * @param string $type
+     * @param int $uploadedTo
+     * @return Image
+     * @throws ImageUploadException
+     */
+    private function saveNew($imageName, $imageData, $type, $uploadedTo = 0)
+    {
+        $storage = $this->getStorage($type);
+        $secureUploads = setting('app-secure-images');
+        $imageName = str_replace(' ', '-', $imageName);
+
+        $imagePath = '/uploads/images/' . $type . '/' . Date('Y-m-M') . '/';
+
+        while ($storage->exists($imagePath . $imageName)) {
+            $imageName = str_random(3) . $imageName;
+        }
+
+        $fullPath = $imagePath . $imageName;
+        if ($secureUploads) {
+            $fullPath = $imagePath . str_random(16) . '-' . $imageName;
+        }
+
+        try {
+            $storage->put($fullPath, $imageData);
+            $storage->setVisibility($fullPath, 'public');
+        } catch (Exception $e) {
+            throw new ImageUploadException(trans('errors.path_not_writable', ['filePath' => $fullPath]));
+        }
+
+        $imageDetails = [
+            'name'       => $imageName,
+            'path'       => $fullPath,
+            'url'        => $this->getPublicUrl($fullPath),
+            'type'       => $type,
+            'uploaded_to' => $uploadedTo
+        ];
+
+        if (user()->id !== 0) {
+            $userId = user()->id;
+            $imageDetails['created_by'] = $userId;
+            $imageDetails['updated_by'] = $userId;
+        }
+
+        $image = $this->image->newInstance();
+        $image->forceFill($imageDetails)->save();
+        return $image;
+    }
+
+
+    /**
+     * Checks if the image is a gif. Returns true if it is, else false.
+     * @param Image $image
+     * @return boolean
+     */
+    protected function isGif(Image $image)
+    {
+        return strtolower(pathinfo($image->path, PATHINFO_EXTENSION)) === 'gif';
+    }
+
+    /**
+     * Get the thumbnail for an image.
+     * If $keepRatio is true only the width will be used.
+     * Checks the cache then storage to avoid creating / accessing the filesystem on every check.
+     * @param Image $image
+     * @param int $width
+     * @param int $height
+     * @param bool $keepRatio
+     * @return string
+     * @throws Exception
+     * @throws ImageUploadException
+     */
+    public function getThumbnail(Image $image, $width = 220, $height = 220, $keepRatio = false)
+    {
+        if ($keepRatio && $this->isGif($image)) {
+            return $this->getPublicUrl($image->path);
+        }
+
+        $thumbDirName = '/' . ($keepRatio ? 'scaled-' : 'thumbs-') . $width . '-' . $height . '/';
+        $imagePath = $image->path;
+        $thumbFilePath = dirname($imagePath) . $thumbDirName . basename($imagePath);
+
+        if ($this->cache->has('images-' . $image->id . '-' . $thumbFilePath) && $this->cache->get('images-' . $thumbFilePath)) {
+            return $this->getPublicUrl($thumbFilePath);
+        }
+
+        $storage = $this->getStorage($image->type);
+        if ($storage->exists($thumbFilePath)) {
+            return $this->getPublicUrl($thumbFilePath);
+        }
+
+        try {
+            $thumb = $this->imageTool->make($storage->get($imagePath));
+        } catch (Exception $e) {
+            if ($e instanceof \ErrorException || $e instanceof NotSupportedException) {
+                throw new ImageUploadException(trans('errors.cannot_create_thumbs'));
+            }
+            throw $e;
+        }
+
+        if ($keepRatio) {
+            $thumb->resize($width, null, function ($constraint) {
+                $constraint->aspectRatio();
+                $constraint->upsize();
+            });
+        } else {
+            $thumb->fit($width, $height);
+        }
+
+        $thumbData = (string)$thumb->encode();
+        $storage->put($thumbFilePath, $thumbData);
+        $storage->setVisibility($thumbFilePath, 'public');
+        $this->cache->put('images-' . $image->id . '-' . $thumbFilePath, $thumbFilePath, 60 * 72);
+
+        return $this->getPublicUrl($thumbFilePath);
+    }
+
+    /**
+     * Get the raw data content from an image.
+     * @param Image $image
+     * @return string
+     * @throws \Illuminate\Contracts\Filesystem\FileNotFoundException
+     */
+    public function getImageData(Image $image)
+    {
+        $imagePath = $image->path;
+        $storage = $this->getStorage();
+        return $storage->get($imagePath);
+    }
+
+    /**
+     * Destroy an image along with its revisions, thumbnails and remaining folders.
+     * @param Image $image
+     * @throws Exception
+     */
+    public function destroy(Image $image)
+    {
+        $this->destroyImagesFromPath($image->path);
+        $image->delete();
+    }
+
+    /**
+     * Destroys an image at the given path.
+     * Searches for image thumbnails in addition to main provided path..
+     * @param string $path
+     * @return bool
+     */
+    protected function destroyImagesFromPath(string $path)
+    {
+        $storage = $this->getStorage();
+
+        $imageFolder = dirname($path);
+        $imageFileName = basename($path);
+        $allImages = collect($storage->allFiles($imageFolder));
+
+        // Delete image files
+        $imagesToDelete = $allImages->filter(function ($imagePath) use ($imageFileName) {
+            $expectedIndex = strlen($imagePath) - strlen($imageFileName);
+            return strpos($imagePath, $imageFileName) === $expectedIndex;
+        });
+        $storage->delete($imagesToDelete->all());
+
+        // Cleanup of empty folders
+        $foldersInvolved = array_merge([$imageFolder], $storage->directories($imageFolder));
+        foreach ($foldersInvolved as $directory) {
+            if ($this->isFolderEmpty($directory)) {
+                $storage->deleteDirectory($directory);
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * Save a gravatar image and set a the profile image for a user.
+     * @param \BookStack\Auth\User $user
+     * @param int $size
+     * @return mixed
+     * @throws Exception
+     */
+    public function saveUserGravatar(User $user, $size = 500)
+    {
+        $emailHash = md5(strtolower(trim($user->email)));
+        $url = 'https://www.gravatar.com/avatar/' . $emailHash . '?s=' . $size . '&d=identicon';
+        $imageName = str_replace(' ', '-', $user->name . '-gravatar.png');
+        $image = $this->saveNewFromUrl($url, 'user', $imageName);
+        $image->created_by = $user->id;
+        $image->updated_by = $user->id;
+        $image->save();
+        return $image;
+    }
+
+
+    /**
+     * Delete gallery and drawings that are not within HTML content of pages or page revisions.
+     * Checks based off of only the image name.
+     * Could be much improved to be more specific but kept it generic for now to be safe.
+     *
+     * Returns the path of the images that would be/have been deleted.
+     * @param bool $checkRevisions
+     * @param bool $dryRun
+     * @param array $types
+     * @return array
+     */
+    public function deleteUnusedImages($checkRevisions = true, $dryRun = true, $types = ['gallery', 'drawio'])
+    {
+        $types = array_intersect($types, ['gallery', 'drawio']);
+        $deletedPaths = [];
+
+        $this->image->newQuery()->whereIn('type', $types)
+            ->chunk(1000, function ($images) use ($types, $checkRevisions, &$deletedPaths, $dryRun) {
+                foreach ($images as $image) {
+                    $searchQuery = '%' . basename($image->path) . '%';
+                    $inPage = DB::table('pages')
+                         ->where('html', 'like', $searchQuery)->count() > 0;
+                    $inRevision = false;
+                    if ($checkRevisions) {
+                        $inRevision =  DB::table('page_revisions')
+                             ->where('html', 'like', $searchQuery)->count() > 0;
+                    }
+
+                    if (!$inPage && !$inRevision) {
+                        $deletedPaths[] = $image->path;
+                        if (!$dryRun) {
+                            $this->destroy($image);
+                        }
+                    }
+                }
+            });
+        return $deletedPaths;
+    }
+
+    /**
+     * Convert a image URI to a Base64 encoded string.
+     * Attempts to find locally via set storage method first.
+     * @param string $uri
+     * @return null|string
+     * @throws \Illuminate\Contracts\Filesystem\FileNotFoundException
+     */
+    public function imageUriToBase64(string $uri)
+    {
+        $isLocal = strpos(trim($uri), 'http') !== 0;
+
+        // Attempt to find local files even if url not absolute
+        $base = baseUrl('/');
+        if (!$isLocal && strpos($uri, $base) === 0) {
+            $isLocal = true;
+            $uri = str_replace($base, '', $uri);
+        }
+
+        $imageData = null;
+
+        if ($isLocal) {
+            $uri = trim($uri, '/');
+            $storage = $this->getStorage();
+            if ($storage->exists($uri)) {
+                $imageData = $storage->get($uri);
+            }
+        } else {
+            try {
+                $ch = curl_init();
+                curl_setopt_array($ch, [CURLOPT_URL => $uri, CURLOPT_RETURNTRANSFER => 1, CURLOPT_CONNECTTIMEOUT => 5]);
+                $imageData = curl_exec($ch);
+                $err = curl_error($ch);
+                curl_close($ch);
+                if ($err) {
+                    throw new \Exception("Image fetch failed, Received error: " . $err);
+                }
+            } catch (\Exception $e) {
+            }
+        }
+
+        if ($imageData === null) {
+            return null;
+        }
+
+        return 'data:image/' . pathinfo($uri, PATHINFO_EXTENSION) . ';base64,' . base64_encode($imageData);
+    }
+
+    /**
+     * Gets a public facing url for an image by checking relevant environment variables.
+     * @param string $filePath
+     * @return string
+     */
+    private function getPublicUrl($filePath)
+    {
+        if ($this->storageUrl === null) {
+            $storageUrl = config('filesystems.url');
+
+            // Get the standard public s3 url if s3 is set as storage type
+            // Uses the nice, short URL if bucket name has no periods in otherwise the longer
+            // region-based url will be used to prevent http issues.
+            if ($storageUrl == false && config('filesystems.default') === 's3') {
+                $storageDetails = config('filesystems.disks.s3');
+                if (strpos($storageDetails['bucket'], '.') === false) {
+                    $storageUrl = 'https://' . $storageDetails['bucket'] . '.s3.amazonaws.com';
+                } else {
+                    $storageUrl = 'https://s3-' . $storageDetails['region'] . '.amazonaws.com/' . $storageDetails['bucket'];
+                }
+            }
+            $this->storageUrl = $storageUrl;
+        }
+
+        $basePath = ($this->storageUrl == false) ? baseUrl('/') : $this->storageUrl;
+        return rtrim($basePath, '/') . $filePath;
+    }
+}

app/Uploads/UploadService.php

@@ -0,0 +1,45 @@
+<?php namespace BookStack\Uploads;
+
+use Illuminate\Contracts\Filesystem\Factory as FileSystem;
+use Illuminate\Contracts\Filesystem\Filesystem as FileSystemInstance;
+
+abstract class UploadService
+{
+
+    /**
+     * @var FileSystem
+     */
+    protected $fileSystem;
+
+
+    /**
+     * FileService constructor.
+     * @param $fileSystem
+     */
+    public function __construct(FileSystem $fileSystem)
+    {
+        $this->fileSystem = $fileSystem;
+    }
+
+    /**
+     * Get the storage that will be used for storing images.
+     * @return FileSystemInstance
+     */
+    protected function getStorage()
+    {
+        $storageType = config('filesystems.default');
+        return $this->fileSystem->disk($storageType);
+    }
+
+    /**
+     * Check whether or not a folder is empty.
+     * @param $path
+     * @return bool
+     */
+    protected function isFolderEmpty($path)
+    {
+        $files = $this->getStorage()->files($path);
+        $folders = $this->getStorage()->directories($path);
+        return (count($files) === 0 && count($folders) === 0);
+    }
+}