DatabaseCheck::systemFiles() - Code Metrics - Inspection of "Dev4" - butcherman/Tech_Bench - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Pull Request — master (#61)

by Ron
created 2018-12-28 05:45 UTC
DatabaseCheck::systemFiles() B

↳ Parent: DatabaseCheck
Complexity

Conditions	10
Paths	54
Size

Total Lines	101
Code Lines	56
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	10
eloc	56
nc	54
nop	0
dl	0
loc	101
rs	7.0933
c	0
b	0
f	0
How to fix Long Method Complexity

<?php

namespace App\Console\Commands;

use Carbon\Carbon;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\File;
use Illuminate\Support\Facades\Storage;
use Illuminate\Console\Command;
use App\Files;
use App\User;
use App\UserSettings;
use App\UserInitialize;
use App\SystemFiles;
use App\CustomerFiles;
use App\FileLinkFiles;
use App\TechTipFiles;

class DatabaseCheck extends Command
{
    //  Command Name
    protected $signature = 'dbcheck 
                            {--fix : Automatically fix any issues that arrise} 
                            {--report : Place all results in a downloadable PDF}';

    //  Command description
    protected $description = 'Verify database and file structure matches';
    
    //  Report Data
    protected $repData, $fix, $rep;
    protected $fileArr = [];

    //  Constructor
    public function __construct()
    {
        parent::__construct();
    }

    //  Run the DB Check
    public function handle()
    {
        //  Shortcut for options being on or off
        $this->fix = $this->option('fix');
        $this->rep = $this->option('report');
        $brk = '<br />';

        
        $today = Carbon::now();
        
        //  Extend the Max Execution time for the script
        ini_set('max_execution_time', 600); //600 seconds = 10 minutes
        
        $this->line('Running DB Check...');
        $this->line('');
        
        $this->repData  = "***********************************************************\n";
        $this->repData .= "*                                                         *\n";
        $this->repData .= "*               Database Report $today->year-$today->month-$today->day                *\n";
        $this->repData .= "*                                                         *\n";
        $this->repData .= "***********************************************************\n\n";
        
        /*****************************
        *                            *
        *  User Portion of DB Check  *
        *                            *
        ******************************/
        //  List all system administrators
        $admins = $this->getAdmins();
        $this->output($admins);
        
        //  Count both active and non active users
        $users = $this->countUsers();
        $this->output($users);
        
        //  Make sure all users have a settings table
        $settings = $this->userSettings();
        $this->output($settings);
        
        //  Check for active User Initialization links
        $links = $this->initializationLinks();
        $this->output($links);
        
        /*****************************
        *                            *
        *  File Portion of DB Check  *
        *                            *
        ******************************/
        //  Get all of the files in the file table
        $this->fileArr = $this->getFiles();
        
        //  Check for system files that are in the files table but missing actual file
        $sysFiles = $this->systemFiles();
        $this->output($sysFiles);
        
        //  Check for customer files that are in the files table but missing the actual file
        $custFiles = $this->customerFiles();
        $this->output($custFiles);
        
        //  Check for file link files that are in the files table but missing the actual file
        $linkFiles = $this->linkFiles();
        $this->output($linkFiles);
        
        //  Check for tech tip files that are in the files table but missing the actual file
        $tipFiles = $this->tipFiles();
        $this->output($tipFiles);
        
        //  For all remaining files in 'files' table - verify file exists
        $remainingFiles = $this->remainingFiles();
        $this->output($remainingFiles);
        
        //  Determine any rogue files
        $rogueFiles = $this->rogueFiles();
        $this->output($rogueFiles);

        /*****************************
        *                            *
        *  Wrap up                   *
        *                            *
        ******************************/
        $output = [];
        $output[] = [
            'type' => 'info',
            'value' => 'Database Report Completed'
        ];
        
        $this->output($output);
        
        //  Generate a PDF report if the option is selected
        if($this->rep)
        {
            Storage::disk('logs')->append('dbCheck-'.$today->year.'-'.$today->month.'-'.$today->day.'.log', $this->repData);
        }
    }
    
    //  Print the output to the screen and write for PDF report
    private function output($data)
    {   
        foreach($data as $d)
        {
            //  Console Output
            if(!isset($d['repOnly']))
            {
                $type = $d['type'];
                $this->$type($d['value']);
            }
            
            //  Report Output
            $this->repData .= $d['value']."\n";
        }
        
        //  Line Break
        $this->line('');
        $this->repData .= "\n";
    }
    
    //  List all system administrators
    private function getAdmins()
    {
        $res = [];
        
        $admins = User::where('active', 1)
            ->join('user_role', 'users.user_id', '=', 'user_role.user_id')
            ->where('user_role.role_id', '<=', 2)
            ->get();
        
        $res[] = [ 'type' => 'info', 'value' => 'System Administrators ('.count($admins).')'];
        foreach($admins as $admin)
        {
            $res[] = [
                'type' => 'line', 'value' => '     '.$admin->first_name.' '.$admin->last_name
            ];
        }
        
        return $res;
    }
    
    //  Count active and non-active users
    private function countUsers()
    {
        $res = [];
        
        $activeUsers = User::where('active', 1)->count();
        $inactiveUsr = User::where('active', 0)->count();
        
        $res[] = [
            'type'  => 'line',
            'value' => 'Active Users.................................'.$activeUsers
            'value' => 'Active Users.................................'./** @scrutinizer ignore-type */ $activeUsers
        ];
        $res[] = [
            'type'  => 'line',
            'value' => 'Inactive Users...............................'.$inactiveUsr
            'value' => 'Inactive Users...............................'./** @scrutinizer ignore-type */ $inactiveUsr
        ];
        
        return $res;
    }
    
    //  Verify all users have a settings table
    private function userSettings()
    {
        $res = [];
        
        $users    = User::all();
        $settings = UserSettings::all();
        
        $failedItems = [];
        foreach($users as $user)
        {
            $match = false;
            foreach($settings as $setting)
            {
                if($user->user_id == $setting->user_id)
                {
                    $match = true;
                    break;
                }
            }
            
            if(!$match)
            {
                $failedItems[] = [
                    'user_id' => $user->user_id,
                    'name'    => $user->first_name.' '.$user->last_name
                ];
            }
        }
        
        if($failedItems)
        {
            $res[] = [
                'type'  => 'error',
                'value' => count($failedItems).' user(s) missing settings information'
            ];
            
            foreach($failedItems as $item)
            {
                $res[] = [
                    'type' => 'line',
                    'value' => '     User ID - '.$item['user_id'].'-'.$item['name']
                ];
                
                if($this->fix)
                {
                    UserSettings::create([
                        'user_id' => $item['user_id']
                    ]);
                    
                    $res[] = [
                        'type'  => 'info',
                        'value' => '          corrected'
                    ];
                }
            }
        }
        
        return $res;
    }
    
    //  Verify User Initialization links
    private function initializationLinks()
    {
        $res = [];
        
        $initLinks = UserInitialize::all();
        
        $links = [];
        $over  = [];
        if(!empty($initLinks))
        {
            //  List each expired link
            foreach($initLinks as $link)
            {
                $links[] = [
                    'username' => $link->username,
                    'age'      => $link->created_at->diffInDays(Carbon::now())
                ];
                
                //  See if the link is more than two weeks old
                if($link->created_at->diffInDays(Carbon::now()) > 14)
                {
                    $over[] = [
                        'username' => $link->username,
                        'age'      => $link->created_at->diffInDays(Carbon::now())
                    ];
                }
            }
            
            $res[] = [
                'type' => 'line',
                'value' => count($links).' Users are awaiting to be initialized'
            ];
            
            if(!empty($over))
            {
               foreach($over as $ov)
               {
                   $res[] = [
                       'type'  => 'error',
                       'value' => '     Link for '.$ov['username'].' is '.$ov['age'].' days old'
                   ];
                   
                   if($this->fix)
                   {
                       UserInitialize::where('username', $ov['username'])->delete();
                       $res[] = [
                           'type'  => 'info',
                           'value' => '          Corrected'
                       ];
                   }
               }
            }
        }
        
        return $res;
    }
    
    //  Get all of the files in the "Files" table
    private function getFiles()
    {
        $files = Files::all();
        
        $fileArr = [];
        foreach($files as $f)
        {
            $fileArr[] = $f->file_id;
        }
        
        return $fileArr;
    }
    
    //  Check that all system files exist
    private function systemFiles()
    {
        $res = [];
        $res2 = [];
		
        $badPointer  = 0;
        $missingFile = 0;
        
        $sysFiles = SystemFiles::all();
        
        $res[] = [
            'type'  => 'line',
            'value' => 'System Files......................'.count($sysFiles)
        ];
        
        //  Verify all files have a database pointer and a valid file
        foreach($sysFiles as $file)
        {
            //  Verify database pointer
            if(!in_array($file->file_id, $this->fileArr))
            {
                $badPointer++;
                $res2[] = [
                    'type'    => 'error',
                    'value'   => '          File ID '.$file->file_id.' missing in files table',
                    'repOnly' => true
                ];
                
                if($this->fix)
                {
                    SystemFiles::find($file->sys_file_id)->delete();
                    $res2[] = [
                        'type'    => 'info',
                        'value'   => '               Corrected',
                        'repOnly' => true
                    ];
                }
            }
            else
            {
                //  Verify that the file exists
                $fileData = Files::find($file->file_id);
                if(!Storage::exists($fileData->file_link.$fileData->file_name))
                {
                    $missingFile++;
                    $res2[] = [
                        'type'    => 'error',
                        'value'   => '          Missing File ID - '.$fileData->file_id.' - '.$fileData->file_link.$fileData->file_name,
                        'repOnly' => true
                    ];

                    if($this->fix)
                    {
                        $file->delete();
                        $fileData->delete();
                        $res2[] = [
                            'type'    => 'info',
                            'value'   => '               Corrected',
                            'repOnly' => true
                        ];
                    }
                }
                
                $pos = array_search($file->file_id, $this->fileArr);
                unset($this->fileArr[$pos]);
            } 
        }
        
        //  Error messages if pointer bad or file missing
        if($badPointer)
        {
            $res[] = [
                'type' => 'error',
                'value' => '     Bad file pointers............'.$badPointer
            ];
            if($this->fix)
            {
                $res[] = [
                    'type'  => 'info',
                    'value' => '          Corrected'
                ];
            }
        }
        if($missingFile)
        {
            $res[] = [
                'type' => 'error',
                'value' => '     Missing Files................'.$missingFile
            ];
            if($this->fix)
            {
                $res[] = [
                    'type'  => 'info',
                    'value' => '          Corrected'
                ];
            }
        }
		
		$res = array_merge($res, $res2);
        
        return $res;
    }
    
    //  Check that all customer files exist
    private function customerFiles()
    {
        $res = [];
		$res2 = [];
        
        $badPointer  = 0;
        $missingFile = 0;
        
        $custFiles = CustomerFiles::all();
        
        $res[] = [
            'type'  => 'line',
            'value' => 'Customer Files....................'.count($custFiles)
        ];
        
        //  Verify all files have a database pointer and a valid file
        foreach($custFiles as $file)
        {
            //  Verify database pointer
            if(!in_array($file->file_id, $this->fileArr))
            {
                $badPointer++;
                $res2[] = [
                    'type'    => 'error',
                    'value'   => '          File ID '.$file->file_id.' missing in files table',
                    'repOnly' => true
                ];
                
                if($this->fix)
                {
                    CustomerFiles::find($file->cust_file_id)->delete();
                    $res2[] = [
                        'type'    => 'info',
                        'value'   => '               Corrected',
                        'repOnly' => true
                    ];
                }
            }
            else
            {
                //  Verify that the file exists
                $fileData = Files::find($file->file_id);
                if(!Storage::exists($fileData->file_link.$fileData->file_name))
                {
                    $missingFile++;
                    $res2[] = [
                        'type'    => 'error',
                        'value'   => '          Missing File ID - '.$fileData->file_id.' - '.$fileData->file_link.$fileData->file_name,
                        'repOnly' => true
                    ];

                    if($this->fix)
                    {
                        $file->delete();
                        $fileData->delete();
                        $res2[] = [
                            'type'    => 'info',
                            'value'   => '               Corrected',
                            'repOnly' => true
                        ];
                    }
                }
                $pos = array_search($file->file_id, $this->fileArr);
                unset($this->fileArr[$pos]);
            } 
        }
        
        //  Error messages if pointer bad or file missing
        if($badPointer)
        {
            $res[] = [
                'type' => 'error',
                'value' => '     Bad file pointers............'.$badPointer
            ];
            if($this->fix)
            {
                $res[] = [
                    'type'  => 'info',
                    'value' => '          Corrected'
                ];
            }
        }
        if($missingFile)
        {
            $res[] = [
                'type' => 'error',
                'value' => '     Missing Files................'.$missingFile
            ];
            if($this->fix)
            {
                $res[] = [
                    'type'  => 'info',
                    'value' => '          Corrected'
                ];
            }
        }
		
		$res = array_merge($res, $res2);
        
        return $res;
    }
    
    //  Check that all file link files exist
    private function linkFiles()
    {
        $res = [];
		$res2 = [];
        
        $badPointer  = 0;
        $missingFile = 0;
        
        $linkFiles = FileLinkFiles::all();
        
        $res[] = [
            'type'  => 'line',
            'value' => 'File Link Files...................'.count($linkFiles)
        ];
        
        //  Verify all files have a database pointer and a valid file
        foreach($linkFiles as $file)
        {
            //  Verify database pointer
            if(!in_array($file->file_id, $this->fileArr))
            {
                $badPointer++;
                $res2[] = [
                    'type'    => 'error',
                    'value'   => '          File ID '.$file->file_id.' missing in files table',
                    'repOnly' => true
                ];
                
                if($this->fix)
                {
                    FileLinkFiles::find($file->cust_file_id)->delete();
                    $res2[] = [
                        'type'    => 'info',
                        'value'   => '               Corrected',
                        'repOnly' => true
                    ];
                }
            }
            else
            {
                //  Verify that the file exists
                $fileData = Files::find($file->file_id);
                if(!Storage::exists($fileData->file_link.$fileData->file_name))
                {
                    $missingFile++;
                    $res2[] = [
                        'type'    => 'error',
                        'value'   => '          Missing File ID - '.$fileData->file_id.' - '.$fileData->file_link.$fileData->file_name,
                        'repOnly' => true
                    ];

                    if($this->fix)
                    {
                        $file->delete();
                        $fileData->delete();
                        $res2[] = [
                            'type'    => 'info',
                            'value'   => '               Corrected',
                            'repOnly' => true
                        ];
                    }
                }
                $pos = array_search($file->file_id, $this->fileArr);
                unset($this->fileArr[$pos]);
            } 
        }
        
        //  Error messages if pointer bad or file missing
        if($badPointer)
        {
            $res[] = [
                'type' => 'error',
                'value' => '     Bad file pointers............'.$badPointer
            ];
            if($this->fix)
            {
                $res[] = [
                    'type'  => 'info',
                    'value' => '          Corrected'
                ];
            }
        }
        if($missingFile)
        {
            $res[] = [
                'type' => 'error',
                'value' => '     Missing Files................'.$missingFile
            ];
            if($this->fix)
            {
                $res[] = [
                    'type'  => 'info',
                    'value' => '          Corrected'
                ];
            }
        }
		
		$res = array_merge($res, $res2);
        
        return $res;
    }
    
    //  Check that all tech tip files exist
    private function tipFiles()
    {
        $res = [];
		$res2 = [];
        
        $badPointer  = 0;
        $missingFile = 0;
        
        $tipFiles = TechTipFiles::all();
        
        $res[] = [
            'type'  => 'line',
            'value' => 'Tech Tip Files....................'.count($tipFiles)
        ];
        
        //  Verify all files have a database pointer and a valid file
        foreach($tipFiles as $file)
        {
            //  Verify database pointer
            if(!in_array($file->file_id, $this->fileArr))
            {
                $badPointer++;
                $res2[] = [
                    'type'    => 'error',
                    'value'   => '          File ID '.$file->file_id.' missing in files table',
                    'repOnly' => true
                ];
                
                if($this->fix)
                {
                    TechTipFiles::find($file->cust_file_id)->delete();
                    $res2[] = [
                        'type'    => 'info',
                        'value'   => '               Corrected',
                        'repOnly' => true
                    ];
                }
            }
            else
            {
                //  Verify that the file exists
                $fileData = Files::find($file->file_id);
                if(!Storage::exists($fileData->file_link.$fileData->file_name))
                {
                    $missingFile++;
                    $res2[] = [
                        'type'    => 'error',
                        'value'   => '          Missing File ID - '.$fileData->file_id.' - '.$fileData->file_link.$fileData->file_name,
                        'repOnly' => true
                    ];

                    if($this->fix)
                    {
                        $file->delete();
                        $fileData->delete();
                        $res2[] = [
                            'type'    => 'info',
                            'value'   => '               Corrected',
                            'repOnly' => true
                        ];
                    }
                }
                $pos = array_search($file->file_id, $this->fileArr);
                unset($this->fileArr[$pos]);
            } 
        }
        
        //  Error messages if pointer bad or file missing
        if($badPointer)
        {
            $res[] = [
                'type' => 'error',
                'value' => '     Bad file pointers............'.$badPointer
            ];
            if($this->fix)
            {
                $res[] = [
                    'type'  => 'info',
                    'value' => '          Corrected'
                ];
            }
        }
        if($missingFile)
        {
            $res[] = [
                'type' => 'error',
                'value' => '     Missing Files................'.$missingFile
            ];
            if($this->fix)
            {
                $res[] = [
                    'type'  => 'info',
                    'value' => '          Corrected'
                ];
            }
        }
		
		$res = array_merge($res, $res2);
        
        return $res;
    }
    
    //  Check all remaining file in database that do not have pointers
    private function remainingFiles()
    {
        $res = [];
        
        $res[] = [
            'type' => count($this->fileArr) > 0 ? 'error' : 'line',
            'value' => 'Unknown Files.....................'.count($this->fileArr)
        ];
		
		if(count($this->fileArr) > 0)
		{
			foreach($this->fileArr as $file)
			{
				$fileData = Files::find($file);
				
				$res[] = [
					'type' => 'line',
					'value' => '     Unknown File ID - '.$fileData->file_id.' - '.$fileData->file_link.$fileData->file_name,
					'repOnly' => true
				];
				
				if($this->fix)
				{
					$res[] = [
						'type' => 'info',
						'value' => '          Corrected',
                        'repOnly' => true
					];

					if(!Storage::exists($fileData->file_link.$fileData->file_name))
					{
						Storage::delete($fileData->file_link.$fileData->file_name);
					}
					
					$fileData->delete();
					
				}
			}
		}
		
		
/*		
        
        if($this->fix  && count($this->fileArr) > 0)
        {
            $res[] = [
                'type' => 'info',
                'value' => '          Corrected'
            ];
            foreach($this->fileArr as $file)
            {
                $fileData = Files::find($file);
                
                if(!Storage::exists($fileData->file_link.$fileData->file_name))
                {
                    Storage::delete($fileData->file_link.$fileData->file_name);
                }
                
                $res[] = [
                    'type'    => 'info',
                    'value'   => '     File - '.$fileData->file_link.$fileData->file_name.' deleted',
                    'repOnly' => true
                ];
                
                $fileData->delete();
            }
        }
*/
        
        return $res;
    }
    
    //  Determine any rogue files that exist but are not in the database
    private function rogueFiles()
    {
        $res = [];
        
		$allFiles = File::allFiles(config('filesystems.disks.local.root'));
        
        foreach($allFiles as $pos => $file)
        {
            $dbFile = Files::where('file_name', basename($file))->get();
                        
            if(!$dbFile->isEmpty())
            {
                unset($allFiles[$pos]);
            }
        }
        
        $res[] = [
            'type'  => count($allFiles) > 0 ? 'error' : 'line',
            'value' => 'Rogue Files.......................'.count($allFiles)
        ];
        
        if($this->fix && count($allFiles) > 0)
        {
            $res[] = [
                'type' => 'info',
                'value' => '          Corrected'
            ];
        }
        
        if(count($allFiles) > 0)
        {
            foreach($allFiles as $file)
            {
                $res[] = [
                    'type'    => 'info',
                    'value'   => '     '.$file,
                    'repOnly' => true
                ];
                
                if($this->fix)
                {
                    Storage::delete($file);
                    $res[] = [
                        'type'    => 'info',
                        'value'   => '          Corrected',
                        'repOnly' => true
                    ];
                }
            }
        }
        
        return $res;
    }
}

butcherman / Tech_Bench

Pull Request — master (#61)

DatabaseCheck::systemFiles() B

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like
