src/Controller/Api/PlayerController.php line 488

Open in your IDE?
  1. <?php
  2. namespace App\Controller\Api;
  3. use App\Entity\Convocatoria;
  4. use App\Entity\ConvocatoriaPlayer;
  5. use App\Entity\Customer;
  6. use App\Entity\Player;
  7. use App\Entity\Season;
  8. use App\Entity\Game;
  9. use App\Entity\GameAlignment;
  10. use App\Entity\PlayerSportsInjuries;
  11. use App\Entity\SeasonPlayer;
  12. use App\Entity\GamePlayerStatistics;
  13. use App\Entity\TrainingAsist;
  14. use App\Helper\UploadedBase64File;
  15. use App\Repository\ConvocatoriaRepository;
  16. use App\Repository\PlayerRepository;
  17. use App\Services\Api\PlayerManager;
  18. use Doctrine\ORM\EntityManagerInterface;
  19. use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
  20. use Symfony\Component\HttpFoundation\JsonResponse;
  21. use Symfony\Component\HttpFoundation\Request;
  22. use Symfony\Component\Routing\Annotation\Route;
  23. use Psr\Log\LoggerInterface;
  24. use App\Entity\PlayerWeight;
  25. use DateTime;
  26. class PlayerController extends ApiController
  27. {
  28.     /** @var PlayerManager $playerManager */
  29.     protected $playerManager;
  30.     /**
  31.      * @param PlayerManager $playerManager
  32.      */
  33.     public function __construct(EntityManagerInterface $emParameterBagInterface $parameterBagPlayerManager $playerManager)
  34.     {
  35.         parent::__construct($em$parameterBag);
  36.         $this->playerManager $playerManager;
  37.     }
  38.     /**
  39.      * @param Request $request
  40.      * @return JsonResponse
  41.      *
  42.      * @Route("/player/listbygame/{id}", name="api_player_list_by_game", methods={"POST"})
  43.      */
  44.     public function listPlayerByGame($idRequest $request)
  45.     {
  46.         $prefixFile $this->getParameter("app.path.player_images");
  47.         $baseurl $request->getScheme() . '://' $request->getHttpHost() . $request->getBasePath();
  48.         $request $this->transformJsonBody($request);
  49.         $players = [];
  50.         /** @var PlayerRepository $playerRepository */
  51.         $playerRepository $this->em->getRepository(Player::class);
  52.         /** @var Customer $customer */
  53.         $customer $this->getUser();
  54.         $season $customer->getSeasonActive();
  55.         if (!empty($season)) {
  56.             $filter = [
  57.                 "season" => $season->getId()
  58.             ];
  59.             $sort $request->get('sort');
  60.             if (empty($sort)) $sort 'dorsal';
  61.             $direction $request->get('direction');
  62.             if (empty($direction)) $direction 'ASC';
  63.             /** @var Game $game */
  64.             $game $this->em->getRepository(Game::class)->find($id);
  65.             $convocatoria $game->getConvocatoria();
  66.             $convocatoriaPlayerRepository $this->em->getRepository(ConvocatoriaPlayer::class);
  67.              /** @var GameAlignment $gameAlignment */
  68.              $captain $game->getAlignment()->getCaptain()? $game->getAlignment()->getCaptain()->getPlayer()->getId() : null;
  69.              
  70.             /** @var SeasonPlayer $seasonPlayer */
  71.             /** @var Player $player */
  72.             foreach ($this->em->getRepository(SeasonPlayer::class)->findBy($filter, [$sort => $direction]) as $seasonPlayer) {
  73.                 $player $seasonPlayer->getPlayer();
  74.                 $playerArr $player->__toArray($baseurl $prefixFile "/");
  75.                 $seasonPlayerActive = !$seasonPlayer->getDeletedAt();
  76.                 $isActive $player->getIsActive();
  77.                 if ($isActive && $seasonPlayerActive) {
  78.                     $criteria = [
  79.                         "seasonPlayer" => $seasonPlayer,
  80.                         "game" => $game
  81.                     ];
  82.                     $miscellaneous $playerRepository->getStatsMiscellaneousByGame($player$game);
  83.                     $isTitular $miscellaneous['isTitular'] ? true false;
  84.                     $isCaptain $captain == $player->getId();
  85.                     $out array_merge($miscellaneous,[
  86.                         "dorsal" => $seasonPlayer->getDorsal(),
  87.                         "isTitular" => $isTitular,
  88.                         "isCaptain" => $isCaptain,
  89.                         "countryId" => !empty($player->getCountry()) ? $player->getCountry()->getId() : null,
  90.                     ]);
  91.                     if ($convocatoria) {
  92.                         $convocatoriaPlayer $convocatoriaPlayerRepository->findOneBy([
  93.                             "player_id" => $player->getId(),
  94.                             "convocatoria_id" => $convocatoria->getId(),
  95.                         ]);
  96.                         if ($convocatoriaPlayer) {
  97.                             $out array_merge($out, [
  98.                                 "isOn" => $convocatoriaPlayer->getIsActive(),
  99.                             ], $convocatoriaPlayer->__toArray());
  100.                         } else {
  101.                             $out array_merge($out, [
  102.                                 "isOn" => false,
  103.                                 "justification_type" => null,
  104.                                 "is_active" => null,
  105.                             ]);
  106.                         }
  107.                     } else {
  108.                         $out array_merge($out, [
  109.                             "isOn" => false,
  110.                             "justification_type" => null,
  111.                             "is_active" => null,
  112.                         ]);
  113.                     }
  114.                     if ($out['isOn']) {
  115.                         $players[] = array_merge($playerArr$out);
  116.                     }
  117.                 }
  118.             }
  119.         }
  120.         return $this->response($players);
  121.     }
  122.     /**
  123.      * @param Request $request
  124.      * @return JsonResponse
  125.      *
  126.      * @Route("/player/list", name="api_player_list", methods={"POST"})
  127.      */
  128.     public function listPlayer(Request $request)
  129.     {
  130.         $request $this->transformJsonBody($request);
  131.         $players = [];
  132.         /** @var Customer $customer */
  133.         $customer $this->getUser();
  134.         $season $customer->getSeasonActive();
  135.         if (!empty($season)) {
  136.             $filter = [
  137.                 "season" => $season->getId()
  138.             ];
  139.             $sort $request->get('sort');
  140.             if (empty($sort)) $sort 'dorsal';
  141.             $direction $request->get('direction');
  142.             if (empty($direction)) $direction 'ASC';
  143.             /** @var Player $player */
  144.             foreach ($this->em->getRepository(SeasonPlayer::class)->findBy($filter, [$sort => $direction]) as $seasonPlayer) {
  145.                 /** @var SeasonPlayer $seasonPlayer */
  146.                 $player $seasonPlayer->getPlayer();
  147.                 $seasonPlayerActive = !$seasonPlayer->getDeletedAt();
  148.                 $isActive $player->getIsActive();
  149.                 if ($isActive && !$player->getDeletedAt() && $seasonPlayerActive) {
  150.                     $players[] = $this->getDataPlayer($request$player$season);
  151.                 }
  152.             }
  153.         }
  154.         return $this->response($players);
  155.     }
  156.         /**
  157.      * @param Request $request
  158.      * @return JsonResponse
  159.      *
  160.      * @Route("/player/list/recycling", name="api_player_list_recycling", methods={"POST"})
  161.      */
  162.     public function listPlayerRecycling(Request $request)
  163.     {
  164.         $request $this->transformJsonBody($request);
  165.         $players = [];
  166.         /** @var Customer $customer */
  167.         $customer $this->getUser();
  168.         $season $customer->getSeasonActive();
  169.         if (!empty($season)) {
  170.             $filter = [
  171.                 "season" => $season->getId()
  172.             ];
  173.             $sort $request->get('sort');
  174.             if (empty($sort)) $sort 'dorsal';
  175.             $direction $request->get('direction');
  176.             if (empty($direction)) $direction 'ASC';
  177.             /** @var Player $player */
  178.             foreach ($this->em->getRepository(SeasonPlayer::class)->findBy($filter, [$sort => $direction]) as $seasonPlayer) {
  179.                 /** @var SeasonPlayer $seasonPlayer */
  180.                 $player $seasonPlayer->getPlayer();
  181.                 $seasonPlayerActive $seasonPlayer->getIsActive();
  182.                 $seasonPlayerDeletedAt $seasonPlayer->getDeletedAt();
  183.                 if ($player->getDeletedAt() && $player->getIsActive() && $seasonPlayerActive && $seasonPlayerDeletedAt) {
  184.                     $players[] = $this->getDataPlayer($request$player$season);
  185.                 }
  186.             }
  187.         }
  188.         return $this->response($players);
  189.     }
  190.     public function getDataPlayer(Request $requestPlayer $playerSeason $season)
  191.     {
  192.         $seasonPlayer $this->em->getRepository(SeasonPlayer::class)->findOneBy(['player' => $player"season" => $season]);
  193.         $weights = [];
  194.         foreach ($this->em->getRepository(PlayerWeight::class)->findBy([
  195.             'seasonPlayer' => $seasonPlayer
  196.         ], ['date' => 'ASC']) as $key => $weight) {
  197.             $weights[] = $weight->__toArray();
  198.         }
  199.         $baseurl $request->getScheme() . '://' $request->getHttpHost() . $request->getBasePath();
  200.         $prefixFile $this->getParameter("app.path.player_images");
  201.         /** @var PlayerRepository $playerRepository */
  202.         $playerRepository $this->em->getRepository(Player::class);
  203.         $playerArr $player->__toArray($baseurl $prefixFile "/");
  204.         $playerArr['weights'] = $weights;
  205.         $playerArr['weight'] = count($weights)  ?   $weights[0]['weight'] : $playerArr['weight'];
  206.         // add weight if is empty table PlayerWeight player
  207.         if (!count($weights) && $playerArr['weight'] != 0.00) {
  208.             $playerWeight = new PlayerWeight();
  209.             $playerWeight->setSeasonPlayer($seasonPlayer);
  210.             $playerWeight->setWeight($playerArr['weight']);
  211.             $playerWeight->setDate(new DateTime());
  212.             $playerWeight->setTime(new DateTime());
  213.             $this->em->persist($playerWeight);
  214.             $this->em->flush();
  215.             $playerArr['weights'] = $playerWeight->__toArray();
  216.         }
  217.         $miscellaneous $playerRepository->getStatsMiscellaneousAllPlayers($player$season);
  218.         $trainingAsist $playerRepository->getStatsAsist($player$season);
  219.         $result $playerRepository->getStatsConvocatoria($player$season);
  220.         $newData array_merge($playerArr$miscellaneous);
  221.         $newData array_merge($trainingAsist$newData);
  222.         $newData array_merge($result$newData);
  223.         return array_merge($newData, [
  224.             "dorsal" => $seasonPlayer->getDorsal(),
  225.             "countryId" => !empty($player->getCountry()) ? $player->getCountry()->getId() : null,
  226.             "seasonsPlayer" => $player->getSeasonPlayers()->map(function (SeasonPlayer $seasonPlayer) use ($playerRepository$player$request) {
  227.                 $season $seasonPlayer->getSeason();
  228.                 $miscellaneous $playerRepository->getStatsMiscellaneousAllPlayers($player$season);
  229.                 $imageTeam $season->getTeam()->getImage();
  230.                 $prefixFile $this->getParameter("app.path.customer_images");
  231.                 $baseurl $request->getScheme() . '://' $request->getHttpHost() . $request->getBasePath();
  232.                 $imagePath = !empty($imageTeam) ? $baseurl $prefixFile "/" $imageTeam "";
  233.                 $miscellaneous['imageTeam'] = $imagePath;
  234.                 return array_merge($seasonPlayer->__toArray(), $miscellaneous);
  235.             })->toArray(),
  236.         ]);
  237.     }
  238.     /**
  239.      * @param Request $request
  240.      * @return JsonResponse
  241.      *
  242.      * @Route("/player/add", name="api_player_add", methods={"POST"})
  243.      */
  244.     public function addPlayer(Request $request)
  245.     {
  246.         $request $this->transformJsonBody($request);
  247.         $data $this->getDataFromRequest($request);
  248.         /** @var Customer $customer */
  249.         $customer $this->getUser();
  250.         $season $customer->getSeasonActive();
  251.         $response $this->playerManager->add($data$request);
  252.         $this->setStatusCode($response["code"]);
  253.         if ($response['code'] == 200) {
  254.             $response['player'] = $this->getDataPlayer($request$response['player'], $season);
  255.         };
  256.         return $this->response($response);
  257.     }
  258.     /**
  259.      * @param Request $request
  260.      * @return JsonResponse
  261.      *
  262.      * @Route("/players/all", name="api_players_all", methods={"POST"})
  263.      */
  264.     public function allPlayers(Request $request)
  265.     {
  266.         $customer $this->getUser();
  267.         $response $this->playerManager->allPlayersByUserId($customer);
  268.         return $this->response($response);
  269.     }
  270.     /**
  271.      * @param Request $request
  272.      * @return JsonResponse
  273.      *
  274.      * @Route("/players/migrate/{seasonId}", name="api_players_migrate", methods={"POST"})
  275.      */
  276.     public function migratePlayer($seasonIdRequest $request)
  277.     {
  278.         $customer $this->getUser();
  279.         $season $customer->getSeasonActive();
  280.         $players json_decode($request->get('players'"[]"), true);
  281.         $seasonRepository $this->em->getRepository(Season::class);
  282.         /** @var Season $seasonTarget */
  283.         $seasonTarget $seasonRepository->findOneBy(["id" => $seasonId"customer" => $customer->getId(), "isActive" => true]);
  284.         $response $this->playerManager->addPlayerToSeason($customer$season$players$seasonTarget);
  285.         $this->setStatusCode($response["code"]);
  286.         return $this->response($response);
  287.     }
  288.     /**
  289.      * @param Request $request
  290.      * @return JsonResponse
  291.      *
  292.      * @Route("/players/migrate/undo/{seasonId}", name="api_players_migrate_undo", methods={"POST"})
  293.      */
  294.     public function undoMigratePlayer($seasonIdRequest $request)
  295.     {
  296.         $customer $this->getUser();
  297.         $season $customer->getSeasonActive();
  298.         $players json_decode($request->get('players'"[]"), true);
  299.         $seasonRepository $this->em->getRepository(Season::class);
  300.         /** @var Season $seasonTarget */
  301.         $seasonTarget $seasonRepository->findOneBy(["id" => $seasonId"customer" => $customer->getId(), "isActive" => true]);
  302.         $response $this->playerManager->moveToBinPlayerFromSeason($customer$season$players$seasonTarget);
  303.         $this->setStatusCode($response["code"]);
  304.         return $this->response($response);
  305.     }
  306.     /**
  307.      * @param Request $request
  308.      * @return JsonResponse
  309.      *
  310.      * @Route("/players/migrate/remove/{seasonId}", name="api_players_migrate_remove", methods={"POST"})
  311.      */
  312.     public function removeMigratePlayer($seasonIdRequest $request)
  313.     {
  314.         $customer $this->getUser();
  315.         $season $customer->getSeasonActive();
  316.         $players json_decode($request->get('players'"[]"), true);
  317.         $seasonRepository $this->em->getRepository(Season::class);
  318.         /** @var Season $seasonTarget */
  319.         $seasonTarget $seasonRepository->findOneBy(["id" => $seasonId"customer" => $customer->getId(), "isActive" => true]);
  320.         $response $this->playerManager->removePlayerFromSeason($customer$season$players$seasonTarget);
  321.         $this->setStatusCode($response["code"]);
  322.         return $this->response($response);
  323.     }
  324.     /**
  325.      * @param Request $request
  326.      * @return JsonResponse
  327.      *
  328.      * @Route("/players/migrate/rollback/{seasonId}", name="api_players_migrate_rollback", methods={"POST"})
  329.      */
  330.     public function rollbackMigratePlayer($seasonIdRequest $request)
  331.     {
  332.         $customer $this->getUser();
  333.         $season $customer->getSeasonActive();
  334.         $players json_decode($request->get('players'"[]"), true);
  335.         $seasonRepository $this->em->getRepository(Season::class);
  336.         /** @var Season $seasonTarget */
  337.         $seasonTarget $seasonRepository->findOneBy(["id" => $seasonId"customer" => $customer->getId(), "isActive" => true]);
  338.         $response $this->playerManager->removePlayerFromSeason($customer$season$players$seasonTarget);
  339.         $this->setStatusCode($response["code"]);
  340.         return $this->response($response);
  341.     }
  342.     /**
  343.      * @param Request $request
  344.      * @return JsonResponse
  345.      *
  346.      * @Route("/player/edit/{player}", name="api_player_edit", methods={"POST"})
  347.      */
  348.     public function editPlayer(Player $playerRequest $requestLoggerInterface $logger)
  349.     {
  350.         $request $this->transformJsonBody($request);
  351.         $data $this->getDataFromRequest($request);
  352.         $response $this->playerManager->edit($player$data);
  353.         $logger->info("DATA " json_encode($data));
  354.         $this->setStatusCode($response["code"]);
  355.         return $this->response($response);
  356.     }
  357.     /**
  358.      * @param Request $request
  359.      * @return JsonResponse 
  360.      *
  361.      * @Route("/player/editstats/{player}", name="api_player_editstats", methods={"POST"})
  362.      */
  363.     public function editStats(Player $playerRequest $requestLoggerInterface $logger)
  364.     {
  365.         $data = [
  366.             "gameId" => $request->get('gameId'),
  367.             "minutes" => $request->get('minutes'),
  368.             "yellowCards" => $request->get('yellowCards'),
  369.             "redCards" => $request->get('redCards'),
  370.             "goals" => $request->get('goals'),
  371.             "goalAssistances" => $request->get('goalAssistances'),
  372.             "isTitular" => $request->get('isTitular'),
  373.             "kilometersTraveled" => $request->get('kilometersTraveled'),
  374.             "shotsOnGoal" => $request->get('shotsOnGoal'),
  375.             "stolenBalls" => $request->get('stolenBalls'),
  376.             "penaltiesCommitted" => $request->get('penaltiesCommitted'),
  377.             "forcedPenalties" => $request->get('forcedPenalties'),
  378.             "stopsMade" => $request->get('stopsMade'),
  379.         ];
  380.         /** @var Customer $customer */
  381.         $customer $this->getUser();
  382.         $season $customer->getSeasonActive();
  383.         $response $this->playerManager->updateStats($player$datafalse);
  384.         $this->setStatusCode($response["code"]);
  385.         if ($response['code'] == 200) {
  386.             $response['player'] = $this->getDataPlayer($request$response['player'], $season);
  387.         };
  388.         return $this->response($response);
  389.     }
  390.     protected function getDataFromRequest(Request $request)
  391.     {
  392.         $data = [
  393.             "name" => $request->get('name'),
  394.             "lastname" => $request->get('lastname'),
  395.             "position" => $request->get('position'),
  396.             "secondary_position" => $request->get('secondaryPosition'),
  397.             "age" => (int) $request->get('age'),
  398.             "weight" => (float) $request->get('weight'),
  399.             "height" => (float) $request->get('height'),
  400.             "shoes" => (int) $request->get('shoes'),
  401.             "games" => (int) $request->get('games'),
  402.             "goals" => (int) $request->get('goals'),
  403.             "yellowCard" => (int) $request->get('yellowCard'),
  404.             "redCard" => (int) $request->get('redCard'),
  405.             "dorsal" => (int) $request->get('dorsal'),
  406.             "skillfulLeg" => (int) $request->get('skillfulLeg'),
  407.             "countryId" => (int) $request->get('countryId'),
  408.             "phone" => $request->get('phone') ?? NULL,
  409.             "email" => $request->get('email') ?? NULL,
  410.             "numberDocument" => $request->get('numberDocument') ?? NULL,
  411.             "healthCard" => $request->get('healthCard') ?? NULL,
  412.             "dateOfBirth" => $request->get('dateOfBirth') ? new DateTime($request->get('dateOfBirth')) : NULL,
  413.             "medicalReviewDate" => $request->get('medicalReviewDate') ? new DateTime($request->get('medicalReviewDate')) : NULL,
  414.             "lastClub" => $request->get('lastClub') ?? NULL,
  415.         ];
  416.         $image $request->get('image');
  417.         if (!empty($image))
  418.             $data["image"] = new UploadedBase64File($image$request->get('imageFilename'));
  419.         return $data;
  420.     }
  421.     /**
  422.      * @param Request $request
  423.      * @return JsonResponse
  424.      *
  425.      * @Route("/player/trainingAsist", name="api_player_trainingAsist", methods={"POST"})
  426.      */
  427.     public function trainingAsistPlayer(Request $request)
  428.     {
  429.         $prefixFile $this->getParameter("app.path.player_images");
  430.         $baseurl $request->getScheme() . '://' $request->getHttpHost() . $request->getBasePath();
  431.         $order $request->get('order''trainingAsist');
  432.         $players = [];
  433.         /** @var PlayerRepository $playerRepository */
  434.         $playerRepository $this->em->getRepository(Player::class);
  435.         /** @var Customer $customer */
  436.         $customer $this->getUser();
  437.         $season $customer->getSeasonActive();
  438.         if (!empty($season)) {
  439.             $filter = [
  440.                 "season" => $season->getId()
  441.             ];
  442.             /** @var SeasonPlayer $seasonPlayer */
  443.             /** @var Player $player */
  444.             foreach ($this->em->getRepository(SeasonPlayer::class)->findBy($filter) as $seasonPlayer) {
  445.                 $player $seasonPlayer->getPlayer();
  446.                 $seasonPlayerActive = !$seasonPlayer->getDeletedAt();
  447.                 $isActive $player->getIsActive();
  448.                 if ($isActive && $seasonPlayerActive) {
  449.                     $result $playerRepository->getStatsAsist($player$season);
  450.                     // Retrieve min statistics and league statistics
  451.                     $playerMinutes $this->em->getRepository(GamePlayerStatistics::class)->getPlayerMinutes($player->getId());
  452.                     $totalMinutes = (int) $playerMinutes['totalMinutes'];
  453.                     $leagueMinutes = (int) $playerMinutes['leagueMinutes'];
  454.                     
  455.                     $players[] = [
  456.                         "id" => $player->getId(),
  457.                         "name" => $player->getName(),
  458.                         "lastname" => $player->getLastname(),
  459.                         "position" => !empty($player->getPosition()) ? $player->getPosition()->getSlug() : "",
  460.                         "image" => !empty($player->getImage()) ? $baseurl $prefixFile "/" $player->getImage() : "",
  461.                         "trainingAsist" => intval($result['trainingAsist'] ?? 0),
  462.                         "trainingAsistTotal" => intval($result['trainingAsistTotal'] ?? 0),
  463.                         "trainingAsistPercent" => intval($result['trainingAsistPercent'] ?? 0),
  464.                         "totalMinutes" => $totalMinutes,
  465.                         "leagueMinutes" => $leagueMinutes,
  466.                     ];
  467.                 }
  468.             }
  469.             usort($players, function ($a$b) use ($order) {
  470.                 if ($a[$order] > $b[$order])
  471.                     return 1;
  472.                 if ($a[$order] < $b[$order])
  473.                     return -1;
  474.                 return 0;
  475.             });
  476.             $players array_reverse($players);
  477.         }
  478.         return $this->response($players);
  479.     }
  480.     /**
  481.      * @param Request $request
  482.      * @return JsonResponse
  483.      *
  484.      * @Route("/player/convocatorias", name="api_player_convocatorias", methods={"POST"})
  485.      */
  486.     public function convocatoriasPlayer(Request $request)
  487.     {
  488.         $prefixFile $this->getParameter("app.path.player_images");
  489.         $baseurl $request->getScheme() . '://' $request->getHttpHost() . $request->getBasePath();
  490.         $request $this->transformJsonBody($request);
  491.         $players = [];
  492.         /** @var PlayerRepository $playerRepository */
  493.         $playerRepository $this->em->getRepository(Player::class);
  494.         /** @var Customer $customer */
  495.         $customer $this->getUser();
  496.         $season $customer->getSeasonActive();
  497.         if (!empty($season)) {
  498.             $filter = [
  499.                 "season" => $season->getId()
  500.             ];
  501.             /** @var ConvocatoriaRepository $convocatoriaRepository */
  502.             $convocatoriaRepository $this->em->getRepository(Convocatoria::class);
  503.             /** @var SeasonPlayer $seasonPlayer */
  504.             /** @var Player $player */
  505.             foreach ($this->em->getRepository(SeasonPlayer::class)->findBy($filter) as $seasonPlayer) {
  506.                 $player $seasonPlayer->getPlayer();
  507.                 $seasonPlayerActive = !$seasonPlayer->getDeletedAt();
  508.                 $isActive $player->getIsActive();
  509.                 if ($isActive && $seasonPlayerActive) {
  510.                     $result $playerRepository->getStatsConvocatoria($player$season);
  511.                     $players[] = array_merge([
  512.                         "id" => $player->getId(),
  513.                         "name" => $player->getName(),
  514.                         "lastname" => $player->getLastname(),
  515.                         "position" => !empty($player->getPosition()) ? $player->getPosition()->getSlug() : "",
  516.                         "image" => !empty($player->getImage()) ? $baseurl $prefixFile "/" $player->getImage() : "",
  517.                     ],$result);
  518.                 }
  519.             }
  520.             usort($players, function ($a$b) {
  521.                 if ($a["convocatory"] > $b["convocatory"])
  522.                     return 1;
  523.                 if ($a["convocatory"] < $b["convocatory"])
  524.                     return -1;
  525.                 return 0;
  526.             });
  527.             $players array_reverse($players);
  528.         }
  529.         return $this->response($players);
  530.     }
  531.     /**
  532.      * @param Request $request
  533.      * @return JsonResponse
  534.      *
  535.      * @Route("/player/assistances/{id}/{month}/{year}", name="api_player_assistances", methods={"POST"})
  536.      */
  537.     public function assistancesPlayer($id$month$year)
  538.     {
  539.         /** @var Player $player */
  540.         $player $this->em->getRepository(Player::class)->findOneBy(['id' => $id]);
  541.         $lowermonth = \DateTime::createFromFormat("d/m/Y H:i:s""1/" . ($month) . "/" . ($year) . " 00:00:00");
  542.         $uppermonth = \DateTime::createFromFormat("d/m/Y H:i:s""0/" . ($month 1) . "/" . ($year) . " 00:00:00");
  543.         $dates = [];
  544.         $dates['justifications'] = [];
  545.         $justifications $player->getJustification();
  546.         foreach ($justifications as $justification) {
  547.             if ($justification->getDate() >= $lowermonth && $justification->getDate() <= $uppermonth) {
  548.                 $dates['justifications'][] = [
  549.                     "date" => $justification->getDate()->format("Y-m-d"),
  550.                     "type" => $justification->getJustificationType()->getId()
  551.                 ];
  552.             }
  553.         };
  554.         $dates['assistances'] = [];
  555.         $trainingsAssits $player->getTrainingAsists();
  556.         foreach ($trainingsAssits as $trainingAssist) {
  557.             if ($trainingAssist->getDate() >= $lowermonth && $trainingAssist->getDate() <= $uppermonth)
  558.                 $dates['assistances'][] = [
  559.                     "date" => $trainingAssist->getDate()->format("Y-m-d")
  560.                 ];
  561.         };
  562.         $dates['lacks'] = [];
  563.         /** @var Customer $customer */
  564.         $customer $this->getUser();
  565.         $season $customer->getSeasonActive();
  566.         if (!empty($season)) {
  567.             $filter = [
  568.                 [
  569.                     "prop" => "season",
  570.                     "comp" => "=",
  571.                     "val" => $season->getId()
  572.                 ],
  573.                 [
  574.                     "prop" => "date",
  575.                     "comp" => ">=",
  576.                     "val" => $lowermonth
  577.                 ],
  578.                 [
  579.                     "prop" => "date",
  580.                     "comp" => "<=",
  581.                     "val" => $uppermonth
  582.                 ],
  583.             ];
  584.             /** @var TrainingAsist $trainingAsist */
  585.             foreach ($this->em->getRepository(TrainingAsist::class)->findByOwnCriteria($filter) as $trainingAsist) {
  586.                 $date $trainingAsist->getDate()->format("Y-m-d");
  587.                 if (!in_array($datearray_column($dates['justifications'], 'date')) && !in_array($datearray_column($dates['assistances'], 'date'))) {
  588.                     $dates['lacks'][] = [
  589.                         "date" => $date
  590.                     ];
  591.                 }
  592.             }
  593.         }
  594.         return $this->response($dates);
  595.     }
  596.     /**
  597.      * @param Request $request
  598.      * @return JsonResponse
  599.      *
  600.      * @Route("/player/assistance/{id}/{month}", name="api_player_assistance", methods={"POST"})
  601.      */
  602.     public function assistancePlayer($id$month)
  603.     {
  604.         /** @var Player $player */
  605.         $player $this->em->getRepository(Player::class)->findOneBy(['id' => $id]);
  606.         $lowermonth = \DateTime::createFromFormat("d/m/Y H:i:s""1/" . ($month) . "/" date('Y') . " 00:00:00");
  607.         $uppermonth = \DateTime::createFromFormat("d/m/Y H:i:s""0/" . ($month 1) . "/" date('Y') . " 00:00:00");
  608.         $dates = [];
  609.         $dates['justifications'] = [];
  610.         $justifications $player->getJustification();
  611.         foreach ($justifications as $justification) {
  612.             if ($justification->getDate() >= $lowermonth && $justification->getDate() <= $uppermonth) {
  613.                 $dates['justifications'][] = [
  614.                     "date" => $justification->getDate()->format("Y-m-d"),
  615.                     "type" => $justification->getJustificationType()->getId()
  616.                 ];
  617.             }
  618.         };
  619.         $dates['assistances'] = [];
  620.         $trainingsAssits $player->getTrainingAsists();
  621.         foreach ($trainingsAssits as $trainingAssist) {
  622.             if ($trainingAssist->getDate() >= $lowermonth && $trainingAssist->getDate() <= $uppermonth)
  623.                 $dates['assistances'][] = [
  624.                     "date" => $trainingAssist->getDate()->format("Y-m-d")
  625.                 ];
  626.         };
  627.         $dates['lacks'] = [];
  628.         /** @var Customer $customer */
  629.         $customer $this->getUser();
  630.         $season $customer->getSeasonActive();
  631.         if (!empty($season)) {
  632.             $filter = [
  633.                 [
  634.                     "prop" => "season",
  635.                     "comp" => "=",
  636.                     "val" => $season->getId()
  637.                 ],
  638.                 [
  639.                     "prop" => "date",
  640.                     "comp" => ">=",
  641.                     "val" => $lowermonth
  642.                 ],
  643.                 [
  644.                     "prop" => "date",
  645.                     "comp" => "<=",
  646.                     "val" => $uppermonth
  647.                 ],
  648.             ];
  649.             /** @var TrainingAsist $trainingAsist */
  650.             foreach ($this->em->getRepository(TrainingAsist::class)->findByOwnCriteria($filter) as $trainingAsist) {
  651.                 $date $trainingAsist->getDate()->format("Y-m-d");
  652.                 if (!in_array($datearray_column($dates['justifications'], 'date')) && !in_array($datearray_column($dates['assistances'], 'date'))) {
  653.                     $dates['lacks'][] = [
  654.                         "date" => $date
  655.                     ];
  656.                 }
  657.             }
  658.         }
  659.         return $this->response($dates);
  660.     }
  661.     /**
  662.      * @param Request $request
  663.      * @return JsonResponse
  664.      *
  665.      * @Route("/player/delete/{player}", name="api_player_delete", methods={"POST"})
  666.      */
  667.     public function deletePlayer(Player $player)
  668.     {
  669.         $response $this->playerManager->delete($player);
  670.         $this->setStatusCode($response["code"]);
  671.         return $this->response($response);
  672.     }
  673.         /**
  674.      * @param Request $request
  675.      * @return JsonResponse
  676.      *
  677.      * @Route("/player/delete/{player}/permanent", name="api_player_delete_permanent", methods={"POST"})
  678.      */
  679.     public function deletePlayerPermanent(Player $player)
  680.     {
  681.         $response $this->playerManager->deletePermanent($player);
  682.         $this->setStatusCode($response["code"]);
  683.         return $this->response($response);
  684.     }
  685.             /**
  686.      * @param Request $request
  687.      * @return JsonResponse
  688.      *
  689.      * @Route("/player/restore/{player}", name="api_player_restore", methods={"POST"})
  690.      */
  691.     public function restorePlayer(Player $player)
  692.     {
  693.         $response $this->playerManager->restorePlayer($player);
  694.         $this->setStatusCode($response["code"]);
  695.         return $this->response($response);
  696.     }
  697.     /**
  698.      * @param Request $request
  699.      * @return JsonResponse
  700.      *
  701.      * @Route("/player/games/{id}", name="api_player_games", methods={"POST"})
  702.      */
  703.     public function gamesPlayer($idRequest $request)
  704.     {
  705.         $prefixFile $this->getParameter("app.path.game_images");
  706.         $baseurl $request->getScheme() . '://' $request->getHttpHost() . $request->getBasePath();
  707.         /** @var Customer $customer */
  708.         $customer $this->getUser();
  709.         $season $customer->getSeasonActive();
  710.         /** @var PlayerRepository $playerRepository */
  711.         $playerRepository $this->em->getRepository(Player::class);
  712.         $player $playerRepository->findOneBy([
  713.             'id' => $id
  714.         ]);
  715.         $results $playerRepository->findGamesBySeason($player$season);
  716.         /** @var PlayerRepository $playerRepository */
  717.         $gameRepository $this->em->getRepository(Game::class);
  718.         $output = [];
  719.         foreach ($results as $result) {
  720.             $game $gameRepository->findOneBy([
  721.                 'id' => $result['id']
  722.             ])->__toArray($baseurl $prefixFile "/");
  723.             $game['playerStats'] = $result;
  724.             $output[] = $game;
  725.         }
  726.         return $this->response($output);
  727.     }
  728.     /**
  729.      * @param Request $request
  730.      * @return JsonResponse
  731.      *
  732.      * @Route("/player/justifications", name="api_player_justifications", methods={"POST"})
  733.      */
  734.     public function justifications(Request $request)
  735.     {
  736.         $prefixFile $this->getParameter("app.path.player_images");
  737.         $baseurl $request->getScheme() . '://' $request->getHttpHost() . $request->getBasePath();
  738.         $order $request->get('order''justificationTotal');
  739.         $players = [];
  740.         /** @var PlayerRepository $playerRepository */
  741.         $playerRepository $this->em->getRepository(Player::class);
  742.         /** @var Customer $customer */
  743.         $customer $this->getUser();
  744.         $season $customer->getSeasonActive();
  745.         if (!empty($season)) {
  746.             $filter = [
  747.                 "season" => $season->getId()
  748.             ];
  749.             /** @var SeasonPlayer $seasonPlayer */
  750.             /** @var Player $player */
  751.             foreach ($this->em->getRepository(SeasonPlayer::class)->findBy($filter) as $seasonPlayer) {
  752.                 $player $seasonPlayer->getPlayer();
  753.                 $seasonPlayerActive = !$seasonPlayer->getDeletedAt();
  754.                 $isActive $player->getIsActive();
  755.                 $playerSportInjure = [
  756.                     'season' => $season,
  757.                     'seasonPlayer' => $seasonPlayer
  758.                 ];
  759.                 $playerInjury = [];
  760.                 foreach ($this->em->getRepository(PlayerSportsInjuries::class)->findBy($playerSportInjure) as $key => $injury) {
  761.                     $playerInjury[] = $injury->__toArray();
  762.                 }
  763.                 if ($isActive && $seasonPlayerActive) {
  764.                     $justifications $playerRepository->getStatsJustification($player$season);
  765.                     $justificationsConvocatoria $playerRepository->getStatsJustificationConvocatoria($player$season);
  766.                     $base = [
  767.                         "id" => $player->getId(),
  768.                         "name" => $player->getName(),
  769.                         "lastname" => $player->getLastname(),
  770.                         "position" => !empty($player->getPosition()) ? $player->getPosition()->getSlug() : "",
  771.                         "image" => !empty($player->getImage()) ? $baseurl $prefixFile "/" $player->getImage() : "",
  772.                         "playerInjuriesGames" => $playerInjury
  773.                     ];
  774.                     $players[] = array_merge($base$justifications$justificationsConvocatoria);
  775.                 }
  776.             }
  777.             usort($players, function ($a$b) use ($order) {
  778.                 if ($a[$order] > $b[$order])
  779.                     return 1;
  780.                 if ($a[$order] < $b[$order])
  781.                     return -1;
  782.                 return 0;
  783.             });
  784.             $players array_reverse($players);
  785.         }
  786.         return $this->response($players);
  787.     }
  788.     /**
  789.      * @param Request $request
  790.      * @return JsonResponse
  791.      *
  792.      * @Route("/player/{id}/seasons", name="api_player_seasons", methods={"POST"})
  793.      */
  794.     public function seasons(Request $request)
  795.     {
  796.         $prefixFile $this->getParameter("app.path.player_images");
  797.         $baseurl $request->getScheme() . '://' $request->getHttpHost() . $request->getBasePath();
  798.         $order $request->get('order''justificationTotal');
  799.         $players = [];
  800.         /** @var PlayerRepository $playerRepository */
  801.         $playerRepository $this->em->getRepository(Player::class);
  802.         /** @var Customer $customer */
  803.         $customer $this->getUser();
  804.         $season $customer->getSeasonActive();
  805.         if (!empty($season)) {
  806.             $filter = [
  807.                 "season" => $season->getId()
  808.             ];
  809.             /** @var SeasonPlayer $seasonPlayer */
  810.             /** @var Player $player */
  811.             foreach ($this->em->getRepository(SeasonPlayer::class)->findBy($filter) as $seasonPlayer) {
  812.                 $player $seasonPlayer->getPlayer();
  813.                 $seasonPlayerActive = !$seasonPlayer->getDeletedAt();
  814.                 $isActive $player->getIsActive();
  815.                 if ($isActive && $seasonPlayerActive) {
  816.                     $justifications $playerRepository->getStatsJustification($player$season);
  817.                     $justificationsConvocatoria $playerRepository->getStatsJustificationConvocatoria($player$season);
  818.                     $base = [
  819.                         "id" => $player->getId(),
  820.                         "name" => $player->getName(),
  821.                         "lastname" => $player->getLastname(),
  822.                         "position" => !empty($player->getPosition()) ? $player->getPosition()->getSlug() : "",
  823.                         "image" => !empty($player->getImage()) ? $baseurl $prefixFile "/" $player->getImage() : "",
  824.                     ];
  825.                     $players[] = array_merge($base$justifications$justificationsConvocatoria);
  826.                 }
  827.             }
  828.             usort($players, function ($a$b) use ($order) {
  829.                 if ($a[$order] > $b[$order])
  830.                     return 1;
  831.                 if ($a[$order] < $b[$order])
  832.                     return -1;
  833.                 return 0;
  834.             });
  835.             $players array_reverse($players);
  836.         }
  837.         return $this->response($players);
  838.     }
  839.     /**
  840.      * @param Request $request
  841.      * @return JsonResponse
  842.      *
  843.      * @Route("/player/search_customer_shared", name="api_search_customer_shared_", methods={"POST"})
  844.      */
  845.     public function searchCustomerSharedPlayer(Request $request)
  846.     {
  847.         if (!$request->get('email')) {
  848.             return $this->response(['code' => 422'message' => 'email is required']);
  849.         }
  850.         $customerRepository $this->em->getRepository(Customer::class);
  851.         $customer $customerRepository->findOneBy(["email" => $request->get("email")]);
  852.         if ($customer) {
  853.             return $this->response([
  854.                 'code' => 200,
  855.                 'data' => [
  856.                     'id' => $customer->getId(),
  857.                     'name' => $customer->getName(),
  858.                     'teamName' => $customer->getNameTeam(),
  859.                     'email' => $customer->getEmail(),
  860.                 ]
  861.             ]);
  862.         }
  863.         return $this->response([
  864.             'code' => 401,
  865.             'message' => 'user not fount!',
  866.         ]);
  867.     }
  868. }