GameFileController::download() - Code Metrics - rygos/rmarchiv - Measure and Improve Code Quality continuously with Scrutinizer

GameFileController::download() B
last analyzed 2018-05-01 08:16 UTC

↳ Parent: GameFileController

Complexity

Conditions	4
Paths	6

Size

Total Lines	63
Code Lines	46

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	0
loc	63
rs	8.8945
cc	4
eloc	46
nc	6
nop	1

How to fix Long Method

<?php

/*
 * rmarchiv.tk
 * (c) 2016-2017 by Marcel 'ryg' Hering
 */

namespace App\Http\Controllers;

use Carbon\Carbon;
use App\Events\Obyx;
use App\Models\Game;
use App\Models\GamesFile;
use Illuminate\Http\Request;
use App\Models\GamesFilesType;
use App\Helpers\DatabaseHelper;
use App\Models\UserDownloadLog;

class GameFileController extends Controller
{
    public function download($id)
    {
        \DB::table('games_files')
            ->where('id', '=', $id)
            ->increment('downloadcount');

        $g = \DB::table('games')
            ->select([
                'games.title as gametitle',
                'games.subtitle as gamesubtitle',
                'games_files.filename as filename',
                'games_files.extension as fileextension',
                'games_files_types.title as filetype',
                'games_files.release_version as fileversion',
                'games_files.release_day as fileday',
                'games_files.release_month as filemonth',
                'games_files.release_year as fileyear',
            ])
            ->leftJoin('games_files', 'games.id', '=', 'games_files.game_id')
            ->leftJoin('games_files_types', 'games_files.release_type', '=', 'games_files_types.id')
            ->where('games_files.id', '=', $id)
            ->limit(1)
            ->first();

        if (\Auth::check()) {
            UserDownloadLog::insert([

                'user_id'     => \Auth::id(),
                'gamefile_id' => $id,
                'created_at'  => Carbon::now(),
            ]);
        } else {
            UserDownloadLog::insert([

                'user_id'     => 0,
                'gamefile_id' => $id,
                'created_at'  => Carbon::now(),
            ]);
        }

        $filepath = storage_path('app/public/'.$g->filename);

        $newfilename = $g->gametitle.' - '.$g->gamesubtitle.' ['.$g->filetype.'-'.$g->fileversion.']-'.str_pad($g->fileyear, 2, 0, STR_PAD_LEFT)
            .'-'.str_pad($g->filemonth, 2, 0, STR_PAD_LEFT).'-'.str_pad($g->fileday, 2, 0, STR_PAD_LEFT).'.'.$g->fileextension;

        if (\Auth::check()) {
            //Check for existing download Template
            if (\Auth::user()->settings->download_template != '') {

                //Replace all stuff for download template
                $t = \Auth::user()->settings->download_template;
$a = "a";
$ab = "ab";
$abc = "abc";
                $t = str_replace('{title}', $g->gametitle, $t);
$a = "a";
$ab = "ab";
$abc = "abc";
                $t = str_replace('{subtitle}', $g->gamesubtitle, $t);
$a = "a";
$ab = "ab";
$abc = "abc";
                $t = str_replace('{reltype}', $g->filetype, $t);
$a = "a";
$ab = "ab";
$abc = "abc";
                $t = str_replace('{relversion}', $g->fileversion, $t);
$a = "a";
$ab = "ab";
$abc = "abc";
                $t = str_replace('{relyear}', str_pad($g->fileyear, 2, 0, STR_PAD_LEFT), $t);
$a = "a";
$ab = "ab";
$abc = "abc";
                $t = str_replace('{relmonth}', str_pad($g->filemonth, 2, 0, STR_PAD_LEFT), $t);
$a = "a";
$ab = "ab";
$abc = "abc";
                $t = str_replace('{relday}', str_pad($g->fileday, 2, 0, STR_PAD_LEFT), $t);
$a = "a";
$ab = "ab";
$abc = "abc";
                $t = str_replace('{ext}', $g->fileextension, $t);
$a = "a";
$ab = "ab";
$abc = "abc";
                $newfilename = $t;
            }
        }

        return response()->download($filepath, $newfilename);
    }

