Championship::category() - Code Metrics - Inspection of "change chooseGenerationStrategy to Championship" - xoco70/laravel-tournaments - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( d98836...b20032 )

by Julien

created 2017-05-12 03:18 UTC

Championship::category() A

↳ Parent: Championship

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php

namespace Xoco70\KendoTournaments\Models;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\HasMany;
use Illuminate\Database\Eloquent\SoftDeletes;
use Illuminate\Foundation\Auth\User;
use Xoco70\KendoTournaments\Contracts\TreeGenerable;
use Xoco70\KendoTournaments\TreeGen\DirectEliminationCompetitorTreeGen;
use Xoco70\KendoTournaments\TreeGen\DirectEliminationTeamTreeGen;
use Xoco70\KendoTournaments\TreeGen\PlayOffCompetitorTreeGen;
use Xoco70\KendoTournaments\TreeGen\PlayOffTeamTreeGen;
use Xoco70\KendoTournaments\TreeGen\TreeGen;

class Championship extends Model
{
    use SoftDeletes;
    protected $dates = ['created_at', 'updated_at', 'deleted_at'];
    protected $table = 'championship';

    public $timestamps = true;
    protected $fillable = [
        'tournament_id',
        'category_id',
    ];

    protected static function boot()
    {
        parent::boot();

        static::deleting(function ($championship) {
            $championship->competitors()->delete();
            $championship->settings()->delete();
        });
        static::restoring(function ($championship) {
            $championship->competitors()->restore();
            $championship->settings()->restore();
        });
    }

    /**
     * A championship has many Competitors.
     *
     * @return \Illuminate\Database\Eloquent\Relations\HasMany
     */
    public function competitors()
    {
        return $this->hasMany(Competitor::class);
    }

    /**
     * A championship belongs to a Category.
     *
     * @return \Illuminate\Database\Eloquent\Relations\BelongsTo
     */
    public function category()
    {
        return $this->belongsTo(Category::class);
    }

    /**
     * A championship belongs to a Tournament.
     *
     * @return \Illuminate\Database\Eloquent\Relations\BelongsTo
     */
    public function tournament()
    {
        return $this->belongsTo(Tournament::class);
    }

    /**
     * Get All competitors from a Championships.
     *
     * @return \Illuminate\Database\Eloquent\Relations\BelongsToMany
     */
    public function users()
    {
        return $this->belongsToMany(User::class, 'competitor', 'championship_id')
            ->withPivot('confirmed')
            ->withTimestamps();
    }

    /**
     * A championship only has 1 Settings.
     *
     * @return \Illuminate\Database\Eloquent\Relations\HasOne
     */
    public function settings()
    {
        return $this->hasOne(ChampionshipSettings::class);
    }

    /**
     * A championship has Many Teams.
     *
     * @return \Illuminate\Database\Eloquent\Relations\HasMany
     */
    public function teams()
    {
        return $this->hasMany(Team::class);
    }

    /**
     * Check if Championship has Preliminary Round Configured.
     *
     * @return bool
     */
    public function hasPreliminary()
    {
        return $this->settings == null || $this->settings->hasPreliminary;
    }

    /**
     * Check if 2nd Round of Championship is Round Robin.
     *
     * @return bool
     */
    public function isPlayOffType()
    {
        return $this->settings != null && $this->settings->treeType == ChampionshipSettings::PLAY_OFF;
    }

    /**
     * Check if 2nd Round of Championship is Direct Elimination.
     *
     * @return bool
     */
    public function isDirectEliminationType()
    {
        return $this->settings != null && $this->settings->treeType == ChampionshipSettings::DIRECT_ELIMINATION;
    }

    /**
     * A championship has Many Groups of Fighters.
     *
     * @return \Illuminate\Database\Eloquent\Relations\HasMany
     */
    public function fightersGroups()
    {
        return $this->hasMany(FightersGroup::class);
    }

    /**
     * A championship has Many fights.
     *
     * @return \Illuminate\Database\Eloquent\Relations\HasManyThrough
     */
    public function fights()
    {
        return $this->hasManyThrough(Fight::class, FightersGroup::class);
    }

    /**
     * Get the fights that happen to the first round
     * @return \Illuminate\Database\Eloquent\Relations\HasManyThrough
     */
    public function firstRoundFights()
    {
        return $this->hasManyThrough(Fight::class, FightersGroup::class)
            ->where('fighters_groups.round', 1)
            ->orderby('fighters_groups.id', 'desc');
    }

