MatchService - Code Metrics - Inspection of "Update to fix team bug with less than 2 players" - BigBad/golfleague - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( af6f2a...2d5fc1 )

by Michael

created 2017-05-30 15:14 UTC

MatchService B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	366
Duplicated Lines	27.87 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes	15
Bugs	2	Features	0

Metric	Value
wmc	48
lcom	1
cbo	6
dl	102
loc	366
rs	8.4864
c	15
b	2
f	0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	18	1
F	create()	18	123	15
F	finalize()	84	177	26
A	get()	0	5	1
B	search()	0	13	5

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like MatchService often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use MatchService, and based on these observations, apply Extract Interface, too.

<?php namespace GolfLeague\Services;

use GolfLeague\Storage\Match\MatchRepository;
use GolfLeague\Storage\MatchRound\MatchRoundRepository;
use GolfLeague\PrizeMoney;
use GolfLeague\Handicap;
use \Player;
use \Match;
use \GolfLeague\Storage\Ctp\CtpRepository;
use \Grosswinner;
use \Netwinner;
use \Skin;
use GolfLeague\Services\CarryOver;
use Illuminate\Events\Dispatcher;
use \Teammatch;

/**
 * Our MatchService, containing all useful methods for business logic around Matches
 */
class MatchService
{
    // Containing our matchRepository to make all our database calls to
    protected $matchRepo;

    /**
     * Loads our $matchRepo
     *
     * @param MatchRepository $matchRepo
     * @return MatchService

     */
    public function __construct(MatchRoundRepository $matchRoundRepo,
                                MatchRepository $matchRepo,
                                PrizeMoney $prizeMoney,
                                Player $player,
                                Match $match,
                                CtpRepository $ctp,
                                Teammatch $teammatch,
                                Dispatcher $events)
    {
        $this->matchRoundRepo = $matchRoundRepo;
class MyClass { }

$x = new MyClass();
$x->foo = true;
        $this->matchRepo = $matchRepo;
        $this->prizeMoney = $prizeMoney;
class MyClass { }

$x = new MyClass();
$x->foo = true;
        $this->player = $player;
class MyClass { }

$x = new MyClass();
$x->foo = true;
        $this->match = $match;
class MyClass { }

$x = new MyClass();
$x->foo = true;
        $this->ctp = $ctp;
class MyClass { }

$x = new MyClass();
$x->foo = true;
        $this->teammatch = $teammatch;
class MyClass { }

$x = new MyClass();
$x->foo = true;
        $this->events = $events;
class MyClass { }

$x = new MyClass();
$x->foo = true;
    }