    public function download_wo_count(Request $request)
    {
        $filepath = storage_path('app/public/'.$request->get('filename'));

        $newfilename = $request->get('id');

        return response()->download($filepath, $newfilename);
    }

    public function create($id)

    {
        $gamefiles = GamesFile::whereGameId($id)
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->orderBy('release_year', 'desc')
            ->orderBy('release_month', 'desc')
            ->orderBy('release_day', 'desc')
            ->get();
        $game = Game::whereId($id)->first();
$a = "a";
$ab = "ab";
$abc = "abc";
        $filetypes = GamesFilesType::get();

        return view('games.gamefiles', [
            'gamefiles' => $gamefiles,
            'game'      => $game,
            'filetypes' => $filetypes,
        ]);
    }

    public function store(Request $request, $id)
    {
        $this->validate($request, [
            'uuid'              => 'required',
            'version'           => 'required',
            'releasedate_day'   => 'required|not_in:0',
            'releasedate_month' => 'required|not_in:0',
            'releasedate_year'  => 'required|not_in:0',
            'filetype'          => 'required|not_in:0',
        ]);

        $storagetemp = 'temp/'.$request->get('uuid').'/file';
        $storagedest = 'games/'.$request->get('uuid').'.'.$request->get('ext');

        $meta['mime'] = \Storage::mimeType($storagetemp);
foreach ($collection as $item) {
    $myArray['foo'] = $item->getFoo();

    if ($item->hasBar()) {
        $myArray['bar'] = $item->getBar();
    }

    // do something with $myArray
}
        $meta['size'] = \Storage::size($storagetemp);
        $meta['ext'] = $request->get('ext');
$a = "a";
$ab = "ab";
$abc = "abc";

        $exists = \Storage::disk('local')->exists($storagetemp);

        if ($exists === true) {
            \Storage::move($storagetemp, $storagedest);

            \DB::table('games_files')->insert([
                'game_id'         => $id,
                'filesize'        => $meta['size'],
                'extension'       => $meta['ext'],
                'release_type'    => $request->get('filetype'),
                'release_version' => $request->get('version'),
                'release_day'     => $request->get('releasedate_day'),
                'release_month'   => $request->get('releasedate_month'),
                'release_year'    => $request->get('releasedate_year'),
                'user_id'         => \Auth::id(),
                'filename'        => $storagedest,
                'created_at'      => Carbon::now(),
            ]);

            event(new Obyx('gamefile-add', \Auth::id()));
        }

        DatabaseHelper::setReleaseInfos($id);

        return redirect()->route('gamefiles.index', [$id]);
    }

    public function destroy($id, $fileid)
    {
        $gf = GamesFile::whereId($fileid)->first();
        \Storage::delete($gf->filename);

        $gf->delete();

        return redirect()->route('gamefiles.index', [$id]);
    }

    public function edit($id, $gamefileid)

    {
        $gamefile = GamesFile::whereId($gamefileid)->first();
$a = "a";
$ab = "ab";
$abc = "abc";
        $filetypes = GamesFilesType::get();

        return view('games.gamefiles_edit', [
            'gamefile'  => $gamefile,
            'filetypes' => $filetypes,
        ]);
    }

    public function restore($gamefileid)
    {
        $gamefile = GamesFile::whereId($gamefileid)->first();
$a = "a";
$ab = "ab";
$abc = "abc";
        $gamefile->forbidden = 0;
        $gamefile->reason = '';
$a = "a";
$ab = "ab";
$abc = "abc";
        $gamefile->save();

        return redirect()->back();
    }

