src/Controller/InternalApiController.php line 95

  1. <?php
  3. namespace App\Controller;
  5. use App\Entity\Club;
  6. use App\Entity\ClubNameHistory;
  7. use App\Entity\Event;
  8. use App\Entity\Game;
  9. use App\Entity\GameStats;
  10. use App\Entity\Player;
  11. use App\Entity\PlayerAchievements;
  12. use App\Entity\PlayerCareer;
  13. use App\Entity\Season;
  14. use App\Entity\Stadium;
  15. use App\Entity\ChangeList;
  16. use App\Entity\StadiumNameHistory;
  17. use App\Entity\Tournament;
  18. use App\Entity\TournamentClub;
  19. use App\Entity\TournamentStage;
  20. use Doctrine\ORM\EntityManagerInterface;
  21. use GuzzleHttp\Exception\GuzzleException;
  22. use Symfony\Component\HttpFoundation\Response;
  23. use GuzzleHttp\Client;
  24. use Symfony\Component\Serializer\Encoder\JsonEncoder;
  25. use Symfony\Component\Serializer\Normalizer\DateTimeNormalizer;
  26. use Symfony\Component\Serializer\Normalizer\ObjectNormalizer;
  27. use Symfony\Component\Serializer\Serializer;
  28. use Doctrine\Common\Annotations\AnnotationReader;
  29. use Symfony\Component\Serializer\Mapping\Factory\ClassMetadataFactory;
  30. use Symfony\Component\Serializer\Mapping\Loader\AnnotationLoader;
  31. use DateTimeInterface;
  32. use Symfony\Component\Serializer\Normalizer\AbstractNormalizer;
  33. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  35. class InternalApiController extends AbstractController
  36. {
  37.     protected EntityManagerInterface $em;
  39.     private Serializer $serializer;
  41.     private string $password;
  43.     private string $sendUrl;
  45.     public function __construct(
  46.         EntityManagerInterface $entityManager,
  47.         string $secretKey,
  48.         string $url
  49.     ){
  50.         $this->em       = $entityManager;
  51.         $this->password = $secretKey;
  52.         $this->sendUrl  = $url;
  54.         $dateCallback = function(
  55.             $innerObject
  56.         ){
  57.             return $innerObject instanceof DateTimeInterface ? $innerObject->format("Y-m-d H:i:s") : '';
  58.         };
  60.         $defaultContext = [
  61.             AbstractNormalizer::CALLBACKS => [
  62.                 'birthdate'  => $dateCallback,
  63.                 'team_debut' => $dateCallback,
  64.                 'start'      => $dateCallback,
  65.                 'end'        => $dateCallback,
  66.                 'startDate'  => $dateCallback,
  67.                 'endDate'    => $dateCallback,
  68.                 'dateStart'  => $dateCallback,
  69.                 'timeStart'  => $dateCallback,
  70.                 'createDate' => $dateCallback,
  71.                 'fromDate'   => $dateCallback,
  72.                 'dateCreate' => $dateCallback,
  73.                 'dateUpdate' => $dateCallback,
  74.             ],
  75.         ];
  77.         $encoders             = [new JsonEncoder()];
  78.         $classMetadataFactory = new ClassMetadataFactory(new AnnotationLoader(new AnnotationReader()));
  79.         $normalizers          = [
  80.             new ObjectNormalizer(
  81.                 $classMetadataFactory,
  82.                 null,
  83.                 null,
  84.                 null,
  85.                 null,
  86.                 null,
  87.                 $defaultContext
  88.             ),
  89.             new DateTimeNormalizer(),
  90.         ];
  92.         $this->serializer = new Serializer($normalizers, $encoders);
  93.     }
  95.     public function send(): Response
  96.     {
  97.         $jsonData = [];
  98.         $changes  = $this->em->getRepository(ChangeList::class)->findNotSent();
  100.         if(!is_null($changes) and !empty($changes)){
  101.             foreach($changes as $change){
  102.                 $json['entity_name'] = $change->getEntityName();
  103.                 $json['change_type'] = $change->getChangeType();
  105.                 if($change->getChangeType() != 'del'){
  106.                     switch($change->getEntityName()){
  107.                         case "Club":
  108.                             $club     = $this->em->getRepository(Club::class)->find($change->getChangeId());
  109.                             $jsonData = $this->serializer->serialize($club, 'json', ['groups' => 'groupClub']);
  110.                             break;
  111.                         case "Event":
  112.                             $event = $this->em->getRepository(Event::class)->find($change->getChangeId());
  114.                             if(!is_null($event)){
  115.                                 $jsonData = $this->serializer->serialize($event, 'json', ['groups' => 'groupEvent']);
  116.                             }else{
  117.                                 $jsonData = '';
  118.                                 $change->setSent(1);
  119.                             }
  120.                             break;
  121.                         case "Game":
  122.                             $game     = $this->em->getRepository(Game::class)->find($change->getChangeId());
  123.                             $jsonData = $this->serializer->serialize($game, 'json', ['groups' => 'groupGame']);
  124.                             break;
  125.                         case "Player":
  126.                             $player   = $this->em->getRepository(Player::class)->find($change->getChangeId());
  127.                             $jsonData = $this->serializer->serialize($player, 'json', ['groups' => 'groupPlayer']);
  128.                             break;
  129.                         case "Season":
  130.                             $season   = $this->em->getRepository(Season::class)->find($change->getChangeId());
  131.                             $jsonData = $this->serializer->serialize($season, 'json', ['groups' => 'groupSeason']);
  132.                             break;
  133.                         case "Stadium":
  134.                             $stadium  = $this->em->getRepository(Stadium::class)->find($change->getChangeId());
  135.                             $jsonData = $this->serializer->serialize($stadium, 'json', ['groups' => 'groupStadium']);
  136.                             break;
  137.                         case "Tournament":
  138.                             $tournament = $this->em->getRepository(Tournament::class)->find($change->getChangeId());
  139.                             $jsonData   = $this->serializer->serialize($tournament, 'json', ['groups' => 'groupTournament']);
  140.                             break;
  141.                         case "TournamentStage":
  142.                             $tournamentStage = $this->em->getRepository(TournamentStage::class)->find($change->getChangeId());
  143.                             $jsonData        = $this->serializer->serialize($tournamentStage, 'json', ['groups' => 'groupTournamentStage']);
  144.                             break;
  145.                         case "TournamentClub":
  146.                             $tournamentClub = $this->em->getRepository(TournamentClub::class)->find($change->getChangeId());
  147.                             $jsonData       = $this->serializer->serialize($tournamentClub, 'json', ['groups' => 'groupTournamentClub']);
  148.                             break;
  149.                         case "ClubNameHistory":
  150.                             $clubHistoryName = $this->em->getRepository(ClubNameHistory::class)->find($change->getChangeId());
  151.                             $jsonData        = $this->serializer->serialize($clubHistoryName, 'json');
  152.                             break;
  153.                         case "StadiumNameHistory":
  154.                             $stadiumHistoryName = $this->em->getRepository(StadiumNameHistory::class)->find($change->getChangeId());
  155.                             $jsonData           = $this->serializer->serialize($stadiumHistoryName, 'json');
  156.                             break;
  157.                         case "GameStats":
  158.                             $gameStats = $this->em->getRepository(GameStats::class)->find($change->getChangeId());
  159.                             $jsonData  = $this->serializer->serialize($gameStats, 'json', ['groups' => 'groupGameStats']);
  160.                             break;
  161.                         case "PlayerCareer":
  162.                             $career   = $this->em->getRepository(PlayerCareer::class)->find($change->getChangeId());
  163.                             $jsonData = $this->serializer->serialize($career, 'json', ['groups' => 'groupPlayerCareer']);
  164.                             break;
  165.                         case "PlayerAchievements":
  166.                             $achievements = $this->em->getRepository(PlayerAchievements::class)->find($change->getChangeId());
  167.                             $jsonData     = $this->serializer->serialize($achievements, 'json', ['groups' => 'groupPlayerAchievements']);
  168.                             break;
  169.                     }
  171.                     $jsonData = json_decode($jsonData, true);
  173.                     if(isset($jsonData['logo'])){
  174.                         if($jsonData['logo'] != ''){
  175.                             $jsonData['logo'] = ((!empty($_SERVER['HTTPS'])) ? 'https' : 'http').'://'.$_SERVER['HTTP_HOST'].$jsonData['logo'];
  176.                         }
  177.                     }
  179.                     if(isset($jsonData['logoForList'])){
  180.                         if($jsonData['logoForList'] != ''){
  181.                             $jsonData['logoForList'] = ((!empty($_SERVER['HTTPS'])) ? 'https' : 'http').'://'.$_SERVER['HTTP_HOST'].$jsonData['logoForList'];
  182.                         }
  183.                     }
  184.                 }else{
  185.                     $json['entity_name'] = $change->getEntityName();
  186.                     $json['change_type'] = $change->getChangeType();
  187.                     $jsonData['id']      = $change->getChangeId();
  188.                 }
  190.                 $hash         = md5($this->password.$change->getChangeId().$json['entity_name'].$json['change_type']);
  191.                 $json['hash'] = $hash;
  192.                 $json['data'] = $jsonData;
  194.                 $client = new Client();
  196.                 try{
  197.                     $response = $client->request(
  198.                         'POST',
  199.                         $this->sendUrl,
  200.                         [
  201.                         'auth' => ['admin', '12345'],
  202.                         'json' => $json,
  203.                         ]
  204.                     );
  206.                     $result = json_decode($response->getBody()->getContents());
  208.                     if(isset($result->status) and $result->status == 'success'){
  209.                         $change->setSent(1);
  210.                     }elseif(isset($result->status) and $result->status == 'error'){
  211.                         $change->setErrorText($result->description);
  212.                     }
  213.                 }catch(GuzzleException $e){
  214.                     $change->setErrorText("Response code: ".$e->getCode());
  215.                 }
  217.                 $change->setCount($change->getCount() + 1);
  219.                 $this->em->persist($change);
  220.                 $this->em->flush();
  221.             }
  222.         }
  224.         return new Response(
  225.             'Content',
  226.             Response::HTTP_OK,
  227.             ['content-type' => 'text/html']
  228.         );
  229.     }
  230. }