file-pond

recca0120 · Apr 29, 2023 · b3743b8 · b3743b8
1 parent 42f69c6
commit b3743b8
Show file tree

Hide file tree

Showing 13 changed files with 143 additions and 36 deletions.
diff --git a/docs/demo/composer.json b/docs/demo/composer.json
@@ -2,4 +2,8 @@
     "require": {
         "recca0120/upload": "dev-master"
     }
+    ,
+    "require-dev": {
+        "roave/security-advisories": "dev-latest"
+    }
 }
diff --git a/docs/demo/upload.php b/docs/demo/upload.php
@@ -2,11 +2,16 @@
 
 use Recca0120\Upload\Dropzone;
 use Recca0120\Upload\FileAPI;
+use Recca0120\Upload\FilePond;
 use Recca0120\Upload\FineUploader;
 use Recca0120\Upload\Plupload;
 use Recca0120\Upload\Receiver;
 
-include __DIR__.'/vendor/autoload.php';
+if (file_exists(__DIR__.'/../../vendor/autoload.php')) {
+    include __DIR__.'/../../vendor/autoload.php';
+} else {
+    include __DIR__.'/vendor/autoload.php';
+}
 
 $config = [
     'chunks' => 'temp/chunks',
@@ -32,23 +37,7 @@
         break;
 
     case 'file-pond':
-        if (! empty($_POST['file'])) {
-            echo '12345.png';
-//            var_dump($_SERVER['HTTP_UPLOAD_LENGTH']);
-            exit;
-        }
-        if ($_GET['patch']) {
-            var_dump($_SERVER['HTTP_UPLOAD_NAME']);
-            var_dump($_SERVER['HTTP_UPLOAD_LENGTH']);
-            var_dump($_SERVER['HTTP_UPLOAD_OFFSET']);
-            var_dump($_SERVER['HTTP_CONTENT_TYPE']);
-            $mode = $_SERVER['HTTP_UPLOAD_OFFSET'] === '0' ? 'wb+' : 'ab+';
-            $fp = fopen(__DIR__.'/test.png', $mode);
-            fseek($fp, $_SERVER['HTTP_UPLOAD_OFFSET']);
-            fwrite($fp, file_get_contents('php://input'));
-            fclose($fp);
-        }
-        exit;
+        $receiver = new Receiver(new FilePond($config));
         break;
 
     default:

diff --git a/src/Api.php b/src/Api.php
@@ -22,13 +22,6 @@ abstract class Api implements ApiContract
      */
     protected $files;
 
-    /**
-     * $chunkFile.
-     *
-     * @var ChunkFileFactory
-     */
-    protected $ChunkFileFactory;
-
     /**
      * $config.
      *

diff --git a/src/ChunkFile.php b/src/ChunkFile.php
@@ -70,8 +70,7 @@ public function __construct(
      */
     public function appendStream($source, int $offset = 0): ChunkFile
     {
-        $chunkFile = $this->chunkFile();
-        $this->files->appendStream($chunkFile, $source, $offset);
+        $this->files->appendStream($this->chunkFile(), $source, $offset);
 
         return $this;
     }
@@ -86,8 +85,7 @@ public function appendStream($source, int $offset = 0): ChunkFile
      */
     public function appendFile($source, int $index = 0): ChunkFile
     {
-        $chunkFile = $this->chunkFile().'.'.$index;
-        $this->files->appendStream($chunkFile, $source, 0);
+        $this->files->appendStream($this->chunkFile().'.'.$index, $source);
 
         return $this;
     }

diff --git a/src/FilePond.php b/src/FilePond.php
@@ -2,13 +2,46 @@
 
 namespace Recca0120\Upload;
 
+use Illuminate\Contracts\Filesystem\FileNotFoundException;
+use Recca0120\Upload\Exceptions\ChunkedResponseException;
+use Recca0120\Upload\Exceptions\ResourceOpenException;
+
 class FilePond extends Api
 {
+    /**
+     * @throws ResourceOpenException
+     * @throws FileNotFoundException
+     */
     public function receive(string $name)
     {
         $uploadedFile = $this->request->file($name);
         if (! empty($uploadedFile)) {
             return $uploadedFile;
         }
+
+        if (! $this->request->headers->has('Upload-Name')) {
+            throw new ChunkedResponseException(md5(uniqid('file-pond-', true)));
+        }
+
+        $originalName = $this->request->header('Upload-Name');
+        $uuid = $this->request->get('patch');
+        $offset = (int) $this->request->header('Upload-Offset');
+
+        $chunkFile = $this->createChunkFile($originalName, $uuid);
+        $chunkFile->appendStream($this->request->getContent(true), $offset);
+
+        if (! $this->completed($offset)) {
+            throw new ChunkedResponseException();
+        }
+
+        return $chunkFile->createUploadedFile();
+    }
+
+    private function completed(int $offset): bool
+    {
+        $size = (int) $this->request->header('Upload-Length');
+        $length = (int) $this->request->header('Content-Length');
+
+        return $size === $offset + $length;
     }
 }
diff --git a/src/FineUploader.php b/src/FineUploader.php
@@ -30,7 +30,8 @@ public function receive(string $name)
 
         if ($completed === false) {
             $chunkFile->appendFile($file->getRealPath(), $partindex);
-            throw new ChunkedResponseException(['success' => true, 'uuid' => $uuid], []);
+
+            throw new ChunkedResponseException(['success' => true, 'uuid' => $uuid]);
         }
 
         return $chunkFile->createUploadedFile($totalparts);

diff --git a/src/Receiver.php b/src/Receiver.php
@@ -45,6 +45,7 @@ public static function factory(array $config = [], string $class = FileAPI::clas
             'fileapi' => FileAPI::class,
             'fineuploader' => FineUploader::class,
             'plupload' => Plupload::class,
+            'filepond' => FilePond::class,
         ];
 
         $class = Arr::get($lookup, strtolower($class), $class);

diff --git a/src/UploadManager.php b/src/UploadManager.php
@@ -49,4 +49,9 @@ protected function createPluploadDriver(): Receiver
     {
         return new Receiver(new Plupload($this->container['config']['upload'], $this->request, $this->files));
     }
+
+    protected function createFilePond(): Receiver
+    {
+        return new Receiver(new FilePond($this->container['config']['upload'], $this->request, $this->files));
+    }
 }