    private function hasNoCustomSettings()
    {
        return
            $this->settings == null ||
            ($this->settings->ageCategory == null || $this->settings->ageCategory == 0) &&
            $this->settings->ageMin == null &&
            $this->settings->ageMax == null &&
            $this->settings->gradeMin == null &&
            $this->settings->gradeMax == null &&
            ($this->settings->gradeCategory == null || $this->settings->gradeCategory == 0);
    }

    public function buildName()
    {
        if ($this->settings != null && $this->settings->alias != null && $this->settings->alias != '')
            return $this->settings->alias;

        if ($this->hasNoCustomSettings()) {
            return $this->category->name;
        }

        $genders = [
            'M' => trans('categories.male'),
            'F' => trans('categories.female'),
            'X' => trans('categories.mixt')
        ];

        $teamText = $this->category->isTeam == 1 ? trans_choice('core.team', 1) : trans('categories.single');
        $ageCategoryText = $this->category->getAgeString();
        $gradeText = $this->category->getGradeString();

        return $teamText . ' ' . $genders[$this->category->gender] . ' ' . $ageCategoryText . ' ' . $gradeText;
    }

    public function getSettings()
    {
        return $setting = $this->settings ?? new ChampionshipSettings(ChampionshipSettings::DEFAULT_SETTINGS);
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
    }

    /**
     * Return Groups that belongs to a round
     * @param integer $round
     * @return HasMany
     */
    public function groupsByRound($round)
    {
        return $this->fightersGroups()->where('round', $round);
    }

    /**
     * Return Fights that belongs to a round
     *
     * @param integer $round
     * @return \Illuminate\Database\Eloquent\Relations\HasManyThrough
     */
    public function fightsByRound($round)
    {
        return $this->hasManyThrough(Fight::class, FightersGroup::class)->where('round', $round);
    }

    public function isPlayoffCompetitor()
    {
        return !$this->category->isTeam() &&
            ($this->isPlayOffType() || $this->hasPreliminary());
    }

    public function isPlayoffTeam()
    {
        return $this->category->isTeam() &&
            ($this->isPlayOffType() || $this->hasPreliminary());
    }

    public function isDirectEliminationCompetitor()
    {
        return !$this->category->isTeam() && $this->isDirectEliminationType() && !$this->hasPreliminary();
    }

    public function isDirectEliminationTeam()
    {
        return $this->category->isTeam() && $this->isDirectEliminationType() && !$this->hasPreliminary();
    }

    /**
     * @return TreeGenerable
     */
    public function chooseGenerationStrategy()
    {
        $generation = new TreeGen($this, null);
        switch (true) {
            case $this->isDirectEliminationCompetitor():
switch ($expr) {
    case "A": { //wrong
        doSomething();
        break;
    }
    case "B"; //wrong
        doSomething();
        break;
    case "C": //right
        doSomething();
        break;
}
                $generation = new DirectEliminationCompetitorTreeGen($this, null);
                break;
            case $this->isDirectEliminationTeam():
switch ($expr) {
    case "A": { //wrong
        doSomething();
        break;
    }
    case "B"; //wrong
        doSomething();
        break;
    case "C": //right
        doSomething();
        break;
}
                $generation = new DirectEliminationTeamTreeGen($this, null);
                break;
            case $this->isPlayoffCompetitor():
                $generation = new PlayOffCompetitorTreeGen($this, null);
                break;
            case $this->isPlayoffTeam():
                $generation = new PlayOffTeamTreeGen($this, null);
                break;
            default:
                dd("bad choice");
        }
        return $generation;
    }

}


