App::createBackup() - Code Metrics - Inspection of "Remove old instructions from the README.md." - pavel-mironchik/laravel-backup-panel - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — github-actions ( b5eae9 )

by Pavel

created 2021-01-30 17:32 UTC

App::createBackup() A

↳ Parent: App

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

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

<?php

namespace PavelMironchik\LaravelBackupPanel\Http\Livewire;

use Illuminate\Http\Response;
use Illuminate\Support\Facades\Cache;
use Illuminate\Support\Facades\Validator;
use Illuminate\Validation\ValidationException;
use Livewire\Component;
use PavelMironchik\LaravelBackupPanel\Jobs\CreateBackupJob;
use PavelMironchik\LaravelBackupPanel\Rules\BackupDisk;
use PavelMironchik\LaravelBackupPanel\Rules\PathToZip;
use Spatie\Backup\BackupDestination\Backup;
use Spatie\Backup\BackupDestination\BackupDestination;
use Spatie\Backup\Helpers\Format;
use Spatie\Backup\Tasks\Monitor\BackupDestinationStatus;
use Spatie\Backup\Tasks\Monitor\BackupDestinationStatusFactory;
use Symfony\Component\HttpFoundation\StreamedResponse;

class App extends Component
{
    public $backupStatuses = [];

    public $activeDisk = null;

    public $disks = [];

    public $files = [];

    public $deletingFile = null;

    public function updateBackupStatuses()
    {
        $this->backupStatuses = Cache::remember('backup-statuses', now()->addSeconds(4), function () {
            return BackupDestinationStatusFactory::createForMonitorConfig(config('backup.monitor_backups'))
                ->map(function (BackupDestinationStatus $backupDestinationStatus) {
                    return [
                        'name' => $backupDestinationStatus->backupDestination()->backupName(),
                        'disk' => $backupDestinationStatus->backupDestination()->diskName(),
                        'reachable' => $backupDestinationStatus->backupDestination()->isReachable(),
                        'healthy' => $backupDestinationStatus->isHealthy(),
                        'amount' => $backupDestinationStatus->backupDestination()->backups()->count(),
                        'newest' => $backupDestinationStatus->backupDestination()->newestBackup()
                            ? $backupDestinationStatus->backupDestination()->newestBackup()->date()->diffForHumans()
                            : 'No backups present',
                        'usedStorage' => Format::humanReadableSize($backupDestinationStatus->backupDestination()->usedStorage()),
                    ];
                })
                ->values()
                ->toArray();
        });

        if (! $this->activeDisk and count($this->backupStatuses)) {
            $this->activeDisk = $this->backupStatuses[0]['disk'];
        }

        $this->disks = collect($this->backupStatuses)
            ->map(function ($backupStatus) {
                return $backupStatus['disk'];
            })
            ->values()
            ->all();

        $this->emitSelf('backupStatusesUpdated');
    }

    public function getFiles(string $disk = '')
    {
        if ($disk) {
            $this->activeDisk = $disk;
        }

        $this->validateActiveDisk();

        $backupDestination = BackupDestination::create($this->activeDisk, config('backup.backup.name'));

        $this->files = Cache::remember("backups-{$this->activeDisk}", now()->addSeconds(4), function () use ($backupDestination) {
            return $backupDestination
                ->backups()
                ->map(function (Backup $backup) {
                    return [
                        'path' => $backup->path(),
                        'date' => $backup->date()->format('Y-m-d H:i:s'),
                        'size' => Format::humanReadableSize($backup->size()),
                    ];
                })
                ->toArray();
        });
    }

    public function showDeleteModal($fileIndex)
    {
        $this->deletingFile = $this->files[$fileIndex];

        $this->emitSelf('showDeleteModal');
    }

    public function deleteFile()
    {
        $deletingFile = $this->deletingFile;
        $this->deletingFile = null;

        $this->emitSelf('hideDeleteModal');

        $this->validateActiveDisk();
        $this->validateFilePath($deletingFile ? $deletingFile['path'] : '');

        $backupDestination = BackupDestination::create($this->activeDisk, config('backup.backup.name'));

        $backupDestination
            ->backups()
            ->first(function (Backup $backup) use ($deletingFile) {
                return $backup->path() === $deletingFile['path'];
            })
            ->delete();

        $this->files = collect($this->files)
            ->reject(function ($file) use ($deletingFile) {
                return $file['path'] === $deletingFile['path']
                    && $file['date'] === $deletingFile['date']
                    && $file['size'] === $deletingFile['size'];
            })
            ->values()
            ->all();
    }

