Xoco70\KendoTournaments\Models\Tree::getChampionships()

Complexity

Conditions	3
Paths	3

Size

Total Lines	24
Code Lines	17

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

2 Methods

Rating	Name	Duplication	Size	Complexity
A	Tree::user3()	0	4	1
A	Tree::user4()	0	4	1

<?php

namespace Xoco70\KendoTournaments\Models;


use App\User;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Collection;
use Xoco70\KendoTournaments\TreeGen\TreeGen;

class Tree extends Model
{
    protected $table = 'tree';
    public $timestamps = true;
    protected $guarded = ['id'];

    /**
     * Check if Request contains tournamentSlug / Should Move to TreeRequest When Built
     * @param $request
     * @return bool
     */
    public static function hasTournament($request)
    {
        return $request->tournamentSlug != null;
    }

    /**
     * Check if Request contains championshipId / Should Move to TreeRequest When Built
     * @param $request
     * @return bool
     */
    public static function hasChampionship($request)
    {
        return $request->championshipId != null; // has return false, don't know why
    }


    /**
     * @return \Illuminate\Database\Eloquent\Relations\BelongsTo
     */
    public function championship()
    {
        return $this->belongsTo(Championship::class);
    }

    /**
     * @return \Illuminate\Database\Eloquent\Relations\HasMany
     */
    public function fights()
    {
        return $this->hasMany(Fight::class, 'tree_id', 'id');
    }

    /**
     * @return \Illuminate\Database\Eloquent\Relations\BelongsTo
     */
    public function user1()
    {
        return $this->belongsTo(User::class, 'c1', 'id');
    }

    /**
     * @return \Illuminate\Database\Eloquent\Relations\BelongsTo
     */
    public function user2()
    {
        return $this->belongsTo(User::class, 'c2', 'id');
    }

    /**
     * @return \Illuminate\Database\Eloquent\Relations\BelongsTo
     */
    public function user3()
    {
        return $this->belongsTo(User::class, 'c3', 'id');
    }

    /**
     * @return \Illuminate\Database\Eloquent\Relations\BelongsTo
     */
    public function user4()
    {
        return $this->belongsTo(User::class, 'c4', 'id');
    }

    /**
     * @return \Illuminate\Database\Eloquent\Relations\BelongsTo
     */
    public function user5()
    {
        return $this->belongsTo(User::class, 'c5', 'id');
    }


    /**
     * @return \Illuminate\Database\Eloquent\Relations\BelongsTo
     */
    public function team1()
    {
        return $this->belongsTo(Team::class, 'c1', 'id');
    }

    /**
     * @return \Illuminate\Database\Eloquent\Relations\BelongsTo
     */
    public function team2()
    {
        return $this->belongsTo(Team::class, 'c2', 'id');
    }

    /**
     * @return \Illuminate\Database\Eloquent\Relations\BelongsTo
     */
    public function team3()
    {
        return $this->belongsTo(Team::class, 'c3', 'id');
    }



    /**
     * @param Collection $tree
     * @param $settings
     */
    public static function generateFights(Collection $tree, $settings, Championship $championship = null)
    {

        // Delete previous fight for this championship

        $arrayTreeId = $tree->map(function ($value, $key) {

The parameter $key is not used and could be removed.

            return $value->id;
        })->toArray();
        Fight::destroy($arrayTreeId);

        if ($settings->hasPreliminary) {
            if ($settings->preliminaryGroupSize == 3) {
                for ($numRound = 1; $numRound <= $settings->preliminaryGroupSize; $numRound++) {
                    Fight::saveFightRound($tree, $numRound);
                }
            } else {
                Fight::saveRoundRobinFights($championship, $tree);
            }
        } elseif ($settings->treeType == config('kendo-tournaments.DIRECT_ELIMINATION')) {
            Fight::saveFightRound($tree); // Always C1 x C2
        } elseif ($settings->treeType == config('kendo-tournaments.ROUND_ROBIN')) {
            Fight::saveRoundRobinFights($championship, $tree);

        }

    }
}