1			<?php
2
3			namespace Xoco70\KendoTournaments\Models;
4
5			use Illuminate\Database\Eloquent\Model;
6			use Illuminate\Database\Eloquent\Relations\HasMany;
7			use Illuminate\Database\Eloquent\SoftDeletes;
8			use Illuminate\Foundation\Auth\User;
9			use Xoco70\KendoTournaments\Contracts\TreeGenerable;
10			use Xoco70\KendoTournaments\TreeGen\DirectEliminationCompetitorTreeGen;
11			use Xoco70\KendoTournaments\TreeGen\DirectEliminationTeamTreeGen;
12			use Xoco70\KendoTournaments\TreeGen\PlayOffCompetitorTreeGen;
13			use Xoco70\KendoTournaments\TreeGen\PlayOffTeamTreeGen;
14			use Xoco70\KendoTournaments\TreeGen\TreeGen;
15
16			class Championship extends Model
17			{
18			use SoftDeletes;
19			protected $dates = ['created_at', 'updated_at', 'deleted_at'];
20			protected $table = 'championship';
21
22			public $timestamps = true;
23			protected $fillable = [
24			'tournament_id',
25			'category_id',
26			];
27
28			protected static function boot()
29			{
30			parent::boot();
31
32			static::deleting(function ($championship) {
33			$championship->competitors()->delete();
34			$championship->settings()->delete();
35			});
36			static::restoring(function ($championship) {
37			$championship->competitors()->restore();
38			$championship->settings()->restore();
39			});
40			}
41
42			/**
43			* A championship has many Competitors.
44			*
45			* @return \Illuminate\Database\Eloquent\Relations\HasMany
46			*/
47			public function competitors()
48			{
49			return $this->hasMany(Competitor::class);
50			}
51
52			/**
53			* A championship belongs to a Category.
54			*
55			* @return \Illuminate\Database\Eloquent\Relations\BelongsTo
56			*/
57			public function category()
58			{
59			return $this->belongsTo(Category::class);
60			}
61
62			/**
63			* A championship belongs to a Tournament.
64			*
65			* @return \Illuminate\Database\Eloquent\Relations\BelongsTo
66			*/
67			public function tournament()
68			{
69			return $this->belongsTo(Tournament::class);
70			}
71
72			/**
73			* Get All competitors from a Championships.
74			*
75			* @return \Illuminate\Database\Eloquent\Relations\BelongsToMany
76			*/
77			public function users()
78			{
79			return $this->belongsToMany(User::class, 'competitor', 'championship_id')
80			->withPivot('confirmed')
81			->withTimestamps();
82			}
83
84			/**
85			* A championship only has 1 Settings.
86			*
87			* @return \Illuminate\Database\Eloquent\Relations\HasOne
88			*/
89			public function settings()
90			{
91			return $this->hasOne(ChampionshipSettings::class);
92			}
93
94			/**
95			* A championship has Many Teams.
96			*
97			* @return \Illuminate\Database\Eloquent\Relations\HasMany
98			*/
99			public function teams()
100			{
101			return $this->hasMany(Team::class);
102			}
103
104			/**
105			* Check if Championship has Preliminary Round Configured.
106			*
107			* @return bool
108			*/
109			public function hasPreliminary()
110			{
111			return $this->settings == null \|\| $this->settings->hasPreliminary;
112			}
113
114			/**
115			* Check if 2nd Round of Championship is Round Robin.
116			*
117			* @return bool
118			*/
119			public function isPlayOffType()
120			{
121			return $this->settings != null && $this->settings->treeType == ChampionshipSettings::PLAY_OFF;
122			}
123
124			/**
125			* Check if 2nd Round of Championship is Direct Elimination.
126			*
127			* @return bool
128			*/
129			public function isDirectEliminationType()
130			{
131			return $this->settings != null && $this->settings->treeType == ChampionshipSettings::DIRECT_ELIMINATION;
132			}
133
134			/**
135			* A championship has Many Groups of Fighters.
136			*
137			* @return \Illuminate\Database\Eloquent\Relations\HasMany
138			*/
139			public function fightersGroups()
140			{
141			return $this->hasMany(FightersGroup::class);
142			}
143
144			/**
145			* A championship has Many fights.
146			*
147			* @return \Illuminate\Database\Eloquent\Relations\HasManyThrough
148			*/
149			public function fights()
150			{
151			return $this->hasManyThrough(Fight::class, FightersGroup::class);
152			}
153
154			/**
155			* Get the fights that happen to the first round
156			* @return \Illuminate\Database\Eloquent\Relations\HasManyThrough
157			*/
158			public function firstRoundFights()
159			{
160			return $this->hasManyThrough(Fight::class, FightersGroup::class)
161			->where('fighters_groups.round', 1)
162			->orderby('fighters_groups.id', 'desc');
163			}
164
165			private function hasNoCustomSettings()
166			{
167			return
168			$this->settings == null \|\|
169			($this->settings->ageCategory == null \|\| $this->settings->ageCategory == 0) &&
170			$this->settings->ageMin == null &&
171			$this->settings->ageMax == null &&
172			$this->settings->gradeMin == null &&
173			$this->settings->gradeMax == null &&
174			($this->settings->gradeCategory == null \|\| $this->settings->gradeCategory == 0);
175			}
176
177			public function buildName()
178			{
179			if ($this->settings != null && $this->settings->alias != null && $this->settings->alias != '')
180			return $this->settings->alias;
181
182			if ($this->hasNoCustomSettings()) {
183			return $this->category->name;
184			}
185
186			$genders = [
187			'M' => trans('categories.male'),
188			'F' => trans('categories.female'),
189			'X' => trans('categories.mixt')
190			];
191
192			$teamText = $this->category->isTeam == 1 ? trans_choice('core.team', 1) : trans('categories.single');
193			$ageCategoryText = $this->category->getAgeString();
194			$gradeText = $this->category->getGradeString();
195
196			return $teamText . ' ' . $genders[$this->category->gender] . ' ' . $ageCategoryText . ' ' . $gradeText;
197			}
198
199			public function getSettings()
200			{
201			return $setting = $this->settings ?? new ChampionshipSettings(ChampionshipSettings::DEFAULT_SETTINGS);
			0 ignored issues – show Unused Code introduced 2017-05-05 19:01 UTC by Report Bug Copy Issue Report `$setting` is not used, you could remove the assignment. This check looks for variable assignements that are either overwritten by other assignments or where the variable is not used subsequently. $myVar = 'Value'; $higher = false; if (rand(1, 6) > 3) { $higher = true; } else { $higher = false; } Both the `$myVar` assignment in line 1 and the `$higher` assignment in line 2 are dead. The first because `$myVar` is never used and the second because `$higher` is always overwritten for every possible time line. Loading history...
202			}
203
204			/**
205			* Return Groups that belongs to a round
206			* @param integer $round
207			* @return HasMany
208			*/
209			public function groupsByRound($round)
210			{
211			return $this->fightersGroups()->where('round', $round);
212			}
213
214			/**
215			* Return Fights that belongs to a round
216			*
217			* @param integer $round
218			* @return \Illuminate\Database\Eloquent\Relations\HasManyThrough
219			*/
220			public function fightsByRound($round)
221			{
222			return $this->hasManyThrough(Fight::class, FightersGroup::class)->where('round', $round);
223			}
224
225			public function isPlayoffCompetitor()
226			{
227			return !$this->category->isTeam() &&
228			($this->isPlayOffType() \|\| $this->hasPreliminary());
229			}
230
231			public function isPlayoffTeam()
232			{
233			return $this->category->isTeam() &&
234			($this->isPlayOffType() \|\| $this->hasPreliminary());
235			}
236
237			public function isDirectEliminationCompetitor()
238			{
239			return !$this->category->isTeam() && $this->isDirectEliminationType() && !$this->hasPreliminary();
240			}
241
242			public function isDirectEliminationTeam()
243			{
244			return $this->category->isTeam() && $this->isDirectEliminationType() && !$this->hasPreliminary();
245			}
246
247			/**
248			* @return TreeGenerable
249			*/
250			public function chooseGenerationStrategy()
251			{
252			$generation = new TreeGen($this, null);
253			switch (true) {
254			case $this->isDirectEliminationCompetitor():
			0 ignored issues – show Coding Style introduced 2017-05-12 03:49 UTC by Report Bug Copy Issue Report `case` statements should be defined using a colon. As per the PSR-2 coding standard, case statements should not be wrapped in curly braces. There is no need for braces, since each case is terminated by the next `break`. There is also the option to use a semicolon instead of a colon, this is discouraged because many programmers do not even know it works and the colon is universal between programming languages. switch ($expr) { case "A": { //wrong doSomething(); break; } case "B"; //wrong doSomething(); break; case "C": //right doSomething(); break; } To learn more about the PSR-2 coding standard, please refer to the PHP-Fig. Loading history...
255			$generation = new DirectEliminationCompetitorTreeGen($this, null);
256			break;
257			case $this->isDirectEliminationTeam():
			0 ignored issues – show Coding Style introduced 2017-05-12 03:49 UTC by Report Bug Copy Issue Report `case` statements should be defined using a colon. As per the PSR-2 coding standard, case statements should not be wrapped in curly braces. There is no need for braces, since each case is terminated by the next `break`. There is also the option to use a semicolon instead of a colon, this is discouraged because many programmers do not even know it works and the colon is universal between programming languages. switch ($expr) { case "A": { //wrong doSomething(); break; } case "B"; //wrong doSomething(); break; case "C": //right doSomething(); break; } To learn more about the PSR-2 coding standard, please refer to the PHP-Fig. Loading history...
258			$generation = new DirectEliminationTeamTreeGen($this, null);
259			break;
260			case $this->isPlayoffCompetitor():
261			$generation = new PlayOffCompetitorTreeGen($this, null);
262			break;
263			case $this->isPlayoffTeam():
264			$generation = new PlayOffTeamTreeGen($this, null);
265			break;
266			default:
267			dd("bad choice");
268			}
269			return $generation;
270			}
271
272			}
273

xoco70 / laravel-tournaments

Push — master ( d98836...b20032 )

Championship::category() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like