added routes for zip export

[bookstack] / app / Uploads / AttachmentService.php

diff --git a/app/Uploads/AttachmentService.php b/app/Uploads/AttachmentService.php
index b14f49473709647e23fd03afeea406d39c752361..dabd537292f4823eb7a93faada344f59cc2b2a93 100644 (file)
--- a/app/Uploads/AttachmentService.php
+++ b/app/Uploads/AttachmentService.php
@@ -1,87 +1,68 @@
-<?php namespace BookStack\Uploads;
+<?php
+
+namespace BookStack\Uploads;

 
 use BookStack\Exceptions\FileUploadException;
 use Exception;
 
 use BookStack\Exceptions\FileUploadException;
 use Exception;

-use Illuminate\Contracts\Filesystem\Factory as FileSystem;
-use Illuminate\Contracts\Filesystem\Filesystem as FileSystemInstance;
-use Illuminate\Support\Str;

 use Symfony\Component\HttpFoundation\File\UploadedFile;
 
 class AttachmentService
 {
 use Symfony\Component\HttpFoundation\File\UploadedFile;
 
 class AttachmentService
 {

-
-    protected $fileSystem;
-
-    /**
-     * AttachmentService constructor.
-     */
-    public function __construct(FileSystem $fileSystem)
-    {
-        $this->fileSystem = $fileSystem;
+    public function __construct(
+        protected FileStorage $storage,
+    ) {

     }
 
     }
 

-

     /**
     /**

-     * Get the storage that will be used for storing files.
+     * Stream an attachment from storage.
+     *
+     * @return resource|null

      */
      */

-    protected function getStorage(): FileSystemInstance
+    public function streamAttachmentFromStorage(Attachment $attachment)

     {
     {

-        $storageType = config('filesystems.attachments');
-
-        // Override default location if set to local public to ensure not visible.
-        if ($storageType === 'local') {
-            $storageType = 'local_secure';
-        }
-
-        return $this->fileSystem->disk($storageType);
+        return $this->storage->getReadStream($attachment->path);

     }
 
     /**
     }
 
     /**

-     * Get an attachment from storage.
-     * @param Attachment $attachment
-     * @return string
-     * @throws \Illuminate\Contracts\Filesystem\FileNotFoundException
+     * Read the file size of an attachment from storage, in bytes.

      */
      */

-    public function getAttachmentFromStorage(Attachment $attachment)
+    public function getAttachmentFileSize(Attachment $attachment): int

     {
     {

-        return $this->getStorage()->get($attachment->path);
+        return $this->storage->getSize($attachment->path);

     }
 
     /**
      * Store a new attachment upon user upload.
     }
 
     /**
      * Store a new attachment upon user upload.

-     * @param UploadedFile $uploadedFile
-     * @param int $page_id
-     * @return Attachment
+     *

      * @throws FileUploadException
      */
      * @throws FileUploadException
      */

-    public function saveNewUpload(UploadedFile $uploadedFile, $page_id)
+    public function saveNewUpload(UploadedFile $uploadedFile, int $pageId): Attachment

     {
         $attachmentName = $uploadedFile->getClientOriginalName();
         $attachmentPath = $this->putFileInStorage($uploadedFile);
     {
         $attachmentName = $uploadedFile->getClientOriginalName();
         $attachmentPath = $this->putFileInStorage($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
+        $largestExistingOrder = Attachment::query()->where('uploaded_to', '=', $pageId)->max('order');
+
+        /** @var Attachment $attachment */
+        $attachment = Attachment::query()->forceCreate([
+            'name'        => $attachmentName,
+            'path'        => $attachmentPath,
+            'extension'   => $uploadedFile->getClientOriginalExtension(),
+            'uploaded_to' => $pageId,
+            'created_by'  => user()->id,
+            'updated_by'  => user()->id,
+            'order'       => $largestExistingOrder + 1,

         ]);
 
         return $attachment;
     }
 
     /**
         ]);
 
         return $attachment;
     }
 
     /**

-     * Store a upload, saving to a file and deleting any existing uploads
+     * Store an upload, saving to a file and deleting any existing uploads

      * attached to that file.
      * attached to that file.

-     * @param UploadedFile $uploadedFile
-     * @param Attachment $attachment
-     * @return Attachment
+     *

      * @throws FileUploadException
      */
      * @throws FileUploadException
      */

-    public function saveUpdatedUpload(UploadedFile $uploadedFile, Attachment $attachment)
+    public function saveUpdatedUpload(UploadedFile $uploadedFile, Attachment $attachment): Attachment

     {
         if (!$attachment->external) {
             $this->deleteFileInStorage($attachment);
     {
         if (!$attachment->external) {
             $this->deleteFileInStorage($attachment);


@@ -95,6 +76,7 @@ class AttachmentService
         $attachment->external = false;
         $attachment->extension = $uploadedFile->getClientOriginalExtension();
         $attachment->save();
         $attachment->external = false;
         $attachment->extension = $uploadedFile->getClientOriginalExtension();
         $attachment->save();

+

         return $attachment;
     }
 
         return $attachment;
     }
 


@@ -104,15 +86,16 @@ class AttachmentService
     public function saveNewFromLink(string $name, string $link, int $page_id): Attachment
     {
         $largestExistingOrder = Attachment::where('uploaded_to', '=', $page_id)->max('order');
     public function saveNewFromLink(string $name, string $link, int $page_id): Attachment
     {
         $largestExistingOrder = Attachment::where('uploaded_to', '=', $page_id)->max('order');

+

         return Attachment::forceCreate([
         return Attachment::forceCreate([

-            'name' => $name,
-            'path' => $link,
-            'external' => true,
-            'extension' => '',
+            'name'        => $name,
+            'path'        => $link,
+            'external'    => true,
+            'extension'   => '',

             'uploaded_to' => $page_id,
             'uploaded_to' => $page_id,

-            'created_by' => user()->id,
-            'updated_by' => user()->id,
-            'order' => $largestExistingOrder + 1
+            'created_by'  => user()->id,
+            'updated_by'  => user()->id,
+            'order'       => $largestExistingOrder + 1,

         ]);
     }
 
         ]);
     }
 


@@ -128,83 +111,75 @@ class AttachmentService
         }
     }
 
         }
     }
 

-

     /**
      * Update the details of a file.
      */
     public function updateFile(Attachment $attachment, array $requestData): Attachment
     {
     /**
      * Update the details of a file.
      */
     public function updateFile(Attachment $attachment, array $requestData): Attachment
     {

-        $attachment->name = $requestData['name'];
+        if (isset($requestData['name'])) {
+            $attachment->name = $requestData['name'];
+        }

 
 

-        if (isset($requestData['link']) && trim($requestData['link']) !== '') {
-            $attachment->path = $requestData['link'];
+        $link = trim($requestData['link'] ?? '');
+        if (!empty($link)) {

             if (!$attachment->external) {
                 $this->deleteFileInStorage($attachment);
                 $attachment->external = true;
             if (!$attachment->external) {
                 $this->deleteFileInStorage($attachment);
                 $attachment->external = true;

+                $attachment->extension = '';

             }
             }

+            $attachment->path = $link;

         }
 
         $attachment->save();
         }
 
         $attachment->save();

-        return $attachment;
+
+        return $attachment->refresh();

     }
 
     /**
      * Delete a File from the database and storage.
     }
 
     /**
      * Delete a File from the database and storage.

-     * @param Attachment $attachment
+     *

      * @throws Exception
      */
     public function deleteFile(Attachment $attachment)
     {
      * @throws Exception
      */
     public function deleteFile(Attachment $attachment)
     {

-        if ($attachment->external) {
-            $attachment->delete();
-            return;
+        if (!$attachment->external) {
+            $this->deleteFileInStorage($attachment);

         }
         }

-        
-        $this->deleteFileInStorage($attachment);
+

         $attachment->delete();
     }
 
     /**
      * Delete a file from the filesystem it sits on.
      * Cleans any empty leftover folders.
         $attachment->delete();
     }
 
     /**
      * Delete a file from the filesystem it sits on.
      * Cleans any empty leftover folders.

-     * @param Attachment $attachment

      */
      */

-    protected function deleteFileInStorage(Attachment $attachment)
+    public function deleteFileInStorage(Attachment $attachment): void

     {
     {

-        $storage = $this->getStorage();
-        $dirPath = dirname($attachment->path);
-
-        $storage->delete($attachment->path);
-        if (count($storage->allFiles($dirPath)) === 0) {
-            $storage->deleteDirectory($dirPath);
-        }
+        $this->storage->delete($attachment->path);

     }
 
     /**
     }
 
     /**

-     * Store a file in storage with the given filename
-     * @param UploadedFile $uploadedFile
-     * @return string
+     * Store a file in storage with the given filename.
+     *

      * @throws FileUploadException
      */
      * @throws FileUploadException
      */

-    protected function putFileInStorage(UploadedFile $uploadedFile)
+    protected function putFileInStorage(UploadedFile $uploadedFile): string

     {
     {

-        $attachmentData = file_get_contents($uploadedFile->getRealPath());
-
-        $storage = $this->getStorage();
-        $basePath = 'uploads/files/' . Date('Y-m-M') . '/';
-
-        $uploadFileName = Str::random(16) . '.' . $uploadedFile->getClientOriginalExtension();
-        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]));
-        }
+        $basePath = 'uploads/files/' . date('Y-m-M') . '/';
+
+        return $this->storage->uploadFile(
+            $uploadedFile,
+            $basePath,
+            $uploadedFile->getClientOriginalExtension(),
+            ''
+        );
+    }

 
 

-        return $attachmentPath;
+    /**
+     * Get the file validation rules for attachments.
+     */
+    public static function getFileValidationRules(): array
+    {
+        return ['file', 'max:' . (config('app.upload_limit') * 1000)];

     }
 }
     }
 }