1
0
mirror of https://github.com/BookStackApp/BookStack.git synced 2024-10-30 23:52:40 +01:00
BookStack/app/Uploads/AttachmentService.php

235 lines
7.2 KiB
PHP
Raw Normal View History

2021-06-26 17:23:15 +02:00
<?php
namespace BookStack\Uploads;
2016-11-12 15:12:26 +01:00
use BookStack\Exceptions\FileUploadException;
use Exception;
use Illuminate\Contracts\Filesystem\Factory as FileSystem;
use Illuminate\Contracts\Filesystem\FileNotFoundException;
use Illuminate\Contracts\Filesystem\Filesystem as FileSystemInstance;
use Illuminate\Support\Facades\Log;
2021-09-26 16:48:22 +02:00
use Illuminate\Support\Str;
use League\Flysystem\Util;
2016-11-12 15:12:26 +01:00
use Symfony\Component\HttpFoundation\File\UploadedFile;
class AttachmentService
2016-11-12 15:12:26 +01:00
{
protected $fileSystem;
/**
* AttachmentService constructor.
*/
public function __construct(FileSystem $fileSystem)
{
$this->fileSystem = $fileSystem;
}
/**
* Get the storage that will be used for storing files.
*/
protected function getStorage(): FileSystemInstance
{
return $this->fileSystem->disk($this->getStorageDiskName());
}
/**
* Get the name of the storage disk to use.
*/
protected function getStorageDiskName(): string
{
$storageType = config('filesystems.attachments');
// Change to our secure-attachment disk if any of the local options
// are used to prevent escaping that location.
if ($storageType === 'local' || $storageType === 'local_secure') {
$storageType = 'local_secure_attachments';
}
return $storageType;
}
/**
* Change the originally provided path to fit any disk-specific requirements.
* This also ensures the path is kept to the expected root folders.
*/
protected function adjustPathForStorageDisk(string $path): string
{
$path = Util::normalizePath(str_replace('uploads/files/', '', $path));
if ($this->getStorageDiskName() === 'local_secure_attachments') {
return $path;
}
return 'uploads/files/' . $path;
}
2016-11-12 15:12:26 +01:00
/**
* Get an attachment from storage.
2021-06-26 17:23:15 +02:00
*
* @throws FileNotFoundException
2016-11-12 15:12:26 +01:00
*/
public function getAttachmentFromStorage(Attachment $attachment): string
2016-11-12 15:12:26 +01:00
{
return $this->getStorage()->get($this->adjustPathForStorageDisk($attachment->path));
2016-11-12 15:12:26 +01:00
}
/**
* Store a new attachment upon user upload.
* @throws FileUploadException
*/
public function saveNewUpload(UploadedFile $uploadedFile, int $page_id): Attachment
2016-11-12 15:12:26 +01:00
{
$attachmentName = $uploadedFile->getClientOriginalName();
$attachmentPath = $this->putFileInStorage($uploadedFile);
$largestExistingOrder = Attachment::query()->where('uploaded_to', '=', $page_id)->max('order');
2016-11-12 15:12:26 +01:00
/** @var Attachment $attachment */
$attachment = Attachment::query()->forceCreate([
2021-06-26 17:23:15 +02:00
'name' => $attachmentName,
'path' => $attachmentPath,
'extension' => $uploadedFile->getClientOriginalExtension(),
2016-11-12 15:12:26 +01:00
'uploaded_to' => $page_id,
2021-06-26 17:23:15 +02:00
'created_by' => user()->id,
'updated_by' => user()->id,
'order' => $largestExistingOrder + 1,
2016-11-12 15:12:26 +01:00
]);
return $attachment;
}
/**
* Store an upload, saving to a file and deleting any existing uploads
2016-11-12 15:12:26 +01:00
* attached to that file.
2021-06-26 17:23:15 +02:00
*
2016-11-12 15:12:26 +01:00
* @throws FileUploadException
*/
public function saveUpdatedUpload(UploadedFile $uploadedFile, Attachment $attachment): Attachment
2016-11-12 15:12:26 +01:00
{
if (!$attachment->external) {
$this->deleteFileInStorage($attachment);
}
$attachmentName = $uploadedFile->getClientOriginalName();
$attachmentPath = $this->putFileInStorage($uploadedFile);
2016-11-12 15:12:26 +01:00
$attachment->name = $attachmentName;
$attachment->path = $attachmentPath;
$attachment->external = false;
$attachment->extension = $uploadedFile->getClientOriginalExtension();
$attachment->save();
2021-06-26 17:23:15 +02:00
2016-11-12 15:12:26 +01:00
return $attachment;
}
/**
* Save a new File attachment from a given link and name.
*/
public function saveNewFromLink(string $name, string $link, int $page_id): Attachment
2016-11-12 15:12:26 +01:00
{
$largestExistingOrder = Attachment::where('uploaded_to', '=', $page_id)->max('order');
2021-06-26 17:23:15 +02:00
2016-11-12 15:12:26 +01:00
return Attachment::forceCreate([
2021-06-26 17:23:15 +02:00
'name' => $name,
'path' => $link,
'external' => true,
'extension' => '',
2016-11-12 15:12:26 +01:00
'uploaded_to' => $page_id,
2021-06-26 17:23:15 +02:00
'created_by' => user()->id,
'updated_by' => user()->id,
'order' => $largestExistingOrder + 1,
2016-11-12 15:12:26 +01:00
]);
}
/**
* Updates the ordering for a listing of attached files.
2016-11-12 15:12:26 +01:00
*/
public function updateFileOrderWithinPage(array $attachmentOrder, string $pageId)
2016-11-12 15:12:26 +01:00
{
foreach ($attachmentOrder as $index => $attachmentId) {
Attachment::query()->where('uploaded_to', '=', $pageId)
->where('id', '=', $attachmentId)
->update(['order' => $index]);
2016-11-12 15:12:26 +01:00
}
}
/**
* Update the details of a file.
*/
public function updateFile(Attachment $attachment, array $requestData): Attachment
2016-11-12 15:12:26 +01:00
{
$attachment->name = $requestData['name'];
2016-11-12 15:12:26 +01:00
if (isset($requestData['link']) && trim($requestData['link']) !== '') {
$attachment->path = $requestData['link'];
if (!$attachment->external) {
$this->deleteFileInStorage($attachment);
$attachment->external = true;
}
}
2016-11-12 15:12:26 +01:00
$attachment->save();
2021-06-26 17:23:15 +02:00
2016-11-12 15:12:26 +01:00
return $attachment;
}
/**
* Delete a File from the database and storage.
* @throws Exception
2016-11-12 15:12:26 +01:00
*/
public function deleteFile(Attachment $attachment)
{
if ($attachment->external) {
$attachment->delete();
2021-06-26 17:23:15 +02:00
2016-11-12 15:12:26 +01:00
return;
}
2021-06-26 17:23:15 +02:00
2016-11-12 15:12:26 +01:00
$this->deleteFileInStorage($attachment);
$attachment->delete();
}
/**
* Delete a file from the filesystem it sits on.
* Cleans any empty leftover folders.
*/
protected function deleteFileInStorage(Attachment $attachment)
{
$storage = $this->getStorage();
$dirPath = $this->adjustPathForStorageDisk(dirname($attachment->path));
2016-11-12 15:12:26 +01:00
$storage->delete($this->adjustPathForStorageDisk($attachment->path));
2016-11-12 15:12:26 +01:00
if (count($storage->allFiles($dirPath)) === 0) {
$storage->deleteDirectory($dirPath);
}
}
/**
2021-06-26 17:23:15 +02:00
* Store a file in storage with the given filename.
2016-11-12 15:12:26 +01:00
* @throws FileUploadException
*/
protected function putFileInStorage(UploadedFile $uploadedFile): string
2016-11-12 15:12:26 +01:00
{
$attachmentData = file_get_contents($uploadedFile->getRealPath());
$storage = $this->getStorage();
2021-06-26 17:23:15 +02:00
$basePath = 'uploads/files/' . date('Y-m-M') . '/';
2016-11-12 15:12:26 +01:00
2019-09-14 00:58:40 +02:00
$uploadFileName = Str::random(16) . '.' . $uploadedFile->getClientOriginalExtension();
while ($storage->exists($this->adjustPathForStorageDisk($basePath . $uploadFileName))) {
2019-09-14 00:58:40 +02:00
$uploadFileName = Str::random(3) . $uploadFileName;
2016-11-12 15:12:26 +01:00
}
$attachmentPath = $basePath . $uploadFileName;
2021-06-26 17:23:15 +02:00
2016-11-12 15:12:26 +01:00
try {
$storage->put($this->adjustPathForStorageDisk($attachmentPath), $attachmentData);
2016-11-12 15:12:26 +01:00
} catch (Exception $e) {
Log::error('Error when attempting file upload:' . $e->getMessage());
2021-06-26 17:23:15 +02:00
throw new FileUploadException(trans('errors.path_not_writable', ['filePath' => $attachmentPath]));
2016-11-12 15:12:26 +01:00
}
2016-11-12 15:12:26 +01:00
return $attachmentPath;
}
}