php artisan make:migration create_storage_files_table --create=storage_files

<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

class CreateStorageFilesTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('storage_files', function (Blueprint $table) {
            $table->bigIncrements('id');
            $table->string('user_name');
            $table->string('file_status')->nullable();
            $table->string('download_progress')->nullable();
            $table->string('storage_file_name')->nullable();
            $table->string('file_name')->nullable();
            $table->string('file_type');
            $table->string('file_size')->nullable();
            $table->string('file_size_src')->nullable();
            $table->text('fusion_url')->nullable();
            $table->text('download_link')->nullable();
            $table->text('duration')->nullable();
            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('storage_files');
    }
}

php artisan make:model StorageFiles -c

<?php

namespace App;

use DateTimeInterface;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\Storage;

class StorageFiles extends Model
{
    protected $guarded = array();

    /*
     * Before Laravel 7, dates would be serialized to a format like the following :

    2019-12-02 20:01:00
    Dates serialized using the ISO-8601 format will appear like :

    2019-12-02T20:01:00.283041Z
    Please note that ISO-8601 dates are always expressed in UTC.

    If you would like to keep using the previous behavior you can override
    the serializeDate() method on your model :
     * */

    protected function serializeDate(DateTimeInterface $date)
    {
        return $date->format('d.m.Y H:i:s');
    }

    public function getDownloadProgressAttribute()
    {
        return Storage::exists($this->storage_file_name)
            ? Storage::size($this->storage_file_name)
            : $this->attributes['download_progress'];
    }
}

<?php

namespace App\Http\Controllers;

use App\Jobs\DownloadFusionFile;
use App\Services\Fusion;
use App\StorageFiles;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Storage;

class StorageFilesController extends Controller
{
    /**
     * @OA\Get(
     *     path="/storage_files",
     *     tags={"Storage Files"},
     *     summary="Storage files list by username",
     *     operationId="indexStorageFiles",
     *     security={{"cookieAuth": {}}},
     *     @OA\Parameter(
     *     name="username",
     *     in="query",
     *     required=false,
     *     example="Ronald",
     *     ),
     *     @OA\Response(
     *         response=200,
     *         description="Success",
     *         @OA\JsonContent(ref="#/components/schemas/StorageFileResponse"),
     *     )
     * )
     */
    public function index(Request $request)
    {
        //get request params
        $username = $request->get('username');
        if ($username !== null) {
            $items = StorageFiles::
                        where('user_name', $username)
                        ->where('file_status', '<>', 'deleted')
                        ->get();
        }
        else
        {
            $items = StorageFiles::where('file_status', '<>', 'deleted')->get();
        }

        return response()->json($items, 200);
    }

    /**
     * @OA\Get(
     *     path="/storage_files/count",
     *     tags={"Storage Files"},
     *     summary="Storage files count statuses by username",
     *     operationId="storageFilesCount",
     *     security={{"cookieAuth": {}}},
     *     @OA\Parameter(
     *     name="username",
     *     in="query",
     *     required=false,
     *     example="vasya",
     *     ),
     *     @OA\Response(
     *         response=200,
     *         description="Success",
     *         @OA\JsonContent(ref="#/components/schemas/StorageFileResponse"),
     *     )
     * )
     */
    public function items_count(Request $request)
    {
        //get request params
        $username = $request->get('username');
        if ($username !== null) {
            $d_count = StorageFiles::
                where('user_name', $username)
                ->where('file_status', 'downloading')
                ->get()->count();

            $r_count = StorageFiles::
                where('user_name', $username)
                ->where('file_status', 'ready')
                ->get()->count();

            $a_count = StorageFiles::
                where('user_name', $username)
                ->where('file_status', '<>', 'deleted')
                ->get()->count();
        }
        else
        {
            $d_count = StorageFiles::where('file_status', 'downloading')->get()->count();
            $r_count = StorageFiles::where('file_status', 'ready')->get()->count();
            $a_count = StorageFiles::where('file_status', '<>', 'deleted')->get()->count();
        }

        $res = array(
            "d_count" => $d_count,
            "r_count" => $r_count,
            "a_count" => $a_count
        );
        return response()->json($res, 200);
    }

