Championship::hasNoCustomSettings() - Code Metrics - Inspection of "extract methods" - xoco70/laravel-tournaments - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Push — master ( 84ef8e...92b331 )

by Julien

created 2017-05-22 15:34 UTC

Championship::hasNoCustomSettings() A

↳ Parent: Championship

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
c	1
b	0
f	0
dl	0
loc	4
rs	10
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;
    }

    public function buildName()
    {
        if ($this->settings != null && $this->settings->alias != null)
            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 $this->settings ?? new ChampionshipSettings(ChampionshipSettings::DEFAULT_SETTINGS);
    }

    /**
     * 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 $this->settings == null;
168			}
169
170			public function buildName()
171			{
172			if ($this->settings != null && $this->settings->alias != null)
173			return $this->settings->alias;
174
175			if ($this->hasNoCustomSettings()) {
176			return $this->category->name;
177			}
178
179			$genders = [
180			'M' => trans('categories.male'),
181			'F' => trans('categories.female'),
182			'X' => trans('categories.mixt')
183			];
184
185			$teamText = $this->category->isTeam == 1 ? trans_choice('core.team', 1) : trans('categories.single');
186			$ageCategoryText = $this->category->getAgeString();
187			$gradeText = $this->category->getGradeString();
188
189			return $teamText . ' ' . $genders[$this->category->gender] . ' ' . $ageCategoryText . ' ' . $gradeText;
190			}
191
192			public function getSettings()
193			{
194			return $this->settings ?? new ChampionshipSettings(ChampionshipSettings::DEFAULT_SETTINGS);
195			}
196
197			/**
198			* Return Groups that belongs to a round
199			* @param integer $round
200			* @return HasMany
201			*/
202			public function groupsByRound($round)
203			{
204			return $this->fightersGroups()->where('round', $round);
205			}
206
207			/**
208			* Return Fights that belongs to a round
209			*
210			* @param integer $round
211			* @return \Illuminate\Database\Eloquent\Relations\HasManyThrough
212			*/
213			public function fightsByRound($round)
214			{
215			return $this->hasManyThrough(Fight::class, FightersGroup::class)->where('round', $round);
216			}
217
218			public function isPlayoffCompetitor()
219			{
220			return !$this->category->isTeam() &&
221			($this->isPlayOffType() \|\| $this->hasPreliminary());
222			}
223
224			public function isPlayoffTeam()
225			{
226			return $this->category->isTeam() &&
227			($this->isPlayOffType() \|\| $this->hasPreliminary());
228			}
229
230			public function isDirectEliminationCompetitor()
231			{
232			return !$this->category->isTeam() && $this->isDirectEliminationType() && !$this->hasPreliminary();
233			}
234
235			public function isDirectEliminationTeam()
236			{
237			return $this->category->isTeam() && $this->isDirectEliminationType() && !$this->hasPreliminary();
238			}
239
240			/**
241			* @return TreeGenerable
242			*/
243			public function chooseGenerationStrategy()
244			{
245			$generation = new TreeGen($this, null);
246			switch (true) {
247			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...
248			$generation = new DirectEliminationCompetitorTreeGen($this, null);
249			break;
250			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...
251			$generation = new DirectEliminationTeamTreeGen($this, null);
252			break;
253			case $this->isPlayoffCompetitor():
254			$generation = new PlayOffCompetitorTreeGen($this, null);
255			break;
256			case $this->isPlayoffTeam():
257			$generation = new PlayOffTeamTreeGen($this, null);
258			break;
259			default:
260			dd("bad choice");
261			}
262			return $generation;
263			}
264			}
265

xoco70 / laravel-tournaments

Push — master ( 84ef8e...92b331 )

Championship::hasNoCustomSettings() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like