Enhanced PHP File Manager

⬆️ Go Up (..)

📊 Server Information

Server:

LiteSpeed

System:

Linux 5.14.0-570.21.1.el9_6.x86_64

PHP Version:

8.2.28

User:

u184721437

Directory:

/home/u184721437/domains/dataduck.in/public_html/invoice/vendor/maatwebsite/excel/src/Fakes

Free Space:

7.07 TB

🔧 Quick Actions

✏️ Editing: ExcelFake.php

<?php

namespace Maatwebsite\Excel\Fakes;

use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\PendingDispatch;
use Illuminate\Support\Collection;
use Illuminate\Support\Facades\Queue;
use Maatwebsite\Excel\Exporter;
use Maatwebsite\Excel\Importer;
use Maatwebsite\Excel\Reader;
use PHPUnit\Framework\Assert;
use Symfony\Component\HttpFoundation\BinaryFileResponse;
use Symfony\Component\HttpFoundation\File\UploadedFile;

class ExcelFake implements Exporter, Importer
{
    /**
     * @var array
     */
    protected $downloads = [];

/**
     * @var array
     */
    protected $stored = [];

/**
     * @var array
     */
    protected $queued = [];

/**
     * @var array
     */
    protected $raws = [];

/**
     * @var array
     */
    protected $imported = [];

/**
     * @var bool
     */
    protected $matchByRegex = false;

/**
     * @var object|null
     */
    protected $job;

/**
     * {@inheritdoc}
     */
    public function download($export, string $fileName, string $writerType = null, array $headers = [])
    {
        $this->downloads[$fileName] = $export;

return new BinaryFileResponse(__DIR__ . '/fake_file');
    }

/**
     * {@inheritdoc}
     */
    public function store($export, string $filePath, string $disk = null, string $writerType = null, $diskOptions = [])
    {
        if ($export instanceof ShouldQueue) {
            return $this->queue($export, $filePath, $disk, $writerType);
        }

$this->stored[$disk ?? 'default'][$filePath] = $export;

return true;
    }

/**
     * {@inheritdoc}
     */
    public function queue($export, string $filePath, string $disk = null, string $writerType = null, $diskOptions = [])
    {
        Queue::fake();

$this->stored[$disk ?? 'default'][$filePath] = $export;
        $this->queued[$disk ?? 'default'][$filePath] = $export;

$this->job = new class
        {
            use Queueable;

public function handle()
            {
                //
            }
        };

Queue::push($this->job);

return new PendingDispatch($this->job);
    }

/**
     * @param  object  $export
     * @param  string  $writerType
     * @return string
     */
    public function raw($export, string $writerType)
    {
        $this->raws[get_class($export)] = $export;

return 'RAW-CONTENTS';
    }

/**
     * @param  object  $import
     * @param  string|UploadedFile  $file
     * @param  string|null  $disk
     * @param  string|null  $readerType
     * @return Reader|PendingDispatch
     */
    public function import($import, $file, string $disk = null, string $readerType = null)
    {
        if ($import instanceof ShouldQueue) {
            return $this->queueImport($import, $file, $disk, $readerType);
        }

$filePath = ($file instanceof UploadedFile) ? $file->getClientOriginalName() : $file;

$this->imported[$disk ?? 'default'][$filePath] = $import;

return $this;
    }

/**
     * @param  object  $import
     * @param  string|UploadedFile  $file
     * @param  string|null  $disk
     * @param  string|null  $readerType
     * @return array
     */
    public function toArray($import, $file, string $disk = null, string $readerType = null): array
    {
        $filePath = ($file instanceof UploadedFile) ? $file->getFilename() : $file;

$this->imported[$disk ?? 'default'][$filePath] = $import;

return [];
    }

/**
     * @param  object  $import
     * @param  string|UploadedFile  $file
     * @param  string|null  $disk
     * @param  string|null  $readerType
     * @return Collection
     */
    public function toCollection($import, $file, string $disk = null, string $readerType = null): Collection
    {
        $filePath = ($file instanceof UploadedFile) ? $file->getFilename() : $file;

$this->imported[$disk ?? 'default'][$filePath] = $import;

return new Collection();
    }

/**
     * @param  ShouldQueue  $import
     * @param  string|UploadedFile  $file
     * @param  string|null  $disk
     * @param  string  $readerType
     * @return PendingDispatch
     */
    public function queueImport(ShouldQueue $import, $file, string $disk = null, string $readerType = null)
    {
        Queue::fake();

$filePath = ($file instanceof UploadedFile) ? $file->getFilename() : $file;

$this->queued[$disk ?? 'default'][$filePath]   = $import;
        $this->imported[$disk ?? 'default'][$filePath] = $import;

$this->job = new class
        {
            use Queueable;

public function handle()
            {
                //
            }
        };

Queue::push($this->job);

return new PendingDispatch($this->job);
    }

/**
     * When asserting downloaded, stored, queued or imported, use regular expression
     * to look for a matching file path.
     *
     * @return void
     */
    public function matchByRegex()
    {
        $this->matchByRegex = true;
    }

/**
     * When asserting downloaded, stored, queued or imported, use regular string
     * comparison for matching file path.
     *
     * @return void
     */
    public function doNotMatchByRegex()
    {
        $this->matchByRegex = false;
    }

/**
     * @param  string  $fileName
     * @param  callable|null  $callback
     */
    public function assertDownloaded(string $fileName, $callback = null)
    {
        $fileName = $this->assertArrayHasKey($fileName, $this->downloads, sprintf('%s is not downloaded', $fileName));