    /**
     * @OA\Get(
     *     path="/storage_files/addFileToQueue",
     *     tags={"Storage Files"},
     *     summary="add file to download queue by file_url",
     *     operationId="addFileToQueue",
     *     security={{"cookieAuth": {}}},
     *     description="Add file to the download queue",
     *     @OA\Parameter(
     *     name="file_url",
     *     in="query",
     *     required=true,
     *     example="http://xxx.xxx.xxx.xxx/yyyyy/download?datasource=TYPENAME&field=FILEDNAME&oid=...&typeOID...&filename=...",
     *     ),
     *     @OA\Parameter(
     *     name="file_type",
     *     in="query",
     *     required=true,
     *     example="RAR Invoice",
     *     ),
     *     @OA\Parameter(
     *     name="file_extension",
     *     in="query",
     *     required=true,
     *     example="rar",
     *     ),
     *     @OA\Parameter(
     *     name="file_size_src",
     *     in="query",
     *     required=false,
     *     example="5678943",
     *     ),
     *     @OA\Response(
     *         response=200,
     *         description="Success",
     *         @OA\JsonContent(ref="#/components/schemas/InvoiceBinaryPDFFileResponse"),
     *     )
     * )
     */

    public function addFileToQueue(Request $request, Fusion $api)
    {
        //get request params
        $file_url = $request->get('file_url');
        $file_type = $request->get('file_type');
        $file_extension = $request->get('file_extension');
        $file_size_src = $request->get('file_size_src');
        $cookies = $request->get('cookies');

        if (empty($file_size_src)) {
            $file_size_src = '';
        }

        if (!empty($cookies)) {
            $api->setCookies($cookies);
        }

        $sf = StorageFiles::
            where('fusion_url', $file_url)->
            where('user_name', $api->cookieAr['currentUser'])->
            first();

        if ($sf === null) {
            DownloadFusionFile::dispatch($file_url, $api->cookieAr, $file_type, $file_extension, $file_size_src);
            return response()->json(array('success' => 'y'), 200);
        } else {
            $err = array(
                "code" => 'file_already_exist',
                "name" => 'Файл уже скачивается или был скачан'
            );

            return response()->json($err, 400);
        }
    }

    /**
     * @OA\Get(
     *     path="/storage_files/download",
     *     tags={"Storage Files"},
     *     summary="download Storage File by name",
     *     operationId="downloadStorageFile",
     *     security={{"cookieAuth": {}}},
     *     @OA\Parameter(
     *     name="filename",
     *     in="query",
     *     required=true,
     *     example="file_12345.rar",
     *     ),
     *     @OA\Parameter(
     *     name="deleteAfterDownload",
     *     in="query",
     *     required=true,
     *     example="true",
     *     ),
     *     @OA\Response(
     *         response=200,
     *         description="Success",
     *         @OA\JsonContent(ref="#/components/schemas/StorageFileResponse"),
     *     )
     * )
     */
    public function download(Request $request)
    {

        //get request params
        $filename = $request->get('filename');
        $deleteAfterDownload = $request->get('deleteAfterDownload');

        if ($filename !==null) {
            $sf = StorageFiles::where('storage_file_name', $filename)->first();
            if ($sf !== null && Storage::exists($filename)) {
                switch ($deleteAfterDownload) {
                    case 'true':
                        $sf->file_status = 'deleted';
                        $sf->update();
                        return response()->download($sf->download_link, $sf->file_name)->deleteFileAfterSend(true);
                    case 'false':
                        return Storage::download($filename, $sf->file_name);
                }
            }
            else
            {
                $err = array(
                    "code" => 'file ' . $filename . ' doesnt exist',
                    "name" => 'File doesnt exist'
                );

                return response()->json($err, 400);
            }
        }
        else
        {
            $err = array(
                "code" => 'filename is empty',
                "name" => 'File name not specified'
            );

            return response()->json($err, 400);
        }
    }

    /**
     * @OA\Delete(
     *     path="/storage_files/delete",
     *     tags={"Storage Files"},
     *     summary="Delete storage file",
     *     operationId="deleteStorageFile",
     *     security={{"cookieAuth": {}}},
     *     @OA\RequestBody(
     *         required=true,
     *         description="Input data format",
     *         @OA\JsonContent(ref="#/components/schemas/StorageFileDeleteRequest")
     *
     *     ),
     *     @OA\Response(
     *         response=200,
     *         description="Success"
     *     )
     * )
     */

    public function delete(Request $request, Fusion $api) {

        $filename = $request->get('storage_file_name');
        $username = $api->cookieAr['currentUser'];
        $sf = StorageFiles::
            where('user_name', $username)->
            where('storage_file_name', $filename)
            ->first();

        if($sf !== null && Storage::exists($filename)) {
            Storage::delete($filename);
        }

        if ($sf !== null) {
            $sf->delete();
        }

        return response()->json(array('success' => 'y'));
    }

}