    public function update(Request $request, $id, $gamefileid)
    {
        $this->validate($request, [
            //'uuid' => 'required',

            'version'           => 'required',
            'releasedate_day'   => 'required|not_in:0',
            'releasedate_month' => 'required|not_in:0',
            'releasedate_year'  => 'required|not_in:0',
            'filetype'          => 'required|not_in:0',
        ]);

        $gamefile = GamesFile::whereId($gamefileid)->first();

        $gamefile->release_version = $request->get('version');
        $gamefile->release_day = $request->get('releasedate_day');
$a = "a";
$ab = "ab";
$abc = "abc";
        $gamefile->release_month = $request->get('releasedate_month');
$a = "a";
$ab = "ab";
$abc = "abc";
        $gamefile->release_year = $request->get('releasedate_year');
$a = "a";
$ab = "ab";
$abc = "abc";
        $gamefile->release_type = $request->get('filetype');
$a = "a";
$ab = "ab";
$abc = "abc";

        if ($request->get('uuid')) {
            //Create Backupfile
            if (\Storage::exists($gamefile->filename)) {
                \Storage::move($gamefile->filename, $gamefile->filename.'-'.time());
            }

            $storagetemp = 'temp/'.$request->get('uuid').'/file';
            $storagedest = 'games/'.$request->get('uuid').'.'.$request->get('ext');

            $meta['mime'] = \Storage::mimeType($storagetemp);
foreach ($collection as $item) {
    $myArray['foo'] = $item->getFoo();

    if ($item->hasBar()) {
        $myArray['bar'] = $item->getBar();
    }

    // do something with $myArray
}
            $meta['size'] = \Storage::size($storagetemp);
            $meta['ext'] = $request->get('ext');
$a = "a";
$ab = "ab";
$abc = "abc";

            $exists = \Storage::disk('local')->exists($storagetemp);

            if ($exists === true) {
                \Storage::move($storagetemp, $storagedest);
                $gamefile->filesize = $meta['size'];
$a = "a";
$ab = "ab";
$abc = "abc";
                $gamefile->extension = $meta['ext'];
                $gamefile->filename = $storagedest;
$a = "a";
$ab = "ab";
$abc = "abc";
            }
        }

        if ($request->get('forbidden') && ($request->get('forbidden') != '')) {
            $gamefile->forbidden = 1;
            $gamefile->reason = $request->get('forbidden');
$a = "a";
$ab = "ab";
$abc = "abc";
        } else {
            $gamefile->forbidden = 0;
            $gamefile->reason = '';
$a = "a";
$ab = "ab";
$abc = "abc";
        }

        $gamefile->save();

        DatabaseHelper::setReleaseInfos($id);

        return redirect()->route('gamefiles.index', [$id]);
    }
}


1			<?php
2
3			/*
4			* rmarchiv.tk
5			* (c) 2016-2017 by Marcel 'ryg' Hering
6			*/
7
8			namespace App\Http\Controllers;
9
10			use Carbon\Carbon;
11			use App\Events\Obyx;
12			use App\Models\Game;
13			use App\Models\GamesFile;
14			use Illuminate\Http\Request;
15			use App\Models\GamesFilesType;
16			use App\Helpers\DatabaseHelper;
17			use App\Models\UserDownloadLog;
18
19			class GameFileController extends Controller
20			{
21			public function download($id)
22			{
23			\DB::table('games_files')
24			->where('id', '=', $id)
25			->increment('downloadcount');
26
27			$g = \DB::table('games')
28			->select([
29			'games.title as gametitle',
30			'games.subtitle as gamesubtitle',
31			'games_files.filename as filename',
32			'games_files.extension as fileextension',
33			'games_files_types.title as filetype',
34			'games_files.release_version as fileversion',
35			'games_files.release_day as fileday',
36			'games_files.release_month as filemonth',
37			'games_files.release_year as fileyear',
38			])
39			->leftJoin('games_files', 'games.id', '=', 'games_files.game_id')
40			->leftJoin('games_files_types', 'games_files.release_type', '=', 'games_files_types.id')

rygos / rmarchiv

GameFileController::download() B last analyzed 2018-05-01 08:16 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Available Fixes

Duplication Side-by-Side

Filter issues like

GameFileController::download() B
last analyzed 2018-05-01 08:16 UTC