BackupJob::getExtension() - Code Metrics - Inspection of "Fixed mongo user auth error + fix wrong extension..." - spatie/laravel-backup - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 25571a...608c0a )

by Freek

created 2019-01-30 09:24 UTC

BackupJob::getExtension() A

↳ Parent: BackupJob

Complexity

Conditions	2
Paths	2

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	2
nc	2
nop	1
dl	0
loc	3
rs	10
c	0
b	0
f	0

<?php

namespace Spatie\Backup\Tasks\Backup;

use Exception;
use Carbon\Carbon;
use Spatie\DbDumper\Databases\MongoDb;
use Spatie\DbDumper\DbDumper;
use Illuminate\Support\Collection;
use Spatie\DbDumper\Databases\Sqlite;
use Spatie\Backup\Events\BackupHasFailed;
use Spatie\Backup\Events\BackupWasSuccessful;
use Spatie\Backup\Events\BackupZipWasCreated;
use Spatie\Backup\Exceptions\InvalidBackupJob;
use Spatie\DbDumper\Compressors\GzipCompressor;
use Spatie\TemporaryDirectory\TemporaryDirectory;
use Spatie\Backup\Events\BackupManifestWasCreated;
use Spatie\Backup\BackupDestination\BackupDestination;

class BackupJob
{
    /** @var \Spatie\Backup\Tasks\Backup\FileSelection */
    protected $fileSelection;

    /** @var \Illuminate\Support\Collection */
    protected $dbDumpers;

    /** @var \Illuminate\Support\Collection */
    protected $backupDestinations;

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

    /** @var \Spatie\TemporaryDirectory\TemporaryDirectory */
    protected $temporaryDirectory;

    /** @var bool */
    protected $sendNotifications = true;

    public function __construct()
    {
        $this->dontBackupFilesystem();
        $this->dontBackupDatabases();
        $this->setDefaultFilename();

        $this->backupDestinations = new Collection();
    }

    public function dontBackupFilesystem(): self
    {
        $this->fileSelection = FileSelection::create();

        return $this;
    }

    public function onlyDbName(array $allowedDbNames): self
    {
        $this->dbDumpers = $this->dbDumpers->filter(
            function (DbDumper $dbDumper, string $connectionName) use ($allowedDbNames) {
                return in_array($connectionName, $allowedDbNames);
            });

        return $this;
    }

    public function dontBackupDatabases(): self
    {
        $this->dbDumpers = new Collection();

        return $this;
    }

    public function disableNotifications(): self
    {
        $this->sendNotifications = false;

        return $this;
    }

    public function setDefaultFilename(): self
    {
        $this->filename = Carbon::now()->format('Y-m-d-H-i-s').'.zip';

        return $this;
    }

    public function setFileSelection(FileSelection $fileSelection): self
    {
        $this->fileSelection = $fileSelection;

        return $this;
    }

    public function setDbDumpers(Collection $dbDumpers): self
    {
        $this->dbDumpers = $dbDumpers;

        return $this;
    }

    public function setFilename(string $filename): self
    {
        $this->filename = $filename;

        return $this;
    }

    public function onlyBackupTo(string $diskName): self
    {
        $this->backupDestinations = $this->backupDestinations->filter(function (BackupDestination $backupDestination) use ($diskName) {
            return $backupDestination->diskName() === $diskName;
        });

        if (! count($this->backupDestinations)) {
            throw InvalidBackupJob::destinationDoesNotExist($diskName);
        }

        return $this;
    }

    public function setBackupDestinations(Collection $backupDestinations): self
    {
        $this->backupDestinations = $backupDestinations;

        return $this;
    }

    public function run()
    {
        $temporaryDirectoryPath = config('backup.backup.temporary_directory') ?? storage_path('app/backup-temp');

        $this->temporaryDirectory = (new TemporaryDirectory($temporaryDirectoryPath))
            ->name('temp')
            ->force()
            ->create()
            ->empty();

        try {
            if (! count($this->backupDestinations)) {
                throw InvalidBackupJob::noDestinationsSpecified();
            }

            $manifest = $this->createBackupManifest();

            if (! $manifest->count()) {
                throw InvalidBackupJob::noFilesToBeBackedUp();
            }

            $zipFile = $this->createZipContainingEveryFileInManifest($manifest);

            $this->copyToBackupDestinations($zipFile);
        } catch (Exception $exception) {
            consoleOutput()->error("Backup failed because {$exception->getMessage()}.".PHP_EOL.$exception->getTraceAsString());
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }

            $this->sendNotification(new BackupHasFailed($exception));

            $this->temporaryDirectory->delete();

            throw $exception;
        }