// StorageFiles
Route::get('storage_files', 'StorageFilesController@index')->middleware('check_cookie');
Route::get('storage_files/addFileToQueue', 'StorageFilesController@addFileToQueue')->middleware('check_cookie');
Route::get('storage_files/download', 'StorageFilesController@download')->middleware('check_cookie');
Route::get('storage_files/count', 'StorageFilesController@items_count')->middleware('check_cookie');
Route::delete('storage_files/delete', 'StorageFilesController@delete')->middleware('check_cookie');

<?php

namespace App\Http\Middleware;

use Illuminate\Foundation\Http\Middleware\VerifyCsrfToken as Middleware;

class VerifyCsrfToken extends Middleware
{
    /**
     * The URIs that should be excluded from CSRF verification.
     *
     * @var array
     */
    protected $except = [
        '/api/login',
    // Storage Files
        'api/storage_files/delete',
    // RunningFusionFuncs
        'api/fq/delete/',
        'api/fq/delete_completed/',
    // House Management
        'api/hm/edit',
    // ..other routes
    ];
}

<?php

return [

    /*
    |--------------------------------------------------------------------------
    | Default Filesystem Disk
    |--------------------------------------------------------------------------
    |
    | Here you may specify the default filesystem disk that should be used
    | by the framework. The "local" disk, as well as a variety of cloud
    | based disks are available to your application. Just store away!
    |
    */

    'default' => env('FILESYSTEM_DRIVER', 'public'),

    /*
    |--------------------------------------------------------------------------
    | Default Cloud Filesystem Disk
    |--------------------------------------------------------------------------
    |
    | Many applications store files both locally and in the cloud. For this
    | reason, you may specify a default "cloud" driver here. This driver
    | will be bound as the Cloud disk implementation in the container.
    |
    */

    'cloud' => env('FILESYSTEM_CLOUD', 's3'),

    /*
    |--------------------------------------------------------------------------
    | Filesystem Disks
    |--------------------------------------------------------------------------
    |
    | Here you may configure as many filesystem "disks" as you wish, and you
    | may even configure multiple disks of the same driver. Defaults have
    | been setup for each driver as an example of the required options.
    |
    | Supported Drivers: "local", "ftp", "sftp", "s3"
    |
    */

    'disks' => [

        'local' => [
            'driver' => 'local',
            'root' => storage_path('app'),
        ],

        'public' => [
            'driver' => 'local',
            'root' => storage_path('app/public'),
            'url' => env('APP_URL').'/storage',
            'visibility' => 'public',
        ],

        's3' => [
            'driver' => 's3',
            'key' => env('AWS_ACCESS_KEY_ID'),
            'secret' => env('AWS_SECRET_ACCESS_KEY'),
            'region' => env('AWS_DEFAULT_REGION'),
            'bucket' => env('AWS_BUCKET'),
            'url' => env('AWS_URL'),
            'endpoint' => env('AWS_ENDPOINT'),
        ],

    ],

    /*
    |--------------------------------------------------------------------------
    | Symbolic Links
   ----------------------------------------------------
    |
    | Here you may configure the symbolic links that will be created when the
    | `storage:link` Artisan command is executed. The array keys should be
    | the locations of the links and the values should be their targets.
    |
    */

    'links' => [
        public_path('storage') => storage_path('app/public'),
    ],

];

php artisan storage:link

php artisan make:job DownloadFile

<?php

namespace App\Jobs;

use App\StorageFiles;
use GuzzleHttp\Client;
use GuzzleHttp\Cookie\CookieJar;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;
use Illuminate\Support\Carbon;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\Storage;