    /**
     * Method to create match from input Match data
     *
     * @param mixed $matchdata
     * @return
     */
    public function create($matchdata)
    {
        $this->prizeMoney->setPurse($matchdata['purse']);

        $matchdata['purse'] = number_format($matchdata['purse'], 2);
        $matchdata['grossmoney'] = $this->prizeMoney->getlowScore();
        $matchdata['netmoney'] = $this->prizeMoney->getlowScore();

        //How many A and B players
        $totalPlayers = 0;

        $aPlayerCount = 0;
        
        $bPlayerCount = 0;
        foreach($matchdata['player'] as $player){
            if ($player['level_id'] == '1'){
                $aPlayerCount++;
            }
            else {
                $bPlayerCount++;
            }
            $totalPlayers++;
        }

        //Calculate Skins money based on how many players in each group

        $matchdata['skinsamoney'] = $this->prizeMoney->skinsGroupPot($matchdata['purse'], $totalPlayers, $aPlayerCount);
        $matchdata['skinsbmoney'] = $this->prizeMoney->skinsGroupPot($matchdata['purse'], $totalPlayers, $bPlayerCount);
        //check for carry over money and if there is add it to skins money
        $carryOver = new CarryOver;
        $carryOverMoney = $carryOver->calculate();
        $matchdata['skinsamoney'] +=  $carryOverMoney[1];
        $matchdata['skinsbmoney'] +=  $carryOverMoney[2];

        //append current handicap and set winnings to 0 for each player
        foreach ($matchdata['player'] as $key=>$player) {
            //get each player's current handicap
            $currentPlayer = $this->player->find($player['player_id']);
            $matchdata['player'][$key]['handicap'] = $currentPlayer->handicap;
            $matchdata['player'][$key]['winnings'] = 0;
        }// End foreach

        $matchid = $this->matchRepo->create($matchdata);
        $matchdata['match_id'] = $matchid;
        $this->events->fire('match.create', array($matchdata));  // MatchHandler and teamMatchHandler are listening...

        // Run for team Matches
        if($matchdata['matchType'] === 'team' || $matchdata['matchType'] === 'both'){

            foreach ($matchdata['teamMatchUp1'] as $teamKey => $team){
                $matchUp1[] = $this->search($matchdata['player'], 'team', $team);
foreach ($collection as $item) {
    $myArray['foo'] = $item->getFoo();

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

    // do something with $myArray
}
            }

            //Save matchUp 1
            $match1['match_id'] = $matchdata['match_id'];  // This is generated below and passed to listener
foreach ($collection as $item) {
    $myArray['foo'] = $item->getFoo();

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

    // do something with $myArray
}
            $match1['team_id'] = $matchUp1[0][0]['team'];
function myFunction($a) {
    switch ($a) {
        case 'foo':
            $x = 1;
            break;

        case 'bar':
            $x = 2;
            break;
    }

    // $x is potentially undefined here.
    echo $x;
}
            $match1['player1'] = $matchUp1[0][0]['player_id'];
            if(isset($matchUp1[0][1]['player_id'])){

                $match1['player2'] = $matchUp1[0][1]['player_id'];
            }
            $match1['opponent'] = $matchUp1[1][0]['team'];
            $this->teammatch->create($match1); //save to match table

            $match1['match_id'] = $matchdata['match_id'];  // This is generated below and passed to listener
            $match1['team_id'] = $matchUp1[1][0]['team'];
            $match1['player1'] = $matchUp1[1][0]['player_id'];
            if(isset($matchUp1[1][1]['player_id'])){

                $match1['player2'] = $matchUp1[1][1]['player_id'];
            }
            $match1['opponent'] = $matchUp1[0][0]['team'];
            $this->teammatch->create($match1); //save to match table


            foreach ($matchdata['teamMatchUp2'] as $teamKey => $team){
                $matchUp2[] = $this->search($matchdata['player'], 'team', $team);
foreach ($collection as $item) {
    $myArray['foo'] = $item->getFoo();

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

    // do something with $myArray
}
            }

            //Save matchUp 2
            $match2['match_id'] = $matchdata['match_id'];  // This is generated below and passed to listener
foreach ($collection as $item) {
    $myArray['foo'] = $item->getFoo();

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

    // do something with $myArray
}
            $match2['team_id'] = $matchUp2[0][0]['team'];
function myFunction($a) {
    switch ($a) {
        case 'foo':
            $x = 1;
            break;

        case 'bar':
            $x = 2;
            break;
    }

    // $x is potentially undefined here.
    echo $x;
}
            $match2['player1'] = $matchUp2[0][0]['player_id'];
            if(isset($matchUp2[0][1]['player_id'])){

                $match2['player2'] = $matchUp2[0][1]['player_id'];
            }
            $match2['opponent'] = $matchUp2[1][0]['team'];
            $this->teammatch->create($match2); //save to match table

            $match2['match_id'] = $matchdata['match_id'];  // This is generated below and passed to listener
            $match2['team_id'] = $matchUp2[1][0]['team'];
            $match2['player1'] = $matchUp2[1][0]['player_id'];
            if(isset($matchUp2[1][1]['player_id'])){

                $match2['player2'] = $matchUp2[1][1]['player_id'];
            }
            $match2['opponent'] = $matchUp2[0][0]['team'];
            $this->teammatch->create($match2); //save to match table


            foreach ($matchdata['teamMatchUp3'] as $teamKey => $team){
                $matchUp3[] = $this->search($matchdata['player'], 'team', $team);
foreach ($collection as $item) {
    $myArray['foo'] = $item->getFoo();

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

    // do something with $myArray
}
            }

            //Save matchUp 3
            $match3['match_id'] = $matchdata['match_id'];  // This is generated below and passed to listener
foreach ($collection as $item) {
    $myArray['foo'] = $item->getFoo();

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

    // do something with $myArray
}
            $match3['team_id'] = $matchUp3[0][0]['team'];
function myFunction($a) {
    switch ($a) {
        case 'foo':
            $x = 1;
            break;

        case 'bar':
            $x = 2;
            break;
    }

    // $x is potentially undefined here.
    echo $x;
}
            $match3['player1'] = $matchUp3[0][0]['player_id'];
            if(isset($matchUp3[0][1]['player_id'])){

                $match3['player2'] = $matchUp3[0][1]['player_id'];
            }

            $match3['opponent'] = $matchUp3[1][0]['team'];
            $this->teammatch->create($match3); //save to match table

            $match3['match_id'] = $matchdata['match_id'];  // This is generated below and passed to listener
            $match3['team_id'] = $matchUp3[1][0]['team'];
            $match3['player1'] = $matchUp3[1][0]['player_id'];
            if(isset($matchUp3[1][1]['player_id'])){

                $match3['player2'] = $matchUp3[1][1]['player_id'];
            }
            $match3['opponent'] = $matchUp3[0][0]['team'];
            $this->teammatch->create($match3); //save to match table

        }
    }

