initial commit

Author: Martin Kluska

composer.json

@@ -0,0 +1,22 @@
+{
+  "name": "pion/laravel-chunk-upload",
+  "description": "Service for chunked upload with several js providers",
+  "require": {
+    "laravel/framework": "5.*"
+  },
+  "require-dev": {
+  },
+  "autoload": {
+    "psr-4": {
+      "Pion\\Laravel\\ChunkUpload\\": "src/"
+    }
+  },
+  "license": "MIT",
+  "authors": [
+    {
+      "name": "Martin Kluska",
+      "email": "martin.kluska@imakers.cz"
+    }
+  ],
+  "minimum-stability": "stable"
+}

readme.md

@@ -0,0 +1,108 @@
+# Laravel chunked upload
+
+___Project in progress___ 
+
+## Instalation
+
+    composer require pion/laravel-chunk-upload
+    
+## Usage
+
+In your own controller create the `FileReceiver`, more in example
+
+## Supports
+
+* Laravel 5+
+* [blueimp-file-upload](https://github.com/blueimp/jQuery-File-Upload) - partial support (simple chunked and single upload)
+
+## Example
+
+### Javascript
+
+    $element.fileupload({
+            url: "upload_url",
+            maxChunkSize: 1000000,
+            method: "POST",
+            sequentialUploads: true,
+            formData: function(form) {
+                //laravel token for communication
+                return [{name: "_token", value: $form.find("[name=_token]").val()}];
+            },
+            progressall: function(e, data) {
+                var progress = parseInt(data.loaded / data.total * 100, 10);
+                console.log(progress+"%");
+            }
+        })
+            .bind('fileuploadchunksend', function (e, data) {
+                //console.log("fileuploadchunksend");
+            })
+            .bind('fileuploadchunkdone', function (e, data) {
+                //console.log("fileuploadchunkdone");
+            })
+            .bind('fileuploadchunkfail', function (e, data) {
+                console.log("fileuploadchunkfail")
+            });
+            
+### Laravel controller
+Create laravel controller `UploadController` and create the file receiver with the desired handler.
+
+#### Controller
+You must import the full namespace in your controler (`use`).
+
+    /**
+     * Handles the file upload
+     *
+     * @param Request $request
+     *
+     * @return \Illuminate\Http\JsonResponse
+     * 
+     * @throws UploadMissingFileException
+     */
+    public function upload(Request $request) {
+
+        // create the file receiver
+        $receiver = new FileReceiver("file", $request, ContentRangeUploadHandler::class);
+
+        // check if the upload is success
+        if ($receiver->isUploaded()) {
+
+            // receive the file
+            $save = $receiver->receive();
+
+            // check if the upload has finished (in chunk mode it will send smaller files)
+            if ($save->isFinished()) {
+                // save the file and return any response you need
+                return $this->saveFile($save->getFile());
+            } else {
+                // we are in chunk mode, lets send the current progress
+
+                /** @var ContentRangeUploadHandler $handler */
+                $handler = $save->handler();
+                
+                return response()->json([
+                    "start" => $handler->getBytesStart(),
+                    "end" => $handler->getBytesEnd(),
+                    "total" => $handler->getBytesTotal()
+                ]);
+            }
+        } else {
+            throw new UploadMissingFileException();
+        }
+    }
+
+#### Route
+Add a route to your controller
+
+    Route::post('upload', 'UploadController@upload');
+
+## Todo
+
+- [ ] add more providers (like pbupload)
+- [ ] add facade for a quick usage with callback and custom response based on the handler
+- [ ] cron to delete uncompleted files
+- [ ] file per session (to support multiple)
+- [ ] add a config with custom storage location 
+
+## Contribution
+Are welcome. To add a new provider, just add a new Handler (which extends AbstractHandler), implement the chunk
+upload and progress

src/Exceptions/ChunkSaveException.php

@@ -0,0 +1,7 @@
+<?php
+namespace Pion\Laravel\ChunkUpload\Exceptions;
+
+class ChunkSaveException extends \Exception
+{
+
+}

src/Exceptions/UploadMissingFileException.php

@@ -0,0 +1,23 @@
+<?php
+namespace Pion\Laravel\ChunkUpload\Exceptions;
+
+use Exception;
+
+class UploadMissingFileException extends \Exception
+{
+    /**
+     * Construct the exception. Note: The message is NOT binary safe.
+     * @link  http://php.net/manual/en/exception.construct.php
+     *
+     * @param string    $message  [optional] The Exception message to throw.
+     * @param int       $code     [optional] The Exception code.
+     * @param Exception $previous [optional] The previous exception used for the exception chaining. Since 5.3.0
+     *
+     * @since 5.1.0
+     */
+    public function __construct($message = "The request is missing a file", $code = 400, Exception $previous = null)
+    {
+        parent::__construct($message, $code, $previous);
+    }
+
+}

src/Handler/AbstractHandler.php

@@ -0,0 +1,62 @@
+<?php
+namespace Pion\Laravel\ChunkUpload\Handler;
+
+use Illuminate\Http\Request;
+use Symfony\Component\HttpFoundation\File\UploadedFile;
+
+/**
+ * The handler that will detect if we can continue the chunked upload
+ * 
+ * @package Pion\Laravel\ChunkUpload\Handler
+ */
+abstract class AbstractHandler
+{
+    /**
+     * @var Request
+     */
+    protected $request;
+
+    /**
+     * @var UploadedFile
+     */
+    protected $file;
+
+    /**
+     * AbstractReceiver constructor.
+     *
+     * @param Request      $request
+     * @param UploadedFile $file
+     */
+    public function __construct(Request  $request, UploadedFile $file)
+    {
+        $this->request = $request;
+        $this->file = $file;
+    }
+
+    /**
+     * Returns the chunk file name
+     *
+     * @return string
+     */
+    abstract public function getChunkFileName();
+
+    /**
+     * Returns the first chunk
+     * @return bool
+     */
+    abstract public function isFirstChunk();
+
+    /**
+     * Returns the chunks count
+     *
+     * @return int
+     */
+    abstract public function isLastChunk();
+
+    /**
+     * Returns the current chunk index
+     *
+     * @return bool
+     */
+    abstract public function isChunkedUpload();
+}

src/Handler/ContentRangeUploadHandler.php

@@ -0,0 +1,143 @@
+<?php
+namespace Pion\Laravel\ChunkUpload\Handler;
+
+use Illuminate\Http\Request;
+use Symfony\Component\HttpFoundation\File\UploadedFile;
+
+/**
+ * Class JqueryUploadReceiver
+ *
+ * Upload receiver that detects the content range by the the header value.
+ *
+ * @package Pion\Laravel\ChunkUpload\Handler
+ */
+class ContentRangeUploadHandler extends AbstractHandler
+{
+    /**
+     * The index for the header
+     */
+    const CONTENT_RANGE_INDEX = "content-range";
+
+    /**
+     * Determines if the upload is via chunked upload
+     * @var bool
+     */
+    protected $chunkedUpload = false;
+
+    /**
+     * Current chunk start bytes
+     * @var int
+     */
+    protected $bytesStart = 0;
+
+    /**
+     * Current chunk bytes end
+     * @var int
+     */
+    protected $bytesEnd = 0;
+
+    /**
+     * The files total bytes
+     * @var int
+     */
+    protected $bytesTotal = 0;
+
+    /**
+     * AbstractReceiver constructor.
+     *
+     * @param Request      $request
+     * @param UploadedFile $file
+     */
+    public function __construct(Request $request, UploadedFile $file)
+    {
+        parent::__construct($request, $file);
+
+        $contentRange = $this->request->header(self::CONTENT_RANGE_INDEX);
+
+        $this->tryToParseContentRange($contentRange);
+    }
+
+    /**
+     * Tries to parse the content range from the string
+     *
+     * @param string $contentRange
+     */
+    protected function tryToParseContentRange($contentRange)
+    {
+        // try to get the content range
+        if (preg_match("/bytes ([\d]+)-([\d]+)\/([\d]+)/", $contentRange, $matches)) {
+
+            $this->chunkedUpload = true;
+
+            // write the bytes values
+            $this->bytesStart = intval($matches[1]);
+            $this->bytesEnd = intval($matches[2]);
+            $this->bytesTotal = intval($matches[3]);
+        }
+    }
+
+    /**
+     * Returns the first chunk
+     * @return bool
+     */
+    public function isFirstChunk()
+    {
+        return $this->bytesStart == 0;
+    }
+
+    /**
+     * Returns the chunks count
+     *
+     * @return int
+     */
+    public function isLastChunk()
+    {
+        // the bytes starts from zero, remove 1 byte from total
+        return $this->bytesEnd >= ($this->bytesTotal - 1);
+    }
+
+    /**
+     * Returns the current chunk index
+     *
+     * @return bool
+     */
+    public function isChunkedUpload()
+    {
+        return $this->chunkedUpload;
+    }
+
+    /**
+     * @return int
+     */
+    public function getBytesStart()
+    {
+        return $this->bytesStart;
+    }
+
+    /**
+     * @return int
+     */
+    public function getBytesEnd()
+    {
+        return $this->bytesEnd;
+    }
+
+    /**
+     * @return int
+     */
+    public function getBytesTotal()
+    {
+        return $this->bytesTotal;
+    }
+
+    /**
+     * Returns the chunk file name
+     *
+     * @return string
+     */
+    public function getChunkFileName()
+    {
+        return $this->file->getClientOriginalName()."-".$this->bytesTotal.".part";
+    }
+    
+}

src/Providers/ChunkUploadServiceProvider.php

@@ -0,0 +1,18 @@
+<?php
+namespace Pion\Laravel\ChunkUpload\Providers;
+
+use Illuminate\Support\ServiceProvider;
+
+class ChunkUploadServiceProvider extends ServiceProvider
+{
+    /**
+     * Register the service provider.
+     *
+     * @return void
+     */
+    public function register()
+    {
+
+    }
+
+}