tippspiel/pfosten/app/leagues/League.php

<?php

namespace App\Leagues;

use Illuminate\Database\Eloquent\Model;

use App\Season;
use App\Round;
use App\User;

use DB;
use Log;

class League extends Model
{

    const RANK_LEAGUE1       = 1;
    const RANK_LEAGUE2       = 2;
    const RANK_LEAGUE3       = 3;
    const RANK_QUALIFICATION = 4;

    protected $table ='leagues';
    protected $fillable = [
        'id','season_id','is_qualification','rank','subrank','start_round_id','round_count','name'
    ];
    //
    public static function neededLeagues($member_count, $round_count) {
        $max_members_per_league=22;
        if ( $round_count < $max_members_per_league-1 ) { $max_members_per_league = $round_count+1; }
        if ($member_count <= $max_members_per_league) return $member_count;

        $neededLeagues = intdiv($member_count, $max_members_per_league);

        if ( $member_count - $max_members_per_league * $neededLeagues ) {
            $neededLeagues+=1;
        }
        return $neededLeagues;
    }

    public static function getMemberCount($league_id) {
        $members = DB::table('leagues_members')->where('league_id','=',$league_id)->get();
        return sizeof($members);
    }


    public static function getNames() {
        $season = Season::getCurrent();

        $leagues = League::where('season_id','=',$season->id)->orderBy('rank')->orderBy('name')->get();

        $leagueNames = array();
        foreach($leagues as $league) {
            $leagueNames[$league->id] = $league->name;
        }
        return $leagueNames;
    }

    public static function getStartRoundId($leagueId)
    {
        $league = League::where('id','=',$leagueId)->first();
        return $league->start_round_id;
    }



    public static function cmpScore($score1, $score2) {
        return ($score1[1] < $score2[1]);
    }

    public static function getRanking($rank, $seasonId=-1) {
        $season = Season::getCurrent();
        if ($seasonId > -1) { $season=Season::where('id','=',$seasonId)->first(); };
        $leagues = League::where('rank','=',$rank)->where('season_id','=', $season->id)->orderBy('id')->get();

        error_log("LeagueCount:".sizeof($leagues));

        $leagueScores=array();
        foreach($leagues as $league) {
            $memberIds = LeagueMember::getMembers($league->id);

            $memberScores =array();
            foreach($memberIds as $memberId) {
                $tpl=array();
                $tpl[0]=$memberId;
                $tpl[1]=0; // league_score
                $tpl[2]=0; // goals
                $tpl[3]=0; // countergoals
                $memberScores[$memberId] = $tpl;
            }

            $matches=Match::getMatchResults($league->id,-1);
            foreach ($matches as $match) {
                if (Round::isCompleted($match->round_id)) {
                    $memberScores[$match->user1_id][1] += $match->user1_league_score;
                    $memberScores[$match->user1_id][2] += $match->user1_rankscore;    // goals
                    $memberScores[$match->user1_id][3] += $match->user2_rankscore;    // countergoals
                    $memberScores[$match->user2_id][1] += $match->user2_league_score;
                    $memberScores[$match->user2_id][2] += $match->user2_rankscore;    // goals
                    $memberScores[$match->user2_id][3] += $match->user1_rankscore;    // countergoals
                }
            }
            usort($memberScores, array('App\Leagues\League','cmpScore'));

            $leagueScores[$league->id]=$memberScores;

        }
        return $leagueScores;
    }



    // Für Auf/Abstiegsberechnung
    public static function getUnifiedRanking($rank, $seasonId=-1) {
        $leagueScores = League::getRanking($rank, $seasonId);
        $unifiedScores = array();
        foreach($leagueScores as $leagueId => $singleLeagueScores) {
            foreach ($singleLeagueScores as $placeNr => $singleLeagueScore) {
                $userId=$singleLeagueScores[$placeNr][0];
                $unifiedScores[$userId]=$singleLeagueScores[$placeNr];
            }
        }
        usort($unifiedScores,array('App\Leagues\League','cmpScore'));
        return $unifiedScores;
    }


    // Aktuelle Liga-Zuordnung auf Basis des Rangs in der letzten Liga
    public static function getNewLeagueForPlayers()
    {
        $lastSeason = Season::getLast();
        $currentSeason = Season::getCurrent();

        if (!$lastSeason) {
            dd("No last season handling implemented. Please fix/implement.");
            //TODO: Implement a qualification round
        }

        $users = User::getActives();
        $usersLastSeason = User::getActives($lastSeason->id);

        // Wenn der User in den roundTipps der previousSeaoson nicht existiert, nahm er an der Runde nicht
        // teil, und ist automatisch Liga 3.

        foreach ($users as $key => $user) {

            $found = false;
            foreach ($usersLastSeason as $userLastSeason) {
                if ($userLastSeason->id == $user->id) $found = true;
            }

            if (!$found) {
                $users[$key]['rank']=League::RANK_LEAGUE3; // In der letzten Season unter den Actives nicht gefunden
            } else {
                // League1, 1-16:   RANK_LEAGUE1
                // League1, 17-22:  RANK_LEAGUE2
                // League2, 1-6:    RANK_LEAGUE1
                // League2, 7-16:   RANK_LEAGUE2
                // League2, 17-22:  RANK_LEAGUE3
                // League3, best6:  RANK_LEAGUE2
                // League3, 7-end:  RANK_LEAGUE3
            }

        }
    }
}