        $this->temporaryDirectory->delete();
    }

    protected function createBackupManifest(): Manifest
    {
        $databaseDumps = $this->dumpDatabases();

        consoleOutput()->info('Determining files to backup...');
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }

        $manifest = Manifest::create($this->temporaryDirectory->path('manifest.txt'))
            ->addFiles($databaseDumps)
            ->addFiles($this->filesToBeBackedUp());
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        $this->sendNotification(new BackupManifestWasCreated($manifest));

        return $manifest;
    }

    public function filesToBeBackedUp()
    {
        $this->fileSelection->excludeFilesFrom($this->directoriesUsedByBackupJob());

        return $this->fileSelection->selectedFiles();
    }

    protected function directoriesUsedByBackupJob(): array
    {
        return $this->backupDestinations
            ->filter(function (BackupDestination $backupDestination) {
                return $backupDestination->filesystemType() === 'local';
            })
            ->map(function (BackupDestination $backupDestination) {
                return $backupDestination->disk()->getDriver()->getAdapter()->applyPathPrefix('').$backupDestination->backupName();
            })
            ->each(function (string $backupDestinationDirectory) {
                $this->fileSelection->excludeFilesFrom($backupDestinationDirectory);
            })
            ->push($this->temporaryDirectory->path())
            ->toArray();
    }

    protected function createZipContainingEveryFileInManifest(Manifest $manifest)
    {
        consoleOutput()->info("Zipping {$manifest->count()} files...");
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }

        $pathToZip = $this->temporaryDirectory->path(config('backup.backup.destination.filename_prefix').$this->filename);

        $zip = Zip::createForManifest($manifest, $pathToZip);

        consoleOutput()->info("Created zip containing {$zip->count()} files. Size is {$zip->humanReadableSize()}");
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }

        $this->sendNotification(new BackupZipWasCreated($pathToZip));

        return $pathToZip;
    }

    /**
     * Dumps the databases to the given directory.
     * Returns an array with paths to the dump files.
     *
     * @return array
     */
    protected function dumpDatabases(): array
    {
        return $this->dbDumpers->map(function (DbDumper $dbDumper) {
            consoleOutput()->info("Dumping database {$dbDumper->getDbName()}...");
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }

            $dbType = mb_strtolower(basename(str_replace('\\', '/', get_class($dbDumper))));

            $dbName = $dbDumper instanceof Sqlite ? 'database' : $dbDumper->getDbName();
	        $fileName = "{$dbType}-{$dbName}.{$this->getExtension($dbDumper)}";
	        
            if (config('backup.backup.gzip_database_dump')) {
                $dbDumper->useCompressor(new GzipCompressor());
                $fileName .= '.'.$dbDumper->getCompressorExtension();
            }

            if ($compressor = config('backup.backup.database_dump_compressor')) {
                $dbDumper->useCompressor(new $compressor());
                $fileName .= '.'.$dbDumper->getCompressorExtension();
            }

            $temporaryFilePath = $this->temporaryDirectory->path('db-dumps'.DIRECTORY_SEPARATOR.$fileName);

            $dbDumper->dumpToFile($temporaryFilePath);

            return $temporaryFilePath;
        })->toArray();
    }

    protected function copyToBackupDestinations(string $path)
    {
        $this->backupDestinations->each(function (BackupDestination $backupDestination) use ($path) {
            try {
                consoleOutput()->info("Copying zip to disk named {$backupDestination->diskName()}...");
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }

                $backupDestination->write($path);

                consoleOutput()->info("Successfully copied zip to disk named {$backupDestination->diskName()}.");
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }

                $this->sendNotification(new BackupWasSuccessful($backupDestination));
            } catch (Exception $exception) {
                consoleOutput()->error("Copying zip failed because: {$exception->getMessage()}.");
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }

                $this->sendNotification(new BackupHasFailed($exception, $backupDestination ?? null));
            }
        });
    }

    protected function sendNotification($notification)
    {
        if ($this->sendNotifications) {
            event($notification);
        }
    }

	/**
	 * @param $dbDumper
	 *
	 * @return string
	 */
	protected function getExtension($dbDumper) {
		return $dbDumper instanceof MongoDb ? "archive" : "sql";
	}
}


