src/Controller/Api/GameController.php line 553

Open in your IDE?
  1. <?php
  3. namespace App\Controller\Api;
  5. use App\Entity\ConvocatoriaPlayer;
  6. use App\Entity\Customer;
  7. use App\Entity\ExerciseCalendar;
  8. use App\Entity\Game;
  9. use App\Entity\Player;
  10. use App\Entity\PlayerJustification;
  11. use App\Entity\PlayerSportsInjuries;
  12. use App\Entity\SeasonPlayer;
  13. use App\Entity\TrainingAsist;
  14. use App\Entity\TrainingAsistPlayer;
  15. use App\Helper\UploadedBase64File;
  16. use App\Repository\GameRepository;
  17. use App\Services\Api\PlayerManager;
  18. use App\Services\Api\GameManager;
  19. use DateTime;
  20. use Doctrine\ORM\EntityManagerInterface;
  21. use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
  22. use Symfony\Component\HttpFoundation\JsonResponse;
  23. use Symfony\Component\HttpFoundation\Request;
  24. use Symfony\Component\Routing\Annotation\Route;
  25. use Psr\Log\LoggerInterface;
  27. class GameController extends ApiController
  28. {
  30.   /** @var GameManager $gameManager */
  31.   protected $gameManager;
  33.   /** @var PlayerManager $playerManager */
  34.   protected $playerManager;
  36.   /**
  37.    * @param GameManager $gameManager
  38.    */
  39.   public function __construct(EntityManagerInterface $em, ParameterBagInterface $parameterBag, GameManager $gameManager, PlayerManager $playerManager)
  40.   {
  41.     parent::__construct($em, $parameterBag);
  42.     $this->gameManager = $gameManager;
  43.     $this->playerManager = $playerManager;
  44.   }
  46.   /**
  47.    * @param Request $request
  48.    * @return JsonResponse
  49.    *
  50.    * @Route("/game/list", name="api_game_list", methods={"POST"})
  51.    */
  52.   public function listGames(Request $request)
  53.   {
  54.     $prefixFile = $this->getParameter("app.path.game_images");
  55.     $baseurl = $request->getScheme() . '://' . $request->getHttpHost() . $request->getBasePath();
  56.     $request = $this->transformJsonBody($request);
  58.     $games = [];
  60.     /** @var Customer $customer */
  61.     $customer = $this->getUser();
  62.     $season = $customer->getSeasonActive();
  63.     if (!empty($season)) {
  64.       $filter = [
  65.         "season" => $season->getId()
  66.       ];
  68.       /** @var Game $game */
  69.       foreach ($this->em->getRepository(Game::class)->findAllActiveGames($filter, ["day" => "DESC"]) as $game) {
  70.         $games[] = $game->__toArray($baseurl . $prefixFile . "/");
  71.       }
  72.     }
  74.     return $this->response($games);
  75.   }
  77.   /**
  78.    * @param Request $request
  79.    * @return JsonResponse
  80.    *
  81.    * @Route("/game/list/recycling", name="api_game_list_recycling", methods={"POST"})
  82.    */
  83.   public function listGamesRecycling(Request $request)
  84.   {
  85.     $prefixFile = $this->getParameter("app.path.game_images");
  86.     $baseurl = $request->getScheme() . '://' . $request->getHttpHost() . $request->getBasePath();
  87.     $request = $this->transformJsonBody($request);
  89.     $games = [];
  91.     /** @var Customer $customer */
  92.     $customer = $this->getUser();
  93.     $season = $customer->getSeasonActive();
  94.     if (!empty($season)) {
  95.       $filter = [
  96.         "season" => $season->getId(),
  97.       ];
  99.       /** @var Game $game */
  100.       foreach ($this->em->getRepository(Game::class)->findAllRecyclingGames($filter, ["day" => "DESC"]) as $game) {
  101.         $games[] = $game->__toArray($baseurl . $prefixFile . "/");
  102.       }
  103.     }
  105.     return $this->response($games);
  106.   }
  108.   /**
  109.    * @param Request $request
  110.    * @return JsonResponse
  111.    *
  112.    * @Route("/game/stats", name="api_game_stats", methods={"POST"})
  113.    */
  114.   public function statsGames()
  115.   {
  116.     $victory = 0;
  117.     $tied = 0;
  118.     $loser = 0;
  119.     $percent = 0;
  120.     $total = 0;
  121.     $totalPlus = 0;
  122.     $future = 0;
  123.     $leagueMinutes = 0;
  124.     $cupMinutes = 0;
  126.     /** @var Customer $customer */
  127.     $customer = $this->getUser();
  128.     $season = $customer->getSeasonActive();
  129.     if (!empty($season)) {
  130.       $filter = [
  131.         "season" => $season->getId()
  132.       ];
  134.       /** @var Game $game */
  135.       foreach ($this->em->getRepository(Game::class)->findBy($filter, ["day" => "DESC"]) as $game) {
  136.         if ((!is_null($game->getGoals())) && !is_null($game->getRivalGoals())) {
  138.           $gameDate = $game->getDate()->format("Y-m-d-H-i-s");
  139.           $currentDate = date("Y-m-d-H-i-s");
  140.           $totalPlus++;
  141.           if ($currentDate > $gameDate) {
  142.             $total++;
  144.             // Update competition-specific minutes
  145.             $competition = $game->getCompetition();
  146.             if ($competition !== null) {
  147.                 if ($competition->getId() === 1) { // League games
  148.                     $leagueMinutes += $game->getTimeMatch();
  149.                 } elseif ($competition->getId() === 2) { // Cup games
  150.                     $cupMinutes += $game->getTimeMatch();
  151.                 }
  152.             }
  153.             if ($game->getGoals() > $game->getRivalGoals())
  154.               $victory++;
  155.             else if ($game->getGoals() < $game->getRivalGoals())
  156.               $loser++;
  157.             else {
  158.               $tied++;
  159.             }
  160.           }
  161.         }
  162.       }
  163.     }
  165.     $percent = $total > 0 ? round($victory * 100 / $total) : 0;
  167.     $stats = [
  168.       'victory' => $victory,
  169.       'tied' => $tied,
  170.       'loser' => $loser,
  171.       'percent' => $percent,
  172.       'total' => $total,
  173.       'future' => $totalPlus - $total,
  174.       'leagueMinutes' => $leagueMinutes,
  175.       'cupMinutes' => $cupMinutes,
  176.     ];
  178.     return $this->response($stats);
  179.   }
  181.   /**
  182.    * @param Request $request
  183.    * @return JsonResponse
  184.    *
  185.    * @Route("/game/delete/{game}/permanent", name="api_game_delete_permanent", methods={"POST"})
  186.    */
  187.   public function deleteGamePermanent(Game $game, Request $request)
  188.   {
  189.     $prefixFile = $this->getParameter("app.path.game_images");
  190.     $baseurl = $request->getScheme() . '://' . $request->getHttpHost() . $request->getBasePath();
  191.     $urlFiles = $baseurl . $prefixFile . "/";
  192.     $response = $this->gameManager->deleteGamePermanent($game, $urlFiles);
  193.     $this->setStatusCode($response["code"]);
  194.     return $this->response($response);
  195.   }
  197.   /**
  198.    * @param Request $request
  199.    * @return JsonResponse
  200.    *
  201.    * @Route("/game/delete/{game}", name="api_game_delete", methods={"POST"})
  202.    */
  203.   public function deleteGame(Game $game, Request $request)
  204.   {
  205.     $response = $this->gameManager->deleteGame($game);
  206.     $this->setStatusCode($response["code"]);
  207.     return $this->response($response);
  208.   }
  210.   /**
  211.    * @param Request $request
  212.    * @return JsonResponse
  213.    *
  214.    * @Route("/game/restore/{game}", name="api_game_restore", methods={"POST"})
  215.    */
  216.   public function restoreGame(Game $game, Request $request)
  217.   {
  218.     $response = $this->gameManager->restoreGame($game);
  219.     $this->setStatusCode($response["code"]);
  220.     return $this->response($response);
  221.   }
  223.   /**
  224.    * @param Request $request
  225.    * @return JsonResponse
  226.    *
  227.    * @Route("/game/convocatoria/{game}", name="api_game_convocatoria", methods={"POST"})
  228.    */
  229.   public function convocatoriaGame(Game $game, Request $request)
  230.   {
  231.     $players = [];
  232.     $prefixFile = $this->getParameter("app.path.player_images");
  233.     $baseurl = $request->getScheme() . '://' . $request->getHttpHost() . $request->getBasePath();
  235.     /** @var Customer $customer */
  236.     $customer = $this->getUser();
  237.     $season = $customer->getSeasonActive();
  238.     if (!empty($season)) {
  240.       $seasonId =  $season->getId();
  242.       if (!empty($game)) {
  243.         $convocatoria = $game->getConvocatoria();
  245.         $filter = [
  246.           "season" => $seasonId,
  247.         ];
  249.         $convocatoriaPlayerRepository = $this->em->getRepository(ConvocatoriaPlayer::class);
  250.         /** @var SeasonPlayer $seasonPlayer */
  251.         foreach ($this->em->getRepository(SeasonPlayer::class)->findBy($filter, ["dorsal" => "ASC"]) as $seasonPlayer) {
  253.           /** @var Player $player */
  254.           $player = $seasonPlayer->getPlayer();
  255.           $seasonPlayerActive = !$seasonPlayer->getDeletedAt();
  256.           $isActive = $player->getIsActive();
  258.           $deletedAt = $player->getDeletedAt();
  260.           if ($isActive && $seasonPlayerActive && !$deletedAt) {
  261.             $out = [
  262.               "id" => $player->getId(),
  263.               "seasonPlayer_id" => $seasonPlayer->getId(),
  264.               "dorsal" => $seasonPlayer->getDorsal(),
  265.               "name" => $player->getName(),
  266.               "lastname" => $player->getLastname(),
  267.               "position" => !empty($player->getPosition()) ? $player->getPosition()->getSlug() : "",
  268.               "image" => !empty($player->getImage()) ? $baseurl . $prefixFile . "/" . $player->getImage() : "",
  269.             ];
  270.             if ($convocatoria) {
  271.               /** @var ConvocatoriaPlayer $convocatoriaPlayer */
  272.               $convocatoriaPlayer = $convocatoriaPlayerRepository->findOneBy([
  273.                 "player_id" => $player->getId(),
  274.                 "convocatoria_id" => $convocatoria->getId(),
  275.               ]);
  276.               if ($convocatoriaPlayer) {
  277.                 $out = array_merge($out, [
  278.                   "isOn" => $convocatoriaPlayer->getIsActive(),
  279.                   "in" => $convocatoriaPlayer->getIsActive(),
  280.                   "justification_type" => $convocatoriaPlayer->getJustificationType() ?  $convocatoriaPlayer->getJustificationType()->getId() : null,
  281.                 ]);
  282.               }
  284.               if (!$convocatoriaPlayer) {
  285.                 $out = array_merge($out, [
  286.                   "isOn" => false,
  287.                   "in" => false,
  288.                   "justification_type" => null,
  289.                   "is_active" => null,
  290.                 ]);
  291.               }
  292.             }
  294.             if (!$convocatoria) {
  295.               $out = array_merge($out, [
  296.                 "isOn" => false,
  297.                 "in" => false,
  298.                 "justification_type" => null,
  299.                 "is_active" => null,
  300.               ]);
  301.             }
  302.             $players[] = $out;
  303.           }
  304.         }
  305.       }
  306.     }
  308.     return $this->response($players);
  309.   }
  311.   /**
  312.    * @param Request $request
  313.    * @return JsonResponse
  314.    *
  315.    * @Route("/game/convocatoria/{game}/edit", name="api_game_convocatoria_edit", methods={"POST"})
  316.    */
  317.   public function convocatoriaGameEdit($game, Request $request)
  318.   {
  319.     $request = $this->transformJsonBody($request);
  320.     $players = $request->get('players', null);
  321.     if (is_string($players)) {
  322.       //INPUT DE JSON
  323.       $inputs = json_decode($players, true);
  324.       $players = [];
  325.       foreach ($inputs as $input) {
  326.         if ($input['isOn']) {
  327.           $players[] = $input;
  328.         }
  329.       }
  330.     } else if (!is_array($players)) {
  331.       $players = [];
  332.     }
  334.     $response = $this->gameManager->editConvocatoria($game, $players);
  335.     $this->setStatusCode($response["code"]);
  336.     return $this->response($response);
  337.   }
  339.   /**
  340.    * @param Request $request
  341.    * @return JsonResponse
  342.    *
  343.    * @Route("/game/training/{date}", name="api_game_training", methods={"POST"})
  344.    */
  345.   public function trainingGame($date, Request $request)
  346.   {
  347.     $prefixFile = $this->getParameter("app.path.player_images");
  348.     $justificationIconBase = $this->getParameter("app.path.justification_icons");
  349.     $baseurl = $request->getScheme() . '://' . $request->getHttpHost() . $request->getBasePath();
  350.     $players = [];
  352.     /** @var Customer $customer */
  353.     $customer = $this->getUser();
  354.     $season = $customer->getSeasonActive();
  355.     if (!empty($season)) {
  356.       $filter = [
  357.         "season" => $season->getId(),
  358.         "date" => \DateTime::createFromFormat("d-m-Y", $date)
  359.       ];
  360.       /** @var TrainingAsist $trainingAsist */
  361.       $trainingAsist = $this->em->getRepository(TrainingAsist::class)->findOneBy($filter);
  363.       $delayPlayersIds = [];
  365.       if (!empty($trainingAsist)) {
  366.         $delayPlayers = $this->em->getRepository(TrainingAsistPlayer::class)->findBy([
  367.           "trainingAsist" => $trainingAsist->getId(),
  368.           "delay" => 1
  369.         ]);
  371.         $delayPlayersIds = array_map(function ($delayPlayer) {
  372.           return $delayPlayer->getPlayer()->getId();
  373.         }, $delayPlayers);
  374.       }
  376.       $filter = [
  377.         "season" => $season->getId()
  378.       ];
  379.       /** @var SeasonPlayer $seasonPlayer */
  380.       /** @var PlayerJustification $playerjustification */
  382.       foreach ($this->em->getRepository(SeasonPlayer::class)->findBy($filter, ["dorsal" => "ASC"]) as $seasonPlayer) {
  383.         /** @var Player $player */
  384.         $player = $seasonPlayer->getPlayer();
  385.         $seasonPlayerActive = !$seasonPlayer->getDeletedAt();
  386.         $isActive = $player->getIsActive();
  387.         $isDeleted = $player->getDeletedAt();
  389.         $justifications = $player->getJustification();
  390.         $type = null;
  391.         foreach ($justifications as $j) {
  392.           if ($j->getDate()->format('d-m-Y') == $date) {
  393.             $type = $j->getJustificationType();
  394.           }
  395.         };
  396.         $playerSportInjure = [
  397.           [
  398.             "prop" => "finish",
  399.             "comp" => "=",
  400.             "val" => 0
  401.           ],
  402.           [
  403.             "prop" => "season",
  404.             "comp" => "=",
  405.             "val" => $season->getId()
  406.           ],
  407.           [
  408.             "prop" => "seasonPlayer",
  409.             "comp" => "=",
  410.             "val" => $seasonPlayer->getId()
  411.           ],
  412.           [
  413.             "prop" => "dateStart",
  414.             "comp" => "<=",
  415.             "val" => \DateTime::createFromFormat("d-m-Y", $date)->format('Y-m-d')
  416.           ]
  417.         ];
  419.         $playerInjury = $this->em->getRepository(PlayerSportsInjuries::class)->findOneByOwnCriteria($playerSportInjure);
  421.         $filterInjureEnd = [
  422.           [
  423.             "prop" => "finish",
  424.             "comp" => "=",
  425.             "val" => 1
  426.           ],
  427.           [
  428.             "prop" => "season",
  429.             "comp" => "=",
  430.             "val" => $season->getId()
  431.           ],
  432.           [
  433.             "prop" => "seasonPlayer",
  434.             "comp" => "=",
  435.             "val" => $seasonPlayer->getId()
  436.           ],
  437.           [
  438.             "prop" => "dateStart",
  439.             "comp" => "<=",
  440.             "val" => \DateTime::createFromFormat("d-m-Y", $date)->format('Y-m-d')
  441.           ],
  442.           [
  443.             "prop" => "dateEnd",
  444.             "comp" => ">=",
  445.             "val" => \DateTime::createFromFormat("d-m-Y", $date)->format('Y-m-d')
  446.           ]
  448.         ];
  449.         if (!$playerInjury) {
  450.           $playerInjury = $this->em->getRepository(PlayerSportsInjuries::class)->findOneByOwnCriteria($filterInjureEnd, [
  451.             "sort" => 'dateEnd',
  452.             "dir" => "desc"
  453.           ]);
  454.         }
  456.         $justification = !is_null($type) ? $type->getId() : null;
  457.         $justificationType = !is_null($type) ? $type->__toArray($baseurl . $justificationIconBase . "/") : null;
  458.         if ($isActive && !$isDeleted && $seasonPlayerActive) {
  459.           $players[] = [
  460.             "id" => $player->getId(),
  461.             "dorsal" => $seasonPlayer->getDorsal(),
  462.             "name" => $player->getName(),
  463.             "lastname" => $player->getLastname(),
  464.             "position" => !empty($player->getPosition()) ? $player->getPosition()->getSlug() : "",
  465.             "image" => !empty($player->getImage()) ? $baseurl . $prefixFile . "/" . $player->getImage() : "",
  466.             "isOn" => !empty($trainingAsist) && $trainingAsist->getPlayers()->contains($player),
  467.             "in" => !empty($trainingAsist) && $trainingAsist->getPlayers()->contains($player),
  468.             "delay" => $delayPlayersIds ? in_array($player->getId(), $delayPlayersIds) : false,
  469.             "justification" => $justificationType,
  470.             "disabled" => $playerInjury ? $playerInjury->__toArray() : null,
  471.           ];
  472.         }
  473.       }
  474.     }
  476.     return $this->response($players);
  477.   }
  479.   /**
  480.    * @param Request $request
  481.    * @return JsonResponse
  482.    *
  483.    * @Route("/game/training/{date}/edit", name="api_game_training_edit", methods={"POST"})
  484.    */
  485.   public function trainingGameEdit($date, Request $request)
  486.   {
  487.     $request = $this->transformJsonBody($request);
  488.     $players = json_decode($request->get('players', "[]"), true);
  489.     $response = $this->gameManager->editTraining($date, $players);
  490.     $this->setStatusCode($response["code"]);
  491.     return $this->response($response);
  492.   }
  494.   /**
  495.    * @param Request $request
  496.    * @return JsonResponse
  497.    *
  498.    * @Route("/game/trainings/{date}", name="api_game_trainings", methods={"POST"})
  499.    */
  500.   public function trainingsGame(DateTime $date)
  501.   {
  502.     $trainings = [];
  504.     /** @var Customer $customer */
  505.     $customer = $this->getUser();
  506.     $season = $customer->getSeasonActive();
  507.     if (!empty($season)) {
  508.       $filter = [
  509.         [
  510.           "prop" => "season",
  511.           "comp" => "=",
  512.           "val" => $season->getId()
  513.         ],
  514.         [
  515.           "prop" => "date",
  516.           "comp" => ">=",
  517.           "val" => \DateTime::createFromFormat("Y/m/d", $date->format('Y/m/') . "01")
  518.         ],
  519.         [
  520.           "prop" => "date",
  521.           "comp" => "<=",
  522.           "val" => \DateTime::createFromFormat("Y/m/d", $date->modify('+2 month')->format('Y/m/t'))
  523.         ],
  524.       ];
  525.       /** @var TrainingAsist $trainingAsist */
  526.       foreach ($this->em->getRepository(TrainingAsist::class)->findByOwnCriteria($filter) as $trainingAsist) {
  527.         $exercises = $this->em->getRepository(ExerciseCalendar::class)->findBy([
  528.           'date' => $trainingAsist->getDate(),
  529.           'season' => $season
  530.         ]);
  532.         if (count($exercises) || count($trainingAsist->getPlayers())) {
  533.           $trainings[] = [
  534.             "id" => $trainingAsist->getId(),
  535.             "date" => $trainingAsist->getDate()->format("Y-m-d"),
  536.           ];
  537.         } else {
  538.           $this->em->remove($trainingAsist);
  539.           $this->em->flush();
  540.         }
  541.       }
  542.     }
  544.     return $this->response($trainings);
  545.   }
  547.   /**
  548.    * @param Request $request
  549.    * @return JsonResponse
  550.    *
  551.    * @Route("/game/add", name="api_game_add", methods={"POST"})
  552.    */
  553.   public function addGame(Request $request)
  554.   {
  555.     $request = $this->transformJsonBody($request);
  556.     $data = $this->getDataFromRequest($request);
  557.     $response = $this->gameManager->add($data, $request);
  559.     $this->setStatusCode($response["code"]);
  561.     if ($response['code'] == 200) {
  562.       $prefixFile = $this->getParameter("app.path.game_images");
  563.       $baseurl = $request->getScheme() . '://' . $request->getHttpHost() . $request->getBasePath();
  564.       $response['game'] = $response['game']->__toArray($baseurl . $prefixFile . "/");
  565.     }
  567.     return $this->response($response);
  568.   }
  570.   /**
  571.    * @param Request $request
  572.    * @return JsonResponse
  573.    *
  574.    * @Route("/game/edit/{game}", name="api_game_edit", methods={"POST"})
  575.    */
  576.   public function editGame($game, Request $request)
  577.   {
  578.     $request = $this->transformJsonBody($request);
  579.     $data = $this->getDataFromRequest($request);
  580.     $response = $this->gameManager->edit($game, $data, $request);
  582.     $this->setStatusCode($response["code"]);
  583.     return $this->response($response);
  584.   }
  586.   /**
  587.    * @param Request $request
  588.    * @return JsonResponse
  589.    *
  590.    * @Route("/game/editlineup/{id}", name="api_game_editlineup", methods={"POST"})
  591.    */
  592.   public function editGameLineUp($id, Request $request, LoggerInterface $logger)
  593.   {
  594.     $lineup = $request->get('lineup');
  595.     $lineup = json_decode($lineup, true);
  596.     $logger->info("DATA-GAME " . json_encode($lineup) . " " . $id);
  597.     $response = $this->gameManager->editLineUp($id, $lineup);
  598.     $this->setStatusCode($response["code"]);
  599.     return $this->response($response);
  600.   }
  602.   /**
  603.    * @param Request $request
  604.    * @return JsonResponse
  605.    *
  606.    * @Route("/game/edit/alignment/{id}", name="api_game_edit_alignment", methods={"POST"})
  607.    */
  608.   public function editAlignment($id, Request $request, LoggerInterface $logger)
  609.   {
  610.     $request = $this->transformJsonBody($request);
  611.     $timePlayers = $request->get('dataPlayers');
  612.     $this->playerManager->updateIsTitularByGame($id);
  614.     foreach (json_decode($timePlayers) as $timePlayer) {
  615.       $player = $this->em->getRepository(Player::class)->find($timePlayer->id);
  616.       $data = [
  617.         "gameId" => $id,
  618.         "minutes" =>  $timePlayer->minutes,
  619.         "yellowCards" => $timePlayer->yellowCards,
  620.         "redCards" => $timePlayer->redCards,
  621.         "goals" => $timePlayer->goals,
  622.         "goalAssistances" => $timePlayer->goalAssistances,
  623.         "isTitular" => $timePlayer->isTitular,
  624.         "kilometersTraveled" => $timePlayer->kilometersTraveled,
  625.         "shotsOnGoal" => $timePlayer->shotsOnGoal,
  626.         'stolenBalls' => $timePlayer->stolenBalls,
  627.         'penaltiesCommitted' => $timePlayer->penaltiesCommitted,
  628.         'forcedPenalties' =>  $timePlayer->forcedPenalties,
  629.       ];
  630.       $response = $this->playerManager->updateStats($player, $data);
  631.     }
  633.     $alignment = [
  634.       'tactic' => $request->get('tactic'),
  635.       'alignment' => $request->get('alignment'),
  636.       'captain' => $request->get('captain'),
  637.     ];
  639.     $response = $this->gameManager->editAlignment($id, $alignment);
  640.     $this->setStatusCode($response["code"]);
  641.     return $this->response($response);
  642.   }
  644.   /**
  645.    * @param Request $request
  646.    * @return JsonResponse
  647.    *
  648.    * @Route("/game/get/alignment/{id}", name="api_game_get_alignment", methods={"POST"})
  649.    */
  650.   public function getAlignment($id, Request $request, LoggerInterface $logger)
  651.   {
  652.     /** @var Customer $customer */
  653.     $customer = $this->getUser();
  654.     $season = $customer->getSeasonActive();
  656.     if (empty($season))
  657.       return [
  658.         "messageType" => "danger",
  659.         "message" => $this->translator->trans('msg.season_dont_active'),
  660.         "code" => 403
  661.       ];
  663.     $filter = [
  664.       "season" => $season->getId(),
  665.       "id" => $id
  666.     ];
  668.     /** @var Game $game */
  669.     $game = $this->em->getRepository(Game::class)->findOneBy($filter);
  670.     $alignment = $game->getAlignment();
  672.     $gameAlignment = [
  673.       'alignment' => isset($alignment) ? json_decode($alignment->getAlignment()) : [],
  674.       'tactic' => isset($alignment) ? $alignment->getTactic() : "",
  675.     ];
  677.     return $this->response($gameAlignment);
  678.   }
  680.   /**
  681.    * @param Request $request
  682.    * @return JsonResponse
  683.    *
  684.    * @Route("/game/statsSeason", name="api_game_statsSeason", methods={"POST"})
  685.    */
  686.   public function assistancePlayer(Request $request)
  687.   {
  688.     $customer = $this->getUser();
  689.     $season = $customer->getSeasonActive();
  691.     /** @var GameRepository $gameRepository */
  692.     $gameRepository = $this->em->getRepository(Game::class);
  693.     $results = $gameRepository->getStatsBySeason($season);
  694.     return $this->response($results);
  695.   }
  697.   /**
  698.    * @return JsonResponse
  699.    *
  700.    * @Route("/game/lineup/{id}/captain/{playerId}/add", name="api_game_lineup_add_captain", methods={"POST"})
  701.    */
  702.   public function addGameCaptain($id, $playerId)
  703.   {
  704.     $response = $this->gameManager->addGameCaptain($id, $playerId);
  705.     $this->setStatusCode($response["code"]);
  706.     return $this->response($response);
  707.   }
  709.   /**
  710.    * @return JsonResponse
  711.    *
  712.    * @Route("/game/lineup/{id}/captain", name="api_game_lineup_captain", methods={"POST"})
  713.    */
  714.   public function getCaptain($id)
  715.   {
  716.     $response = $this->gameManager->getGameCaptain($id);
  717.     $this->setStatusCode($response["code"]);
  718.     return $this->response($response);
  719.   }
  721.   protected function getDataFromRequest(Request $request)
  722.   {
  723.     $date = \DateTime::createFromFormat('d/m/Y', $request->get('date', (new \DateTime())->format('d/m/Y')));
  724.     $time = $request->get('time');
  725.     $date->setTime(0, 0);
  726.     if ($time) {
  727.       $times = explode(':', $time);
  728.       if (count($times) > 1) {
  729.         $date->setTime($times[0], $times[1]);
  730.       }
  731.     }
  732.     $data = [
  733.       "rival" => $request->get('rival'),
  734.       "localityId" => $request->get('locality_id'),
  735.       "day" => $request->get('day'),
  736.       "date" => $date,
  737.       "goals" => $request->get('goals'),
  738.       "rivalGoals" => $request->get('rivalGoals'),
  739.       "competitionId" => $request->get('competition_id'),
  740.       "timeMatch" => $request->get('timeMatch'),
  741.       "category" => $request->get('category'),
  742.       "shotsGoal" => $request->get('shotsGoal'),
  743.       "shotsOpponent" => $request->get('shotsOpponent'),
  744.       "cornersFavor" => $request->get('cornersFavor'),
  745.       "cornersAgainst" => $request->get('cornersAgainst'),
  746.       "penaltiesFavor" => $request->get('penaltiesFavor'),
  747.       "penaltiesAgainst" => $request->get('penaltiesAgainst'),
  748.       "foulsFavor" => $request->get('foulsFavor'),
  749.       "foulsAgainst" => $request->get('foulsAgainst'),
  750.       "rivalTactic" => $request->get('rivalTactic'),
  751.       "rivalPlayersFormation" => $request->get('rivalPlayersFormation'),
  752.       "totalShots" => $request->get('totalShots'),
  753.       "totalShotsAgainst" => $request->get('totalShotsAgainst'),
  754.       "yellowCards" => $request->get('yellowCards'),
  755.       "yellowCardsAgainst" => $request->get('yellowCardsAgainst'),
  756.       "redCards" => $request->get('redCards'),
  757.       "redCardsAgainst" => $request->get('redCardsAgainst'),
  758.       "currentPositionLeague" => $request->get('currentPositionLeague'),
  759.       "opponentCurrentPositionLeague" => $request->get('opponentCurrentPositionLeague'),
  760.       "pressureRivalId" => $request->get('pressureRivalId') ?? 0,
  761.     ];
  763.     $image = $request->get('image');
  764.     if (!empty($image))
  765.       $data["image"] = new UploadedBase64File($image, $request->get('imageFilename'));
  767.     return $data;
  768.   }
  770.    /**
  771.      * @param Request $request
  772.      * @return JsonResponse
  773.      *
  774.      * @Route("/games/main-stats", name="api_game_season_stats", methods={"POST"})
  775.      */
  776.     public function gameMainStats(Request $request)
  777.     {
  778.         /** @var Customer $customer */
  779.         $customer = $this->getUser();
  780.         $season = $customer->getSeasonActive();
  781.         
  782.         /** @var GameRepository $gameRepository */
  783.         $gameRepository = $this->em->getRepository(Game::class);
  784.         
  785.         $gameLeagueStats = $gameRepository->getGameSeasonStats($season->getId());
  786.         return $this->response($gameLeagueStats);
  787.     }
  788. }