src/Controller/InternalApiController.php line 94

  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;
  53.         $dateCallback = function(
  54.             $innerObject
  55.         ){
  56.             return $innerObject instanceof DateTimeInterface ? $innerObject->format("Y-m-d H:i:s") : '';
  57.         };
  59.         $defaultContext = [
  60.             AbstractNormalizer::CALLBACKS => [
  61.                 'birthdate'  => $dateCallback,
  62.                 'team_debut' => $dateCallback,
  63.                 'start'      => $dateCallback,
  64.                 'end'        => $dateCallback,
  65.                 'startDate'  => $dateCallback,
  66.                 'endDate'    => $dateCallback,
  67.                 'dateStart'  => $dateCallback,
  68.                 'timeStart'  => $dateCallback,
  69.                 'createDate' => $dateCallback,
  70.                 'fromDate'   => $dateCallback,
  71.                 'dateCreate' => $dateCallback,
  72.                 'dateUpdate' => $dateCallback,
  73.             ],
  74.         ];
  76.         $encoders             = [new JsonEncoder()];
  77.         $classMetadataFactory = new ClassMetadataFactory(new AnnotationLoader(new AnnotationReader()));
  78.         $normalizers          = [
  79.             new ObjectNormalizer(
  80.                 $classMetadataFactory,
  81.                 null,
  82.                 null,
  83.                 null,
  84.                 null,
  85.                 null,
  86.                 $defaultContext
  87.             ),
  88.             new DateTimeNormalizer(),
  89.         ];
  91.         $this->serializer = new Serializer($normalizers, $encoders);
  92.     }
  94.     public function send(): Response
  95.     {
  96.         $jsonData = [];
  97.         $changes  = $this->em->getRepository(ChangeList::class)->findNotSent();
  99.         if(!is_null($changes) and !empty($changes)){
  100.             foreach($changes as $change){
  101.                 $json['entity_name'] = $change->getEntityName();
  102.                 $json['change_type'] = $change->getChangeType();
  104.                 if($change->getChangeType() != 'del'){
  105.                     switch($change->getEntityName()){
  106.                         case "Club":
  107.                             $club     = $this->em->getRepository(Club::class)->find($change->getChangeId());
  108.                             $jsonData = $this->serializer->serialize($club, 'json', ['groups' => 'groupClub']);
  109.                             break;
  110.                         case "Event":
  111.                             $event = $this->em->getRepository(Event::class)->find($change->getChangeId());
  113.                             if(!is_null($event)){
  114.                                 $jsonData = $this->serializer->serialize($event, 'json', ['groups' => 'groupEvent']);
  115.                             }else{
  116.                                 $jsonData = '';
  117.                                 $change->setSent(1);
  118.                             }
  119.                             break;
  120.                         case "Game":
  121.                             $game     = $this->em->getRepository(Game::class)->find($change->getChangeId());
  122.                             $jsonData = $this->serializer->serialize($game, 'json', ['groups' => 'groupGame']);
  123.                             break;
  124.                         case "Player":
  125.                             $player   = $this->em->getRepository(Player::class)->find($change->getChangeId());
  126.                             $jsonData = $this->serializer->serialize($player, 'json', ['groups' => 'groupPlayer']);
  127.                             break;
  128.                         case "Season":
  129.                             $season   = $this->em->getRepository(Season::class)->find($change->getChangeId());
  130.                             $jsonData = $this->serializer->serialize($season, 'json', ['groups' => 'groupSeason']);
  131.                             break;
  132.                         case "Stadium":
  133.                             $stadium  = $this->em->getRepository(Stadium::class)->find($change->getChangeId());
  134.                             $jsonData = $this->serializer->serialize($stadium, 'json', ['groups' => 'groupStadium']);
  135.                             break;
  136.                         case "Tournament":
  137.                             $tournament = $this->em->getRepository(Tournament::class)->find($change->getChangeId());
  138.                             $jsonData   = $this->serializer->serialize($tournament, 'json', ['groups' => 'groupTournament']);
  139.                             break;
  140.                         case "TournamentStage":
  141.                             $tournamentStage = $this->em->getRepository(TournamentStage::class)->find($change->getChangeId());
  142.                             $jsonData        = $this->serializer->serialize($tournamentStage, 'json', ['groups' => 'groupTournamentStage']);
  143.                             break;
  144.                         case "TournamentClub":
  145.                             $tournamentClub = $this->em->getRepository(TournamentClub::class)->find($change->getChangeId());
  146.                             $jsonData       = $this->serializer->serialize($tournamentClub, 'json', ['groups' => 'groupTournamentClub']);
  147.                             break;
  148.                         case "ClubNameHistory":
  149.                             $clubHistoryName = $this->em->getRepository(ClubNameHistory::class)->find($change->getChangeId());
  150.                             $jsonData        = $this->serializer->serialize($clubHistoryName, 'json');
  151.                             break;
  152.                         case "StadiumNameHistory":
  153.                             $stadiumHistoryName = $this->em->getRepository(StadiumNameHistory::class)->find($change->getChangeId());
  154.                             $jsonData           = $this->serializer->serialize($stadiumHistoryName, 'json');
  155.                             break;
  156.                         case "GameStats":
  157.                             $gameStats = $this->em->getRepository(GameStats::class)->find($change->getChangeId());
  158.                             $jsonData  = $this->serializer->serialize($gameStats, 'json', ['groups' => 'groupGameStats']);
  159.                             break;
  160.                         case "PlayerCareer":
  161.                             $career   = $this->em->getRepository(PlayerCareer::class)->find($change->getChangeId());
  162.                             $jsonData = $this->serializer->serialize($career, 'json', ['groups' => 'groupPlayerCareer']);
  163.                             break;
  164.                         case "PlayerAchievements":
  165.                             $achievements = $this->em->getRepository(PlayerAchievements::class)->find($change->getChangeId());
  166.                             $jsonData     = $this->serializer->serialize($achievements, 'json', ['groups' => 'groupPlayerAchievements']);
  167.                             break;
  168.                     }
  170.                     $jsonData = json_decode($jsonData, true);
  172.                     if(isset($jsonData['logo'])){
  173.                         if($jsonData['logo'] != ''){
  174.                             $jsonData['logo'] = ((!empty($_SERVER['HTTPS'])) ? 'https' : 'http').'://'.$_SERVER['HTTP_HOST'].$jsonData['logo'];
  175.                         }
  176.                     }
  178.                     if(isset($jsonData['logoForList'])){
  179.                         if($jsonData['logoForList'] != ''){
  180.                             $jsonData['logoForList'] = ((!empty($_SERVER['HTTPS'])) ? 'https' : 'http').'://'.$_SERVER['HTTP_HOST'].$jsonData['logoForList'];
  181.                         }
  182.                     }
  183.                 }else{
  184.                     $json['entity_name'] = $change->getEntityName();
  185.                     $json['change_type'] = $change->getChangeType();
  186.                     $jsonData['id']      = $change->getChangeId();
  187.                 }
  189.                 $hash         = md5($this->password.$change->getChangeId().$json['entity_name'].$json['change_type']);
  190.                 $json['hash'] = $hash;
  191.                 $json['data'] = $jsonData;
  193.         //print_r($jsonData);
  194.                 $client = new Client();
  195.         //file_put_contents("./test.tzt",json_encode($json));
  196.                 try{
  197.                     $response = $client->request(
  198.                         'POST',
  199.                         $this->sendUrl,
  200.                         [
  201.                         'auth' => ['admin', '12345'],
  202.                         'json' => $json,
  203.                         ]
  204.                     );
  205.                     $result = json_decode($response->getBody()->getContents());
  206.             //print_r($result);
  207.                     if(isset($result->status) and $result->status == 'success'){
  208.                         $change->setSent(1);
  209.                     }elseif(isset($result->status) and $result->status == 'error'){
  210.                         $change->setErrorText($result->description);
  211.                     }
  212.                 }catch(GuzzleException $e){
  213.                     $change->setErrorText("Response code: ".$e->getCode());
  214.                 }
  216.                 $change->setCount($change->getCount() + 1);
  218.                 $this->em->persist($change);
  219.                 $this->em->flush();
  220.             }
  221.         }
  223.         return new Response(
  224.             'Content',
  225.             Response::HTTP_OK,
  226.             ['content-type' => 'text/html']
  227.         );
  228.     }
  229. }