    public function finalize($matchdata)
    {
        // post CTP1 and CTP2
        $ctp1 = array(
            'match_id' => $matchdata['match'],
            'player_id' => $matchdata['ctp1'],
            'hole_id' => $matchdata['ctp1hole'],
            'money' => $this->prizeMoney->getCtp()
        );
        $this->ctp->create($ctp1);
        $ctp2 = array(
            'match_id' => $matchdata['match'],
            'player_id' => $matchdata['ctp2'],
            'hole_id' => $matchdata['ctp2hole'],
            'money' => $this->prizeMoney->getCtp()
        );
        $this->ctp->create($ctp2);

        //calculate Gross winner and post to grossWinnersTable

        $matchRound = $this->matchRoundRepo->getByMatch($matchdata['match']);


        $lowGross = array();
        foreach ($matchRound as $key => $match){
            $lowGross[$match['player']->id] = $match['score'];
        }
        $arrayLowGross = array_keys($lowGross, min($lowGross));
        foreach($arrayLowGross as $key => $lowgrossPlayer) {

            $grossWinner = new Grosswinner;
            $grossWinner->player_id = $lowgrossPlayer;
            $grossWinner->match_id = $matchdata['match'];
            $grossWinner->score = $lowGross[$lowgrossPlayer];
            $grossWinner->money = $this->prizeMoney->getlowScore() / count($arrayLowGross);
            $grossWinner->save();
        }

        //Calculate NET winner
        $lowNet = array();
        $scores =array();
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        foreach ($matchRound as $key => $match){
            $netScore = ($match['score'] - round($match['player']->handicap,0)); //calculate net score
            $lowNet[$match['player']->id] = $netScore;
        }
        $arrayLowNet = array_keys($lowNet, min($lowNet));

        foreach($arrayLowNet as $key => $lownetPlayer) {

            $netWinner = new Netwinner;
            $netWinner->player_id = $lownetPlayer;
            $netWinner->match_id = $matchdata['match'];
            $netWinner->score = $lowNet[$lownetPlayer];
            $netWinner->money = $this->prizeMoney->getlowScore() /  count($arrayLowNet);
            $netWinner->save();
        }

        //Calculate Skins

        //determine A and B players
        //using pivot table match_player
        $match = $this->match->find($matchdata['match']);
        $aPlayers = array();
        $bPlayers = array();
        foreach($match->players as $player)
        {
            if($player->pivot->level_id == 1){
                $aPlayers[] = $player->pivot->player_id;

            }
            if($player->pivot->level_id == 2){
                $bPlayers[] = $player->pivot->player_id;
            }
        }

        //Create Skins arrays
        //player_id, 'holescores'
        foreach($matchRound as $key => $round) {
            if (in_array($round->player_id,$aPlayers)){

                $aPlayersSkins[$key]['player_id'] = $round->player_id;
foreach ($collection as $item) {
    $myArray['foo'] = $item->getFoo();

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

    // do something with $myArray
}
                $aPlayersSkins[$key]['holescores'] = $round->holescores;
function myFunction($a) {
    switch ($a) {
        case 'foo':
            $x = 1;
            break;

        case 'bar':
            $x = 2;
            break;
    }

    // $x is potentially undefined here.
    echo $x;
}
            }
            if (in_array($round->player_id,$bPlayers)){

                $bPlayersSkins[$key]['player_id'] = $round->player_id;
foreach ($collection as $item) {
    $myArray['foo'] = $item->getFoo();

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

    // do something with $myArray
}
                $bPlayersSkins[$key]['holescores'] = $round->holescores;
            }
        }

        //Run A Skins analysis
        $scores = array();
        foreach($aPlayersSkins as $key => $playerSkin){

            foreach($playerSkin['holescores'] as $hole => $holescore){
                $scores[$holescore['hole_id']][$playerSkin['player_id']] = $holescore['score'];
            }
        }

        foreach($scores as $hole_id => $hole) {

            $minScore = min($hole);
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
            $winners[$hole_id] = array_keys($hole, min($hole)); //gets player id of lowest score
foreach ($collection as $item) {
    $myArray['foo'] = $item->getFoo();

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

    // do something with $myArray
}
        }
        $aSkinsWon = 0;
        foreach($winners as $key => $winner) {
function myFunction($a) {
    switch ($a) {
        case 'foo':
            $x = 1;
            break;

        case 'bar':
            $x = 2;
            break;
    }

    // $x is potentially undefined here.
    echo $x;
}
            if(count($winner)  ===  1) {
                //post to DB
                $skinWinner = new Skin;
                $skinWinner->player_id = $winner[0];
                $skinWinner->level_id = 1;
                $skinWinner->match_id = intval($matchdata['match']);
                $skinWinner->hole_id = $key;
                $skinWinner->save();
                $aSkinsWon++;
            }
        }

        //Run B Skins analysis
        $scores = array();
        foreach($bPlayersSkins as $key => $playerSkin){
function myFunction($a) {
    switch ($a) {
        case 'foo':
            $x = 1;
            break;

        case 'bar':
            $x = 2;
            break;
    }

    // $x is potentially undefined here.
    echo $x;
}
            foreach($playerSkin['holescores'] as $hole => $holescore){
                $scores[$holescore['hole_id']][$playerSkin['player_id']] = $holescore['score'];
            }
        }

        foreach($scores as $hole_id => $hole) {

            $minScore = min($hole);
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
            $winners[$hole_id] = array_keys($hole, min($hole)); //gets player id of lowest score
        }
        $bSkinsWon = 0;
        foreach($winners as $key => $winner) {

            if(count($winner)  ===  1) {
                //post to DB
                $skinWinner = new Skin;
                $skinWinner->player_id = $winner[0];
                $skinWinner->level_id = 2;
                $skinWinner->match_id = intval($matchdata['match']);
                $skinWinner->hole_id = $key;
                $skinWinner->save();
                $bSkinsWon++;
            }
        }

        $match =  Match::find($matchdata['match']);

        //Need to add Carry over money if there no skins are won
        //check for carry over money
        $skinsamoney = $match->skinsamoney; // + carryover A money if any
        $skinsbmoney = $match->skinsbmoney; // + carryover B money if any

        if($aSkinsWon > 0) {

            $moneyperskinA = $skinsamoney / $aSkinsWon;

            $aSkins = Skin::where('match_id', '=', $matchdata['match'])->where('level_id', '=', 1)->get();
            foreach ($aSkins as $askin){
                $askin->money = $moneyperskinA;
                $askin->save();
            }
        }

        if($bSkinsWon > 0) {

            $moneyperskinB = $skinsbmoney / $bSkinsWon;

            $bSkins = Skin::where('match_id', '=', $matchdata['match'])->where('level_id', '=', 2)->get();
            foreach ($bSkins as $bskin){
                $bskin->money = $moneyperskinB;
                $bskin->save();
            }
        }
        //foreach player in pivot table create player and run handicap analysis
        foreach($match->players as $matchplayer)
        {
            $player = Player::find($matchplayer->pivot->player_id);
            $handicap = new Handicap($player);
            $player->handicap = $handicap->calculate();
            $player->save();
        }

        //Fire event to calculate money won and add to pivot table match_player
        $this->events->fire('match.finalize', $match);

    }

