updateRun::copyFiles() - Code Metrics - Inspection of "Updated Update Command" - butcherman/Tech_Bench - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — dev5 ( a3bb6d...a23557 )

by Ron
created 2020-03-27 03:10 UTC
updateRun::copyFiles() A

↳ Parent: updateRun
Complexity

Conditions	1
Paths	1
Size

Total Lines	36
Code Lines	20
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	0
CRAP Score	2
Importance

Changes
Metric	Value
cc	1
eloc	20
c	0
b	0
f	0
nc	1
nop	1
dl	0
loc	36
ccs	0
cts	21
cp	0
crap	2
rs	9.6
<?php

namespace App\Console\Commands;

// use Doctrine\Common\Cache\Version;
use Zip;
use Illuminate\Console\Command;
use Illuminate\Support\Facades\Storage;
use Illuminate\Support\Arr;
use Illuminate\Support\Facades\File;

use PragmaRX\Version\Package\Version;


class updateRun extends Command
{
    /**
     * The name and signature of the console command.
     *
     * @var string
     */
    protected $signature = 'tb-update:run';

    /**
     * The console command description.
     *
     * @var string
     */
    protected $description = 'Update the Tech Bench to a newer version';

    /**
     * Create a new command instance.
     *
     * @return void
     */
    public function __construct()
    {
        parent::__construct();
    }

    /**
     * Execute the console command.
     *
     * @return mixed
     */
    public function handle()
    {
        $this->line('');
        //  Select which update file to use
        $updateFile = $this->checkForUpdate();
        if ($updateFile) {
            //  Open up the file and verify it is at least the same version as the current setup
            $valid = $this->openUpdate($updateFile);

            if ($valid) {
                $this->call('down');
                $this->copyFiles($updateFile);

                $this->info('Update Completed');
            } else {
                $this->error('The selected update is not a newer version');
                $this->error('Cannot downgrade Tech Bench in this manner');
            }
        }
    }

    //  Check to see if any backups are in the backup folder
    private function checkForUpdate()
    {
        $updateList = [];
        $updates    = Storage::disk('staging')->files('updates');

        //  Cycle through each file in the update directory to see if they are update files
        foreach ($updates as $update) {
            $baseName = explode('/', $update)[1];

            //  Verify the file is in the .zip format
            $fileParts = pathinfo($baseName);
            if ($fileParts['extension'] == 'zip') {
                //  Verify this is actually an update file
                $zip = Zip::open(config('filesystems.disks.staging.root') .
                    DIRECTORY_SEPARATOR . 'updates' . DIRECTORY_SEPARATOR . $baseName);
                $files = $zip->listFiles();
                if (in_array($fileParts['filename'] . '/config/version.yml', $files)) {
                    $updateList[] = $baseName;
                }
            }
        }

        if (empty($updateList)) {
            $this->error('No updates have been loaded to the system');
            $this->error('Please upload update package to the Storage/Staging/Updates folder');
            return false;
        }

        //  Determine if there is more than one update that can be applied
        if (count($updateList) > 1) {
            $this->line('');

            $anticipate = [];
            foreach ($updateList as $key => $up) {
                $opt = $key + 1;
                $anticipate[$opt] = $up;
                $this->line('[' . $opt . '] ' . $up);
            }
            $updateFile = $this->choice('Please select which update you would like to load', $anticipate);
        } else {
            $updateFile = $updateList[0];
        }

        return $updateFile;
    }

    //  Unzip the update and verify it is a newer or the same version
    private function openUpdate($file)
    {
        $fileParts = pathinfo($file);
        $folder = $fileParts['filename'];

        $zip = Zip::open(config('filesystems.disks.staging.root') .
            DIRECTORY_SEPARATOR . 'updates' . DIRECTORY_SEPARATOR . $file);

        $zip->extract(config('filesystems.disks.staging.root') .
            DIRECTORY_SEPARATOR . 'updates' . DIRECTORY_SEPARATOR . 'tmp');
        $zip->close();

        $verFile = fopen(config('filesystems.disks.staging.root') .
            DIRECTORY_SEPARATOR . 'updates' . DIRECTORY_SEPARATOR . 'tmp' .
            DIRECTORY_SEPARATOR . $folder . DIRECTORY_SEPARATOR . 'config' .
            DIRECTORY_SEPARATOR . 'version.yml', 'r');

        $verData = [];
        $i = 0;
        while (!feof($verFile)) {
        while (!feof(/** @scrutinizer ignore-type */ $verFile)) {
            $line = fgets($verFile);
            $line = fgets(/** @scrutinizer ignore-type */ $verFile);
            $data = explode(':', $line);

            if (($data[0] === '  major' || $data[0] === '  minor' || $data[0] === '  patch') && $i < 3) {
                $verData[trim($data[0])] = trim($data[1]);
                $i++;
            }
        }

        $curVersion = new \PragmaRX\Version\Package\Version();

        $valid = false;
        if ($verData['major'] > $curVersion->major()) {
            $valid = true;
        } else if ($verData['minor'] > $curVersion->minor()) {
            $valid = true;
        } else if ($verData['patch'] >= $curVersion->patch()) {
            $valid = true;
        }

        return $valid;
    }

    //  copy the update files to the proper folders
    private function copyFiles($updateFile)
    {
        $fileParts = pathinfo($updateFile);
        $folder = $fileParts['filename'];

        $updateFile = config('filesystems.disks.staging.root') .
            DIRECTORY_SEPARATOR . 'updates' . DIRECTORY_SEPARATOR . 'tmp' .
            DIRECTORY_SEPARATOR . $folder . DIRECTORY_SEPARATOR;

        // Copy files
        File::copyDirectory($updateFile . 'app',       base_path() . DIRECTORY_SEPARATOR . 'app');
        File::copyDirectory($updateFile . 'bootstrap', base_path() . DIRECTORY_SEPARATOR . 'bootstrap');
        File::copyDirectory($updateFile . 'config',    base_path() . DIRECTORY_SEPARATOR . 'config');
        File::copyDirectory($updateFile . 'database',  base_path() . DIRECTORY_SEPARATOR . 'database');
        File::copyDirectory($updateFile . 'resources', base_path() . DIRECTORY_SEPARATOR . 'resources');
        File::copyDirectory($updateFile . 'routes',    base_path() . DIRECTORY_SEPARATOR . 'routes');

        //  Run Composer Updates
        exec('cd ' . base_path() . ' && composer install --no-dev --no-interaction --optimize-autoloader --no-ansi');
        // exec('cd'.base_path().  ' && ziggy:generate');
        $this->call('ziggy:generate');
        //  Run NPM
        exec('cd'.base_path().' && npm install --only=production');
        exec('cd'.base_path().' && npm run production');

        //  Update the database
        $this->call('migrate', ['--force']);

        //  Update the cache
        $this->call('config:cache');
        $this->call('route:cache');

        //  Put the app back in working order
        $this->call('up');

        return true;
    }
}

butcherman / Tech_Bench

Push — dev5 ( a3bb6d...a23557 )

updateRun::copyFiles() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