1			<?php
2
3			namespace Spatie\Backup\Tasks\Backup;
4
5			use Exception;
6			use Carbon\Carbon;
7			use Spatie\DbDumper\Databases\MongoDb;
8			use Spatie\DbDumper\DbDumper;
9			use Illuminate\Support\Collection;
10			use Spatie\DbDumper\Databases\Sqlite;
11			use Spatie\Backup\Events\BackupHasFailed;
12			use Spatie\Backup\Events\BackupWasSuccessful;
13			use Spatie\Backup\Events\BackupZipWasCreated;
14			use Spatie\Backup\Exceptions\InvalidBackupJob;
15			use Spatie\DbDumper\Compressors\GzipCompressor;
16			use Spatie\TemporaryDirectory\TemporaryDirectory;
17			use Spatie\Backup\Events\BackupManifestWasCreated;
18			use Spatie\Backup\BackupDestination\BackupDestination;
19
20			class BackupJob
21			{
22			/** @var \Spatie\Backup\Tasks\Backup\FileSelection */
23			protected $fileSelection;
24
25			/** @var \Illuminate\Support\Collection */
26			protected $dbDumpers;
27
28			/** @var \Illuminate\Support\Collection */
29			protected $backupDestinations;
30
31			/** @var string */
32			protected $filename;
33
34			/** @var \Spatie\TemporaryDirectory\TemporaryDirectory */
35			protected $temporaryDirectory;
36
37			/** @var bool */
38			protected $sendNotifications = true;
39
40			public function __construct()
41			{
42			$this->dontBackupFilesystem();
43			$this->dontBackupDatabases();
44			$this->setDefaultFilename();
45
46			$this->backupDestinations = new Collection();
47			}
48
49			public function dontBackupFilesystem(): self
50			{
51			$this->fileSelection = FileSelection::create();
52
53			return $this;
54			}
55
56			public function onlyDbName(array $allowedDbNames): self
57			{
58			$this->dbDumpers = $this->dbDumpers->filter(
59			function (DbDumper $dbDumper, string $connectionName) use ($allowedDbNames) {
60			return in_array($connectionName, $allowedDbNames);
61			});
62
63			return $this;
64			}
65
66			public function dontBackupDatabases(): self
67			{
68			$this->dbDumpers = new Collection();
69
70			return $this;
71			}
72
73			public function disableNotifications(): self
74			{
75			$this->sendNotifications = false;
76
77			return $this;
78			}
79
80			public function setDefaultFilename(): self
81			{
82			$this->filename = Carbon::now()->format('Y-m-d-H-i-s').'.zip';
83
84			return $this;
85			}
86
87			public function setFileSelection(FileSelection $fileSelection): self
88			{
89			$this->fileSelection = $fileSelection;
90
91			return $this;
92			}
93
94			public function setDbDumpers(Collection $dbDumpers): self
95			{
96			$this->dbDumpers = $dbDumpers;
97
98			return $this;
99			}
100
101			public function setFilename(string $filename): self
102			{
103			$this->filename = $filename;
104
105			return $this;
106			}
107
108			public function onlyBackupTo(string $diskName): self
109			{
110			$this->backupDestinations = $this->backupDestinations->filter(function (BackupDestination $backupDestination) use ($diskName) {
111			return $backupDestination->diskName() === $diskName;
112			});
113
114			if (! count($this->backupDestinations)) {
115			throw InvalidBackupJob::destinationDoesNotExist($diskName);
116			}
117
118			return $this;
119			}
120
121			public function setBackupDestinations(Collection $backupDestinations): self
122			{
123			$this->backupDestinations = $backupDestinations;
124
125			return $this;
126			}
127
128			public function run()
129			{
130			$temporaryDirectoryPath = config('backup.backup.temporary_directory') ?? storage_path('app/backup-temp');
131
132			$this->temporaryDirectory = (new TemporaryDirectory($temporaryDirectoryPath))
133			->name('temp')
134			->force()
135			->create()
136			->empty();
137
138			try {
139			if (! count($this->backupDestinations)) {
140			throw InvalidBackupJob::noDestinationsSpecified();
141			}
142
143			$manifest = $this->createBackupManifest();
144
145			if (! $manifest->count()) {
146			throw InvalidBackupJob::noFilesToBeBackedUp();
147			}
148
149			$zipFile = $this->createZipContainingEveryFileInManifest($manifest);
150
151			$this->copyToBackupDestinations($zipFile);
152			} catch (Exception $exception) {
153			consoleOutput()->error("Backup failed because {$exception->getMessage()}.".PHP_EOL.$exception->getTraceAsString());
			0 ignored issues – show Documentation Bug introduced 2016-09-16 15:34 UTC by Report Bug Copy Issue Report The method `error` does not exist on `object<Spatie\Backup\Helpers\ConsoleOutput>`? Since you implemented `__call`, maybe consider adding a @method annotation. If you implement `__call` and you know which methods are available, you can improve IDE auto-completion and static analysis by adding a @method annotation to the class. This is often the case, when `__call` is implemented by a parent class and only the child class knows which methods exist: class ParentClass { private $data = array(); public function __call($method, array $args) { if (0 === strpos($method, 'get')) { return $this->data[strtolower(substr($method, 3))]; } throw new \LogicException(sprintf('Unsupported method: %s', $method)); } } /** * If this class knows which fields exist, you can specify the methods here: * * @method string getName() */ class SomeClass extends ParentClass { } Loading history...
154
155			$this->sendNotification(new BackupHasFailed($exception));
156
157			$this->temporaryDirectory->delete();
158
159			throw $exception;
160			}
161
162			$this->temporaryDirectory->delete();
163			}
164
165			protected function createBackupManifest(): Manifest
166			{
167			$databaseDumps = $this->dumpDatabases();
168
169			consoleOutput()->info('Determining files to backup...');
			0 ignored issues – show Documentation Bug introduced 2017-04-19 13:43 UTC by Report Bug Copy Issue Report The method `info` does not exist on `object<Spatie\Backup\Helpers\ConsoleOutput>`? Since you implemented `__call`, maybe consider adding a @method annotation. If you implement `__call` and you know which methods are available, you can improve IDE auto-completion and static analysis by adding a @method annotation to the class. This is often the case, when `__call` is implemented by a parent class and only the child class knows which methods exist: class ParentClass { private $data = array(); public function __call($method, array $args) { if (0 === strpos($method, 'get')) { return $this->data[strtolower(substr($method, 3))]; } throw new \LogicException(sprintf('Unsupported method: %s', $method)); } } /** * If this class knows which fields exist, you can specify the methods here: * * @method string getName() */ class SomeClass extends ParentClass { } Loading history...
170
171			$manifest = Manifest::create($this->temporaryDirectory->path('manifest.txt'))
172			->addFiles($databaseDumps)
173			->addFiles($this->filesToBeBackedUp());
			0 ignored issues – show Documentation introduced 2018-05-01 07:36 UTC by Report Bug Copy Issue Report `$this->filesToBeBackedUp()` is of type `object<Generator>`, but the function expects a `array\|string`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
174
175			$this->sendNotification(new BackupManifestWasCreated($manifest));
176
177			return $manifest;
178			}
179
180			public function filesToBeBackedUp()
181			{
182			$this->fileSelection->excludeFilesFrom($this->directoriesUsedByBackupJob());
183
184			return $this->fileSelection->selectedFiles();
185			}
186
187			protected function directoriesUsedByBackupJob(): array
188			{
189			return $this->backupDestinations
190			->filter(function (BackupDestination $backupDestination) {
191			return $backupDestination->filesystemType() === 'local';
192			})
193			->map(function (BackupDestination $backupDestination) {
194			return $backupDestination->disk()->getDriver()->getAdapter()->applyPathPrefix('').$backupDestination->backupName();
195			})
196			->each(function (string $backupDestinationDirectory) {
197			$this->fileSelection->excludeFilesFrom($backupDestinationDirectory);
198			})
199			->push($this->temporaryDirectory->path())
200			->toArray();
201			}
202
203			protected function createZipContainingEveryFileInManifest(Manifest $manifest)
204			{
205			consoleOutput()->info("Zipping {$manifest->count()} files...");
			0 ignored issues – show Documentation Bug introduced 2016-09-16 15:34 UTC by Report Bug Copy Issue Report The method `info` does not exist on `object<Spatie\Backup\Helpers\ConsoleOutput>`? Since you implemented `__call`, maybe consider adding a @method annotation. If you implement `__call` and you know which methods are available, you can improve IDE auto-completion and static analysis by adding a @method annotation to the class. This is often the case, when `__call` is implemented by a parent class and only the child class knows which methods exist: class ParentClass { private $data = array(); public function __call($method, array $args) { if (0 === strpos($method, 'get')) { return $this->data[strtolower(substr($method, 3))]; } throw new \LogicException(sprintf('Unsupported method: %s', $method)); } } /** * If this class knows which fields exist, you can specify the methods here: * * @method string getName() */ class SomeClass extends ParentClass { } Loading history...
206
207			$pathToZip = $this->temporaryDirectory->path(config('backup.backup.destination.filename_prefix').$this->filename);
208
209			$zip = Zip::createForManifest($manifest, $pathToZip);
210
211			consoleOutput()->info("Created zip containing {$zip->count()} files. Size is {$zip->humanReadableSize()}");
			0 ignored issues – show Documentation Bug introduced 2016-09-16 15:34 UTC by Report Bug Copy Issue Report The method `info` does not exist on `object<Spatie\Backup\Helpers\ConsoleOutput>`? Since you implemented `__call`, maybe consider adding a @method annotation. If you implement `__call` and you know which methods are available, you can improve IDE auto-completion and static analysis by adding a @method annotation to the class. This is often the case, when `__call` is implemented by a parent class and only the child class knows which methods exist: class ParentClass { private $data = array(); public function __call($method, array $args) { if (0 === strpos($method, 'get')) { return $this->data[strtolower(substr($method, 3))]; } throw new \LogicException(sprintf('Unsupported method: %s', $method)); } } /** * If this class knows which fields exist, you can specify the methods here: * * @method string getName() */ class SomeClass extends ParentClass { } Loading history...
212
213			$this->sendNotification(new BackupZipWasCreated($pathToZip));
214
215			return $pathToZip;
216			}
217
218			/**
219			* Dumps the databases to the given directory.
220			* Returns an array with paths to the dump files.
221			*
222			* @return array
223			*/
224			protected function dumpDatabases(): array
225			{
226			return $this->dbDumpers->map(function (DbDumper $dbDumper) {
227			consoleOutput()->info("Dumping database {$dbDumper->getDbName()}...");
			0 ignored issues – show Documentation Bug introduced 2017-04-19 13:43 UTC by Report Bug Copy Issue Report The method `info` does not exist on `object<Spatie\Backup\Helpers\ConsoleOutput>`? Since you implemented `__call`, maybe consider adding a @method annotation. If you implement `__call` and you know which methods are available, you can improve IDE auto-completion and static analysis by adding a @method annotation to the class. This is often the case, when `__call` is implemented by a parent class and only the child class knows which methods exist: class ParentClass { private $data = array(); public function __call($method, array $args) { if (0 === strpos($method, 'get')) { return $this->data[strtolower(substr($method, 3))]; } throw new \LogicException(sprintf('Unsupported method: %s', $method)); } } /** * If this class knows which fields exist, you can specify the methods here: * * @method string getName() */ class SomeClass extends ParentClass { } Loading history...
228
229			$dbType = mb_strtolower(basename(str_replace('\\', '/', get_class($dbDumper))));
230
231			$dbName = $dbDumper instanceof Sqlite ? 'database' : $dbDumper->getDbName();
232			$fileName = "{$dbType}-{$dbName}.{$this->getExtension($dbDumper)}";
233
234			if (config('backup.backup.gzip_database_dump')) {
235			$dbDumper->useCompressor(new GzipCompressor());
236			$fileName .= '.'.$dbDumper->getCompressorExtension();
237			}
238
239			if ($compressor = config('backup.backup.database_dump_compressor')) {
240			$dbDumper->useCompressor(new $compressor());
241			$fileName .= '.'.$dbDumper->getCompressorExtension();
242			}
243
244			$temporaryFilePath = $this->temporaryDirectory->path('db-dumps'.DIRECTORY_SEPARATOR.$fileName);
245
246			$dbDumper->dumpToFile($temporaryFilePath);
247
248			return $temporaryFilePath;
249			})->toArray();
250			}
251
252			protected function copyToBackupDestinations(string $path)
253			{
254			$this->backupDestinations->each(function (BackupDestination $backupDestination) use ($path) {
255			try {
256			consoleOutput()->info("Copying zip to disk named {$backupDestination->diskName()}...");
			0 ignored issues – show Documentation Bug introduced 2016-09-16 15:34 UTC by Report Bug Copy Issue Report The method `info` does not exist on `object<Spatie\Backup\Helpers\ConsoleOutput>`? Since you implemented `__call`, maybe consider adding a @method annotation. If you implement `__call` and you know which methods are available, you can improve IDE auto-completion and static analysis by adding a @method annotation to the class. This is often the case, when `__call` is implemented by a parent class and only the child class knows which methods exist: class ParentClass { private $data = array(); public function __call($method, array $args) { if (0 === strpos($method, 'get')) { return $this->data[strtolower(substr($method, 3))]; } throw new \LogicException(sprintf('Unsupported method: %s', $method)); } } /** * If this class knows which fields exist, you can specify the methods here: * * @method string getName() */ class SomeClass extends ParentClass { } Loading history...
257
258			$backupDestination->write($path);
259
260			consoleOutput()->info("Successfully copied zip to disk named {$backupDestination->diskName()}.");
			0 ignored issues – show Documentation Bug introduced 2016-09-16 15:34 UTC by Report Bug Copy Issue Report The method `info` does not exist on `object<Spatie\Backup\Helpers\ConsoleOutput>`? Since you implemented `__call`, maybe consider adding a @method annotation. If you implement `__call` and you know which methods are available, you can improve IDE auto-completion and static analysis by adding a @method annotation to the class. This is often the case, when `__call` is implemented by a parent class and only the child class knows which methods exist: class ParentClass { private $data = array(); public function __call($method, array $args) { if (0 === strpos($method, 'get')) { return $this->data[strtolower(substr($method, 3))]; } throw new \LogicException(sprintf('Unsupported method: %s', $method)); } } /** * If this class knows which fields exist, you can specify the methods here: * * @method string getName() */ class SomeClass extends ParentClass { } Loading history...
261
262			$this->sendNotification(new BackupWasSuccessful($backupDestination));
263			} catch (Exception $exception) {
264			consoleOutput()->error("Copying zip failed because: {$exception->getMessage()}.");
			0 ignored issues – show Documentation Bug introduced 2016-03-07 17:59 UTC by Report Bug Copy Issue Report The method `error` does not exist on `object<Spatie\Backup\Helpers\ConsoleOutput>`? Since you implemented `__call`, maybe consider adding a @method annotation. If you implement `__call` and you know which methods are available, you can improve IDE auto-completion and static analysis by adding a @method annotation to the class. This is often the case, when `__call` is implemented by a parent class and only the child class knows which methods exist: class ParentClass { private $data = array(); public function __call($method, array $args) { if (0 === strpos($method, 'get')) { return $this->data[strtolower(substr($method, 3))]; } throw new \LogicException(sprintf('Unsupported method: %s', $method)); } } /** * If this class knows which fields exist, you can specify the methods here: * * @method string getName() */ class SomeClass extends ParentClass { } Loading history...
265
266			$this->sendNotification(new BackupHasFailed($exception, $backupDestination ?? null));
267			}
268			});
269			}
270
271			protected function sendNotification($notification)
272			{
273			if ($this->sendNotifications) {
274			event($notification);
275			}
276			}
277
278			/**
279			* @param $dbDumper
280			*
281			* @return string
282			*/
283			protected function getExtension($dbDumper) {
284			return $dbDumper instanceof MongoDb ? "archive" : "sql";
285			}
286			}
287

spatie / laravel-backup

Push — master ( 25571a...608c0a )

BackupJob::getExtension() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like