    /**
     * Method to get match from input Match data
     *
     * @param mixed $matchdata
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
     * @return JSON object
     */
    public function get($matchid)
    {
        $matchdata =  $this->matchRepo->get($matchid);
        return $matchdata;
    }



    private function search($array, $key, $value)
    {
        $results = array();
        if (is_array($array)) {
            if (isset($array[$key]) && $array[$key] == $value) {
                $results[] = $array;
            }
            foreach ($array as $subarray) {
                $results = array_merge($results, $this->search($subarray, $key, $value));
            }
        }
        return $results;
    }
}


Push — master ( af6f2a...2d5fc1 )

MatchService B

Complexity

Size/Duplication

Coupling/Cohesion

Importance

5 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

1			<?php namespace GolfLeague\Services;
2
3			use GolfLeague\Storage\Match\MatchRepository;
4			use GolfLeague\Storage\MatchRound\MatchRoundRepository;
5			use GolfLeague\PrizeMoney;
6			use GolfLeague\Handicap;
7			use \Player;
8			use \Match;
9			use \GolfLeague\Storage\Ctp\CtpRepository;
10			use \Grosswinner;
11			use \Netwinner;
12			use \Skin;
13			use GolfLeague\Services\CarryOver;
14			use Illuminate\Events\Dispatcher;
15			use \Teammatch;
16
17			/**
18			* Our MatchService, containing all useful methods for business logic around Matches
19			*/
20			class MatchService
21			{
22			// Containing our matchRepository to make all our database calls to
23			protected $matchRepo;
24
25			/**
26			* Loads our $matchRepo
27			*
28			* @param MatchRepository $matchRepo
29			* @return MatchService
			0 ignored issues – show Comprehensibility Best Practice introduced 2016-01-06 18:35 UTC by Report Bug Copy Issue Report Adding a `@return` annotation to constructors is generally not recommended as a constructor does not have a meaningful return value. Adding a `@return` annotation to a constructor is not recommended, since a constructor does not have a meaningful return value. Please refer to the PHP core documentation on constructors. Loading history...
30			*/
31			public function __construct(MatchRoundRepository $matchRoundRepo,
32			MatchRepository $matchRepo,
33			PrizeMoney $prizeMoney,
34			Player $player,
35			Match $match,
36			CtpRepository $ctp,
37			Teammatch $teammatch,
38			Dispatcher $events)
39			{

BigBad / golfleague

Push — master ( af6f2a...2d5fc1 )

MatchService B

Complexity

Size/Duplication

Coupling/Cohesion

Importance

5 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like