    public function downloadFile(string $filePath)
    {
        $this->validateActiveDisk();
        $this->validateFilePath($filePath);

        $backupDestination = BackupDestination::create($this->activeDisk, config('backup.backup.name'));

        $backup = $backupDestination->backups()->first(function (Backup $backup) use ($filePath) {
            return $backup->path() === $filePath;
        });

        if (! $backup) {
            return response('Backup not found', Response::HTTP_UNPROCESSABLE_ENTITY);
        }

        return $this->respondWithBackupStream($backup);
    }

    public function respondWithBackupStream(Backup $backup): StreamedResponse
    {
        $fileName = pathinfo($backup->path(), PATHINFO_BASENAME);

        $downloadHeaders = [
            'Cache-Control' => 'must-revalidate, post-check=0, pre-check=0',
            'Content-Type' => 'application/zip',
            'Content-Length' => $backup->size(),
            'Content-Disposition' => 'attachment; filename="'.$fileName.'"',
            'Pragma' => 'public',
        ];

        return response()->stream(function () use ($backup) {
            $stream = $backup->stream();

            fpassthru($stream);

            if (is_resource($stream)) {
                fclose($stream);
            }
        }, 200, $downloadHeaders);
    }

    public function createBackup(string $option = '')
    {
        dispatch(new CreateBackupJob($option))
            ->onQueue(config('laravel_backup_panel.queue'));
    }

    public function render()
    {
        return view('laravel_backup_panel::livewire.app');
    }

    protected function validateActiveDisk()
    {
        try {
            Validator::make(
                ['activeDisk' => $this->activeDisk],
                [
                    'activeDisk' => ['required', new BackupDisk()],
                ],
                [
                    'activeDisk.required' => 'Select a disk',
                ]
            )->validate();
        } catch (ValidationException $e) {
            $message = $e->validator->errors()->get('activeDisk')[0];
            $this->emitSelf('showErrorToast', $message);

            throw $e;
        }
    }

    protected function validateFilePath(string $filePath)
    {
        try {
            Validator::make(
                ['file' => $filePath],
                [
                    'file' => ['required', new PathToZip()],
                ],
                [
                    'file.required' => 'Select a file',
                ]
            )->validate();
        } catch (ValidationException $e) {
            $message = $e->validator->errors()->get('file')[0];
            $this->emitSelf('showErrorToast', $message);

            throw $e;
        }
    }
}