diff --git a/src/UploadServiceProvider.php b/src/UploadServiceProvider.php
@@ -32,7 +32,7 @@ public function register()
     /**
      * handle publishes.
      */
-    protected function handlePublishes()
+    protected function handlePublishes(): void
     {
         $this->publishes([
             __DIR__.'/../config/upload.php' => config_path('upload.php'),

diff --git a/tests/FileAPITest.php b/tests/FileAPITest.php
@@ -53,6 +53,10 @@ public function testReceiveChunkedFile(): void
         self::assertEquals('{}', $response->getContent());
     }
 
+    /**
+     * @throws FileNotFoundException
+     * @throws ResourceOpenException
+     */
     public function testReceiveChunkedFileWithoutContentRange(): void
     {
         $this->request->headers->replace([

diff --git a/tests/FilePondTest.php b/tests/FilePondTest.php
@@ -2,7 +2,12 @@
 
 namespace Recca0120\Upload\Tests;
 
+use Illuminate\Contracts\Filesystem\FileNotFoundException;
+use Recca0120\Upload\Exceptions\ChunkedResponseException;
+use Recca0120\Upload\Exceptions\ResourceOpenException;
 use Recca0120\Upload\FilePond;
+use ReflectionClass;
+use ReflectionException;
 
 class FilePondTest extends TestCase
 {
@@ -11,10 +16,82 @@ protected function setUp(): void
         parent::setUp();
 
         $this->api = new FilePond($this->config, $this->request, $this->files);
+        $this->request->files->remove('foo');
     }
 
     public function testReceiveSingleFile(): void
     {
+        $this->request->files->replace(['foo' => $this->uploadedFile]);
+
         $this->assertSame($this->uploadedFile, $this->api->receive('foo'));
     }
+
+    public function testReceiveChunkedFileAndThrowUniqIdChunkedResponseException(): void
+    {
+        $this->expectException(ChunkedResponseException::class);
+        $this->expectExceptionMessageMatches('/\w+/');
+
+        $this->request->replace(['file' => '{}']);
+        $this->request->headers->replace(['Upload-Length' => $this->uploadedFile->getSize()]);
+        $this->api->receive('foo');
+    }
+
+    /**
+     * @throws ReflectionException
+     * @throws ResourceOpenException
+     * @throws FileNotFoundException
+     */
+    public function testReceiveChunkedFile(): void
+    {
+        $this->request->setMethod('patch');
+        $this->request->replace(['patch' => $this->uuid]);
+        $content = $this->uploadedFile->getContent();
+
+        $size = $this->uploadedFile->getSize();
+        $name = $this->uploadedFile->getClientOriginalName();
+
+        $length = 10;
+        $loop = 2;
+        $offset = 0;
+        for ($i = 0; $i < $loop; $i++) {
+            $offset = $i * $length;
+            $this->setProperty(substr($content, $offset, $length));
+            $this->request->headers->replace([
+                'Upload-Length' => $size,
+                'Upload-Name' => $name,
+                'Upload-Offset' => $offset,
+                'Content-Length' => $length,
+            ]);
+
+            try {
+                $this->api->receive('foo');
+            } catch (ChunkedResponseException $e) {
+
+            }
+        }
+
+        $offset *= $loop;
+        $this->setProperty(substr($content, $offset));
+        $this->request->headers->replace([
+            'Upload-Length' => $size,
+            'Upload-Name' => $name,
+            'Upload-Offset' => $offset,
+            'Content-Length' => $size - $offset,
+        ]);
+
+        $uploadedFile = $this->api->receive('foo');
+        self::assertTrue($uploadedFile->isValid());
+        self::assertEquals($size, $uploadedFile->getSize());
+    }
+
+    /**
+     * @throws ReflectionException
+     */
+    private function setProperty($value): void
+    {
+        $reflectedClass = new ReflectionClass($this->request);
+        $reflection = $reflectedClass->getProperty('content');
+        $reflection->setAccessible(true);
+        $reflection->setValue($this->request, $value);
+    }
 }
diff --git a/tests/FineUploaderTest.php b/tests/FineUploaderTest.php
@@ -17,6 +17,10 @@ protected function setUp(): void
         $this->api = new FineUploader($this->config, $this->request, $this->files);
     }
 
+    /**
+     * @throws FileNotFoundException
+     * @throws ResourceOpenException
+     */
     public function testReceiveSingleFile(): void
     {
         $this->assertSame($this->uploadedFile, $this->api->receive('foo'));

diff --git a/tests/ReceiverTest.php b/tests/ReceiverTest.php
@@ -76,12 +76,10 @@ public function testReceiveAndThrowChunkedResponseException(): void
         $receiver = new Receiver($api = m::mock(Api::class));
         $inputName = 'foo';
         $api->allows('receive')->once()->with($inputName)->andThrow(new ChunkedResponseException());
+        $callback = function () {
+        };
 
-        $this->assertInstanceOf(
-            Response::class,
-            $receiver->receive($inputName, function () {
-            })
-        );
+        $this->assertInstanceOf(Response::class, $receiver->receive($inputName, $callback));
     }
 
     public function testFactory(): void