PlayerService::mergePlayers()   F
last analyzed

Complexity

Conditions 19
Paths 343

Size

Total Lines 72

Duplication

Lines 0
Ratio 0 %

Importance

Changes 0
Metric Value
cc 19
nc 343
nop 2
dl 0
loc 72
rs 1.8958
c 0
b 0
f 0

How to fix   Long Method    Complexity   

Long Method

Small methods make your code easier to understand, in particular if combined with a good name. Besides, if your method is small, finding a good name is usually much easier.

For example, if you find yourself adding comments to a method's body, this is usually a good sign to extract the commented part to a new method, and use the comment as a starting point when coming up with a good name for this new method.

Commonly applied refactorings include:

1
<?php
2
declare(strict_types=1);
3
/**
4
 * Created by PhpStorm.
5
 * User: benedikt
6
 * Date: 1/29/17
7
 * Time: 11:10 PM
8
 */
9
10
namespace Tfboe\FmLib\Service;
11
12
13
use Doctrine\ORM\EntityManagerInterface;
14
use Tfboe\FmLib\Entity\PlayerInterface;
15
use Tfboe\FmLib\Entity\TournamentInterface;
16
17
/**
18
 * Class PlayerService
19
 * @package App\Service
20
 */
21
class PlayerService implements PlayerServiceInterface
22
{
23
//<editor-fold desc="Fields">
24
  /** @var EntityManagerInterface */
25
  private $em;
26
27
  /** @var LoadingServiceInterface */
28
  private $ls;
29
30
  /** @var RankingSystemServiceInterface */
31
  private $rankingSystemService;
32
//</editor-fold desc="Fields">
33
34
//<editor-fold desc="Constructor">
35
36
  /**
37
   * PlayerService constructor.
38
   * @param EntityManagerInterface $em
39
   * @param LoadingServiceInterface $ls
40
   * @param RankingSystemServiceInterface $rankingSystemService
41
   */
42
  public function __construct(
43
    EntityManagerInterface $em,
44
    LoadingServiceInterface $ls,
45
    RankingSystemServiceInterface $rankingSystemService
46
  )
47
  {
48
    $this->em = $em;
49
    $this->ls = $ls;
50
    $this->rankingSystemService = $rankingSystemService;
51
  }
52
//</editor-fold desc="Constructor">
53
54
55
//<editor-fold desc="Public Methods">
56
  /**
57
   * @param PlayerInterface $player
58
   * @param PlayerInterface $toMerge
59
   * @return bool|string
60
   */
61
  public function mergePlayers(PlayerInterface $player, PlayerInterface $toMerge)
62
  {
63
    if ($player->getId() == $toMerge->getId()) {
64
      return "Players are identical!";
65
    }
66
67
    /** @var TournamentInterface[] $ts */
68
    $ts = $this->em->createQueryBuilder()
69
      ->select("t")
70
      ->from(TournamentInterface::class, 't')
71
      ->innerJoin('t.competitions', 'c')
72
      ->innerJoin('c.teams', 'te')
73
      ->innerJoin('te.memberships', 'm')
74
      ->where('m.player = (:id)')->setParameter('id', $toMerge->getId())
75
      ->getQuery()->getResult();
76
77
    $tMap = [];
78
    foreach ($ts as $tournament) {
79
      $tMap[$tournament->getId()] = $tournament;
80
    }
81
    $ts = array_values($tMap);
82
83
    $this->ls->loadEntities($ts);
84
85
    //check if player is attendant in one of the tournaments of toMerge
86
    foreach ($ts as $tournament) {
87
      foreach ($tournament->getCompetitions() as $competition) {
88
        foreach ($competition->getTeams() as $team) {
89
          foreach ($team->getMemberships() as $membership) {
90
            if ($membership->getPlayer()->getId() == $player->getId()) {
91
              return "Player 1 and player 2 both attended the tournament " . $tournament->getName() .
92
                "(" . $tournament->getStartTime()->format('d.m.Y H:i') . ", id='" . $tournament->getId() . "')";
93
            }
94
          }
95
        }
96
      }
97
    }
98
99
    //change players
100
    foreach ($ts as $tournament) {
101
      foreach ($tournament->getCompetitions() as $competition) {
102
        $isMember = false;
103
        foreach ($competition->getTeams() as $team) {
104
          foreach ($team->getMemberships() as $membership) {
105
            if ($membership->getPlayer()->getId() == $toMerge->getId()) {
106
              $this->rankingSystemService->adaptOpenSyncFromValues($tournament, []);
107
              $membership->setPlayer($player);
108
              $isMember = true;
109
            }
110
          }
111
        }
112
        if ($isMember) {
113
          foreach ($competition->getPhases() as $phase) {
114
            foreach ($phase->getMatches() as $match) {
115
              foreach ($match->getGames() as $game) {
116
                if ($game->getPlayersA()->containsKey($toMerge->getId())) {
117
                  $game->getPlayersA()->remove($toMerge->getId());
118
                  $game->getPlayersA()->set($player->getId(), $player);
119
                }
120
                if ($game->getPlayersB()->containsKey($toMerge->getId())) {
121
                  $game->getPlayersB()->remove($toMerge->getId());
122
                  $game->getPlayersB()->set($player->getId(), $player);
123
                }
124
              }
125
            }
126
          }
127
        }
128
      }
129
    }
130
131
    return true;
132
  }
133
//</editor-fold desc="Public Methods">
134
}