1			<?php
2
3			namespace PavelMironchik\LaravelBackupPanel\Http\Livewire;
4
5			use Illuminate\Http\Response;
6			use Illuminate\Support\Facades\Cache;
7			use Illuminate\Support\Facades\Validator;
8			use Illuminate\Validation\ValidationException;
9			use Livewire\Component;
10			use PavelMironchik\LaravelBackupPanel\Jobs\CreateBackupJob;
11			use PavelMironchik\LaravelBackupPanel\Rules\BackupDisk;
12			use PavelMironchik\LaravelBackupPanel\Rules\PathToZip;
13			use Spatie\Backup\BackupDestination\Backup;
14			use Spatie\Backup\BackupDestination\BackupDestination;
15			use Spatie\Backup\Helpers\Format;
16			use Spatie\Backup\Tasks\Monitor\BackupDestinationStatus;
17			use Spatie\Backup\Tasks\Monitor\BackupDestinationStatusFactory;
18			use Symfony\Component\HttpFoundation\StreamedResponse;
19
20			class App extends Component
21			{
22			public $backupStatuses = [];
23
24			public $activeDisk = null;
25
26			public $disks = [];
27
28			public $files = [];
29
30			public $deletingFile = null;
31
32			public function updateBackupStatuses()
33			{
34			$this->backupStatuses = Cache::remember('backup-statuses', now()->addSeconds(4), function () {
35			return BackupDestinationStatusFactory::createForMonitorConfig(config('backup.monitor_backups'))
36			->map(function (BackupDestinationStatus $backupDestinationStatus) {
37			return [
38			'name' => $backupDestinationStatus->backupDestination()->backupName(),
39			'disk' => $backupDestinationStatus->backupDestination()->diskName(),
40			'reachable' => $backupDestinationStatus->backupDestination()->isReachable(),
41			'healthy' => $backupDestinationStatus->isHealthy(),
42			'amount' => $backupDestinationStatus->backupDestination()->backups()->count(),
43			'newest' => $backupDestinationStatus->backupDestination()->newestBackup()
44			? $backupDestinationStatus->backupDestination()->newestBackup()->date()->diffForHumans()
45			: 'No backups present',
46			'usedStorage' => Format::humanReadableSize($backupDestinationStatus->backupDestination()->usedStorage()),
47			];
48			})
49			->values()
50			->toArray();
51			});
52
53			if (! $this->activeDisk and count($this->backupStatuses)) {
54			$this->activeDisk = $this->backupStatuses[0]['disk'];
55			}
56
57			$this->disks = collect($this->backupStatuses)
58			->map(function ($backupStatus) {
59			return $backupStatus['disk'];
60			})
61			->values()
62			->all();
63
64			$this->emitSelf('backupStatusesUpdated');
65			}
66
67			public function getFiles(string $disk = '')
68			{
69			if ($disk) {
70			$this->activeDisk = $disk;
71			}
72
73			$this->validateActiveDisk();
74
75			$backupDestination = BackupDestination::create($this->activeDisk, config('backup.backup.name'));
76
77			$this->files = Cache::remember("backups-{$this->activeDisk}", now()->addSeconds(4), function () use ($backupDestination) {
78			return $backupDestination
79			->backups()
80			->map(function (Backup $backup) {
81			return [
82			'path' => $backup->path(),
83			'date' => $backup->date()->format('Y-m-d H:i:s'),
84			'size' => Format::humanReadableSize($backup->size()),
85			];
86			})
87			->toArray();
88			});
89			}
90
91			public function showDeleteModal($fileIndex)
92			{
93			$this->deletingFile = $this->files[$fileIndex];
94
95			$this->emitSelf('showDeleteModal');
96			}
97
98			public function deleteFile()
99			{
100			$deletingFile = $this->deletingFile;
101			$this->deletingFile = null;
102
103			$this->emitSelf('hideDeleteModal');
104
105			$this->validateActiveDisk();
106			$this->validateFilePath($deletingFile ? $deletingFile['path'] : '');
107
108			$backupDestination = BackupDestination::create($this->activeDisk, config('backup.backup.name'));
109
110			$backupDestination
111			->backups()
112			->first(function (Backup $backup) use ($deletingFile) {
113			return $backup->path() === $deletingFile['path'];
114			})
115			->delete();
116
117			$this->files = collect($this->files)
118			->reject(function ($file) use ($deletingFile) {
119			return $file['path'] === $deletingFile['path']
120			&& $file['date'] === $deletingFile['date']
121			&& $file['size'] === $deletingFile['size'];
122			})
123			->values()
124			->all();
125			}
126
127			public function downloadFile(string $filePath)
128			{
129			$this->validateActiveDisk();
130			$this->validateFilePath($filePath);
131
132			$backupDestination = BackupDestination::create($this->activeDisk, config('backup.backup.name'));
133
134			$backup = $backupDestination->backups()->first(function (Backup $backup) use ($filePath) {
135			return $backup->path() === $filePath;
136			});
137
138			if (! $backup) {
139			return response('Backup not found', Response::HTTP_UNPROCESSABLE_ENTITY);
140			}
141
142			return $this->respondWithBackupStream($backup);
143			}
144
145			public function respondWithBackupStream(Backup $backup): StreamedResponse
146			{
147			$fileName = pathinfo($backup->path(), PATHINFO_BASENAME);
148
149			$downloadHeaders = [
150			'Cache-Control' => 'must-revalidate, post-check=0, pre-check=0',
151			'Content-Type' => 'application/zip',
152			'Content-Length' => $backup->size(),
153			'Content-Disposition' => 'attachment; filename="'.$fileName.'"',
154			'Pragma' => 'public',
155			];
156
157			return response()->stream(function () use ($backup) {
158			$stream = $backup->stream();
159
160			fpassthru($stream);
161
162			if (is_resource($stream)) {
163			fclose($stream);
164			}
165			}, 200, $downloadHeaders);
166			}
167
168			public function createBackup(string $option = '')
169			{
170			dispatch(new CreateBackupJob($option))
171			->onQueue(config('laravel_backup_panel.queue'));
172			}
173
174			public function render()
175			{
176			return view('laravel_backup_panel::livewire.app');
177			}
178
179			protected function validateActiveDisk()
180			{
181			try {
182			Validator::make(
183			['activeDisk' => $this->activeDisk],
184			[
185			'activeDisk' => ['required', new BackupDisk()],
186			],
187			[
188			'activeDisk.required' => 'Select a disk',
189			]
190			)->validate();
191			} catch (ValidationException $e) {
192			$message = $e->validator->errors()->get('activeDisk')[0];
193			$this->emitSelf('showErrorToast', $message);
194
195			throw $e;
196			}
197			}
198
199			protected function validateFilePath(string $filePath)
200			{
201			try {
202			Validator::make(
203			['file' => $filePath],
204			[
205			'file' => ['required', new PathToZip()],
206			],
207			[
208			'file.required' => 'Select a file',
209			]
210			)->validate();
211			} catch (ValidationException $e) {
212			$message = $e->validator->errors()->get('file')[0];
213			$this->emitSelf('showErrorToast', $message);
214
215			throw $e;
216			}
217			}
218			}
219

pavel-mironchik / laravel-backup-panel

Push — github-actions ( b5eae9 )

App::createBackup() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like