class DownloadFusionFile implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    /**
     * @var string
     */
    protected $url;

    /**
     * @var array
     */
    protected $cookiesJar;

    /**
     * @var string
     */
    protected $fileType;

    /**
     * @var string
     */
    protected $fileExtension;

    /**
     * @var string
     */
    protected $fileSizeSrc;


    /**
     * Create a new job instance.
     *
     * @return void
     */
    public function __construct($url,
                                $cookiesJar,
                                $fileType,
                                $fileExtension,
                                $fileSizeSrc)
    {
        $this->url = $url;
        $this->cookiesJar = $cookiesJar;
        $this->fileType = $fileType;
        $this->fileExtension = $fileExtension;
        $this->fileSizeSrc = $fileSizeSrc;
    }

    /**
     * Execute the job.
     *
     * @return void
     */
    public function handle()
    {
        $file_ext = $this->fileExtension;
        $storage_filename = "file_"
            . $this->cookiesJar['currentUser'] . '_'
            . Carbon::now()->format('YmdHs') . '.'
            . $file_ext;
        $file_path = public_path() . "/storage/" . $storage_filename;
        $fileSizeSrc = $this->fileSizeSrc;

        // create a db-record
        // about the file is going to be downloaded
        $sf = new StorageFiles;
        $sf->user_name = $this->cookiesJar['currentUser'];
        $sf->file_status = 'downloading';
        $sf->file_type = $this->fileType;
        $sf->storage_file_name = $storage_filename;
        $sf->fusion_url = $this->url;
        $sf->file_size_src = $fileSizeSrc;
        $sf->save();

        $contentType = 'application/octet-stream';
        switch ($file_ext) {
            case 'rar':
                $contentType = 'application/x-rar-compressed';
                break;
            case 'pdf':
                $contentType = 'application/pdf';
                break;
            case 'xls':
                $contentType = 'application/vnd.ms-excel';
                break;
            case 'csv':
                $contentType = 'text/csv';
                break;
            case 'txt':
                $contentType = 'text/plain';
                break;
            case 'dbf':
                $contentType = 'application/dbase';
                break;
        }
        $headers = [
            'Content-Type' => $contentType,
            'Content-Disposition' => 'attachment; filename="' . $storage_filename . '"'
        ];
        $domain = config('app.FUSION_DOMAIN');
        $cookieJar = CookieJar::fromArray($this->cookiesJar, $domain);
        $client = new Client([
            'headers' => $headers,
            'cookies' => $cookieJar
        ]);

        $response = $client->request(
            'GET', $this->url, [
                'sink' => $file_path
                ]
        );

        $file_name = $response->getHeaderLine('Content-disposition');
        if (preg_match('/.*filename=[\'\"]?([^\"]+)/', $file_name, $matches)) {
            $file_name = urldecode($matches[1]);
        }

        Log::info('File Name = ' . $file_name);

        $sf->file_status = 'ready';
        $sf->file_name = $file_name;
        $sf->file_type = $this->fileType;

        if (isset($response->getHeaders()["Content-Length"])) {
            $sf->file_size = $response->getHeader('Content-Length')[0];
        } else {
            $sf->file_size = Storage::size($sf->storage_file_name);
        }

        $sf->download_link = $file_path;
        $sf->update();

        $sf->duration = $sf->created_at->diff($sf->updated_at)->format('%H:%I:%S');
        $sf->update();

        // queue the deletion of the file and the database record after a while
        $del_after = config('app.DEL_STRG_FILE_AFTER');
        DeleteStorageFile::dispatch($storage_filename)
          ->delay(now()->addMinutes($del_after));
    }
}

<?php

namespace App\Jobs;

use App\StorageFiles;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\Storage;

class DeleteStorageFile implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    /**
     * @var string
     */
    protected $filename;

    /**
     * Create a new job instance.
     *
     * @return void
     */
    public function __construct($filename)
    {
        $this->filename = $filename;
    }

    /**
     * Execute the job.
     *
     * @return void
     */
    public function handle()
    {
        $downloadLink = public_path(). "/storage/" . $this->filename;
        if (Storage::exists($this->filename)) {
            Storage::delete($this->filename);
            Log::info('file deleted = ' . $downloadLink);
        }

        $deleteRows = StorageFiles::where('download_link', $downloadLink)->delete();
        Log::info('deleteRows = ' . $deleteRows);
    }
}

php artisan queue:work

composer install --optimize-autoloader --no-dev  --no-interaction --prefer-dist
php artisan clear-compiled --env=production
php artisan optimize --env=production
php artisan migrate --force
php artisan storage:link
sudo systemctl enable billing-backend.service
sudo systemctl stop billing-backend.service
sudo systemctl start billing-backend.service
sudo supervisorctl stop all
sudo supervisorctl restart laravel-worker:*

[Unit]
Description=Billing backend

[Service]
User=www-data
Group=www-data
Restart=on-failure
ExecStart=/usr/bin/php /home/dev/backend/artisan serve --host=0.0.0.0

[Install]
WantedBy=multi-user.target

[program:laravel-worker]
process_name=%(program_name)s_%(process_num)02d
command=/usr/bin/php /home/dev/backend/artisan queue:work database --sleep=3 --tries=3 --timeout=0
autostart=true
autorestart=true
user=root
numprocs=8
redirect_stderr=true
stdout_logfile=/home/dev/backend/storage/logs/worker.log
stopwaitsecs=3600