src/Controller/ArticleController.php line 389

Open in your IDE?
  1. <?php
  3. namespace App\Controller;
  5. use App\Entity\Administrateur;
  6. use App\Entity\Article;
  7. use App\Entity\Payment\Subscription;
  8. use App\Entity\Plan;
  9. use App\Entity\Audio;
  10. use App\Entity\Centre;
  11. use App\Entity\ArticleCategorie;
  12. use App\Entity\ArticleTag;
  13. use App\Entity\Categorie;
  14. use App\Entity\Token;
  15. use App\Entity\Tag;
  16. use App\Service\PublicFunction;
  17. use Doctrine\Common\Collections\ArrayCollection;
  18. use Psr\Log\LoggerInterface;
  19. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  20. use Symfony\Component\HttpFoundation\Request;
  21. use Symfony\Component\HttpFoundation\Response;
  22. use Symfony\Component\Routing\Annotation\Route;
  23. use DateTime;
  24. use App\Service\FileUploader;
  27. class ArticleController extends AbstractController
  28. {
  29.     /**
  30.      * @Route("/article/categorie/{id}", name="deleteArticleCategorie", methods={"DELETE"})
  31.      */
  32.     public function deleteArticleCategorie(Categorie $categorie): Response
  33.     {
  34.         $entityManager = $this->getDoctrine()->getManager();
  36.         $articleCategorie = $this->getDoctrine()
  37.         ->getRepository(ArticleCategorie::class)
  38.         ->findBy(array('id_categorie' => $categorie));
  39.         
  40.         $cat = $this->getDoctrine() 
  41.         ->getRepository(Categorie::class)
  42.         ->findOneBy(array('id' => 1));
  43.         foreach($articleCategorie as $ac){
  44.             $ac->setIdCategorie($cat);
  45.             $entityManager->persist($cat);
  46.             $entityManager->flush();
  47.         }
  48.         
  49.         $entityManager->remove($categorie);
  50.         $entityManager->flush();
  51.         return $this->json([
  52.             'message' => "Categorie has been successfully deleted",
  53.             'status' => 200,
  54.         ]);
  55.     }
  57.       /**
  58.      * @Route("/article/{id}", name="deleteArticle", methods={"DELETE"})
  59.      */
  60.     public function deleteArticle(Request $request, Article $article): Response
  61.     {
  63.         if (!$request->query->get('token')) {
  64.             return new Response(json_encode([
  65.                 "message" => "Pas de token n'a été spécifié",
  66.                 "status" => 401,
  67.             ]), 401);
  68.         }
  70.         $entityManager = $this->getDoctrine()->getManager();
  71.         /** @var Token */
  72.         $token = $this->getDoctrine()
  73.             ->getRepository(Token::class)
  74.             ->findOneBy(['token' =>  $request->query->get('token')]);
  75.         if (!$token || !($token->getIdAdmin())) {
  76.             return new Response(json_encode([
  77.                 "message" => "Pas de token trouvé dans la base de données. Veuillez vous reconnecter.",
  78.                 "status" => 404,
  79.             ]));
  80.         }
  82.         // get token age
  83.         $dateDiff = $token->getCreationDate()->diff(new DateTime());
  84.         // if the token if older than 7 days
  85.         if ($dateDiff->d > 7) {
  86.             $entityManager->remove($token);
  87.             $entityManager->flush();
  88.             return $this->json([
  89.                 'message' => 'Ce token est obselète. Veuillez vous reconnecter.',
  90.                 'path' => 'src/Controller/ClientController.php',
  91.                 "status" => 401,
  92.             ]);
  93.         }
  95.         $entityManager = $this->getDoctrine()->getManager();
  97.         $articleCategorie = $this->getDoctrine()
  98.         ->getRepository(ArticleCategorie::class)
  99.         ->findBy(array('id_article' => $article));
  100.         
  101.         foreach($articleCategorie as $ac){
  102.             $entityManager->remove($ac);
  103.             $entityManager->flush();
  104.         }
  105.         
  106.         $entityManager->remove($article);
  107.         $entityManager->flush();
  108.         return $this->json([
  109.             'message' => "Article has been successfully deleted",
  110.             'status' => 200,
  111.         ]);
  112.     }
  115.      /**
  116.       * @Route("/article/categorie", name="postCategorieArticle", methods={"POST"})
  117.     */
  118.      public function postArticleCategorie(Request $request): Response
  119.      {
  120.         if (!$request->query->get('token')) {
  121.             return new Response(json_encode([
  122.                 "message" => "Pas de token n'a été spécifié",
  123.                 "status" => 401,
  124.             ]), 401);
  125.         }
  127.         $entityManager = $this->getDoctrine()->getManager();
  128.         /** @var Token */
  129.         $token = $this->getDoctrine()
  130.             ->getRepository(Token::class)
  131.             ->findOneBy(['token' =>  $request->query->get('token')]);
  132.         if (!$token || !($token->getIdAdmin())) {
  133.             return new Response(json_encode([
  134.                 "message" => "Pas de token trouvé dans la base de données. Veuillez vous reconnecter.",
  135.                 "status" => 404,
  136.             ]));
  137.         }
  139.         // get token age
  140.         $dateDiff = $token->getCreationDate()->diff(new DateTime());
  141.         // if the token if older than 7 days
  142.         if ($dateDiff->d > 7) {
  143.             $entityManager->remove($token);
  144.             $entityManager->flush();
  145.             return $this->json([
  146.                 'message' => 'Ce token est obselète. Veuillez vous reconnecter.',
  147.                 'path' => 'src/Controller/ClientController.php',
  148.                 "status" => 401,
  149.             ]);
  150.         }
  152.         $categorie = new Categorie();
  153.         $categorie->setTitle($_POST["categorie"]);
  154.         $entityManager = $this->getDoctrine()->getManager();
  155.         $entityManager->persist($categorie);
  156.         $entityManager->flush();
  157.         return $this->json([
  158.             "message" => "Catégorie ajouté",
  159.             "status" => 200,
  160.         ]);
  161.         
  162.     }
  164.     /**
  165.      * @Route("/article/image/{slug}", name="getArticleImage", methods={"GET"})
  166.      */
  167.     public function getArticleImage($slug, PublicFunction $publicFunction): Response
  168.     {
  170.         $article = $this->getDoctrine()
  171.         ->getRepository(Article::class)
  172.         ->findOneBy(["slug" => $slug]);
  174.         if (!$article->getImgUrl())
  175.             return new Response(json_encode([
  176.                 "message" => "this article does not have an image attached to it",
  177.                 "status" => 404,
  178.             ]), 404);
  179.         return $publicFunction->replyWithFile('images/article/', $article->getImgUrl());
  180.     }
  183.     /**
  184.      * @Route("/articles", name="getArticles", methods={"GET","HEAD"})
  185.      */
  186.     public function getArticles(Request $request): Response
  187.     {
  188.         
  189.         /*  $audioss = $this->getDoctrine()->getRepository(Centre::class)->findAll();
  190.         $plan = $this->getDoctrine()->getRepository(Plan::class)->find(1);
  191.         $entityManager = $this->getDoctrine()->getManager();
  192.        // getIdGerant
  193.         foreach ($audioss as $audio) {
  194.             if ($audio->getIdGerant()->getId() == 104) {
  195.                // $audioCentre = $audio->getAudioCentre()->getCentre(); // Assuming this returns an AudioCentre object
  196.         
  197.                 $subscription = new Subscription();
  198.                 $subscription->setPlanInterval("month");
  199.                 $subscription->setPlanIntervalCount(1);
  200.                 $subscription->setQuantity(1);
  201.                 
  202.                 $subscription->setPaidAmount(0);
  203.                 $audioCentre = $audio->getAudioCentre(); // Get the associated AudioCentre
  204.         
  205.               
  206.                     $subscription->setCentre($audio);
  207.                 
  208.                 $subscription->setPlan($plan);
  209.                 $subscription->setAudio($audio->getIdGerant());
  210.                 $entityManager->persist($subscription);
  211.             }
  212.         }
  213.         
  214.         $entityManager->flush();*/
  215.         
  216.         $isProValues = [0, 2];
  217.         $etat = 0;
  218.         $limit = $request->query->get('limit', null); 
  219.         
  220.         $articles = $this->getDoctrine()
  221.         ->getRepository(Article::class)
  222.         ->findByIsProAndEtat($isProValues, $etat, $limit);
  223.     
  224.     $result = new ArrayCollection();
  225.     
  226.     foreach ($articles as $article) {
  227.         $categorieResult = new ArrayCollection();
  228.         $articleCategoriesList = $this->getDoctrine()
  229.             ->getRepository(ArticleCategorie::class)
  230.             ->findBy(["id_article" => $article->getId()]);
  231.         
  232.         foreach ($articleCategoriesList as $articleCategorie) {
  233.             $categorieResult->add([
  234.                 "id" => $articleCategorie->getIdCategorie()->getId(),
  235.                 "title" => $articleCategorie->getIdCategorie()->getTitle(),
  236.             ]);
  237.         }
  238.     
  239.         $admin = $this->getDoctrine()
  240.             ->getRepository(Administrateur::class)
  241.             ->findOneBy(["id" => $article->getIdAdmin()]);
  242.     
  243.         $extrait = $article->getExtrait();
  244.         if (empty($extrait)) {
  245.             $extrait = strip_tags($article->getTexte());
  246.         }
  247.     
  248.         // Ensure $categorieResult has elements before accessing $categorieResult[0]
  249.         $category = $categorieResult->first() ?: null; // Get the first element or null
  250.         $categoryId = $category['id'] ?? null;
  251.         $categoryTitle = $category['title'] ?? null;
  252.     
  253.         $result->add([
  254.             "id" => $article->getId(),
  255.             "title" => $article->getTitle(),
  256.             "subtitle" => $article->getSubtitle(),
  257.             "date" => $article->getPublicationDate(),
  258.             "source" => $article->getSource(),
  259.             "slug" => $article->getSlug(),
  260.             "imgUrl" => $article->getImgUrl(),
  261.             "externalId" => $article->getExternalId(),
  262.             "externalLink" => $article->getExternalLink(),
  263.             'description' => $extrait,
  264.             "category" => $category,
  265.             "categoryId" => $categoryId,
  266.             "categoryTitle" => $categoryTitle,
  267.             "admin" => $admin ? $admin->getName() . ' ' . $admin->getLastName() : null,
  268.             "isPro" => $article->getIsPro(),
  269.         ]);
  270.     }
  271.     
  272.     return $this->json([
  273.         "articles" => $result->toArray(),
  274.     ]);
  275.     
  276.     }
  278.     /**
  279.      * @Route("/articles/categories", name="getArticlesCategories", methods={"GET","HEAD"})
  280.      */
  281.     public function getArticlesCategories(): Response
  282.     {
  283.         /** @var Categorie[]*/
  284.         $categories = $this->getDoctrine()
  285.             ->getRepository(Categorie::class)
  286.             ->findAll();
  287.         $result = new ArrayCollection();
  288.         foreach ($categories as $categorie) {
  289.             $result->add([
  290.                 "id" => $categorie->getId(),
  291.                 "libelle" => $categorie->getTitle(),
  292.             ]);
  293.         }
  294.         return $this->json([
  295.             "content" => $result->toArray(),
  296.             "status" => 200,
  297.         ]);
  298.     }
  302.        /**
  303.      * @Route("/articles/categories/withArticle", name="getArticlesCategoriesWithArticle", methods={"GET","HEAD"})
  304.      */
  305.     public function getArticlesCategoriesWithArticle(): Response
  306.     {
  307.         /** @var Categorie[]*/
  308.         $categories = $this->getDoctrine()
  309.             ->getRepository(Categorie::class)
  310.             ->findCategorieWithArticle();
  311.         return $this->json([
  312.             "content" => $categories,
  313.             "status" => 200,
  314.         ]);
  315.     }
  317.       /**
  318.      * @Route("/articles/pro/categories/withArticle", name="getArticlesCategoriesWithArticlePro", methods={"GET","HEAD"})
  319.      */
  320.         public function getArticlesCategoriesWithArticlePro(): Response
  321.         {
  322.             /** @var Categorie[]*/
  323.             $categories = $this->getDoctrine()
  324.                 ->getRepository(Categorie::class)
  325.                 ->findCategorieWithArticlePro();
  326.             return $this->json([
  327.                 "content" => $categories,
  328.                 "status" => 200,
  329.             ]);
  330.         }
  333.     /**
  334.      * @Route("/articles/pro", name="getArticlesPro", methods={"GET","HEAD"})
  335.      */
  336.     public function getArticlesPro(Request $request): Response
  337.     {
  339.         $isProValues = [1];
  340.         $etat = 0;
  341.         $limit = $request->query->get('limit', null);
  343.         $articles = $this->getDoctrine()
  344.             ->getRepository(Article::class)
  345.             ->findByIsProAndEtat($isProValues, $etat, $limit);
  347.         $result = new ArrayCollection();
  348.         foreach ($articles as $article) {
  349.             $categorieResult = new ArrayCollection();
  350.             $articleCategoriesList = $this->getDoctrine()
  351.                 ->getRepository(ArticleCategorie::class)
  352.                 ->findBy(["id_article" => $article->getId()]);
  353.             foreach ($articleCategoriesList as $articleCategorie) {
  354.                 $categorieResult->add([
  355.                     "id" => $articleCategorie->getIdCategorie()->getId(),
  356.                     "title" => $articleCategorie->getIdCategorie()->getTitle(),
  357.                 ]);
  358.             }
  360.             $extrait = $article->getExtrait();
  361.             if ($extrait == ""){
  362.                 $extrait = strip_tags($article->getTexte());
  363.             }
  365.             $result->add([
  366.                 "id" => $article->getId(),
  367.                 "title" => $article->getTitle(),
  368.                 "subtitle" => $article->getSubtitle(),
  369.                 "date" =>  $article->getPublicationDate(),
  370.                 "slug" => $article->getSlug(),
  371.                 "source" => $article->getSource(),
  372.                 "imgUrl" => $article->getImgUrl(),
  373.                 'description' =>$extrait,
  374.                 "externalId" => $article->getExternalId(),
  375.                 "externalLink" => $article->getExternalLink(),
  376.                 "category" => $categorieResult[0],
  377.                 "categoryId" =>$categorieResult[0]['id'],
  378.                 "categoryTitle"=>$categorieResult[0]['title'],
  379.             ]);
  380.         }
  381.         return $this->json([
  382.             "articles" => $result->toArray()
  383.         ]);
  384.     }
  386.     /**
  387.      * @Route("/article/{slug}", name="getArticleBySlug", methods={"GET","HEAD"})
  388.      */
  389.     public function getArticleBySlug($slug): Response
  390.     {
  391.         $categorieResult = new ArrayCollection();
  392.         $article = $this->getDoctrine()
  393.         ->getRepository(Article::class)
  394.         ->findOneBy(["slug" => $slug]);
  395.         
  396.         $articleCategoriesList = $this->getDoctrine()
  397.             ->getRepository(ArticleCategorie::class)
  398.             ->findBy(["id_article" => $article->getId()]);
  399.         foreach ($articleCategoriesList as $articleCategorie) {
  400.             $categorieResult->add([
  401.                 "id" => $articleCategorie->getIdCategorie()->getId(),
  402.                 "title" => $articleCategorie->getIdCategorie()->getTitle(),
  403.             ]);
  404.         }
  405.         $tagResult = new ArrayCollection();
  406.         $articleTagsList = $this->getDoctrine()
  407.             ->getRepository(ArticleTag::class)
  408.             ->findBy(["id_article" => $article->getId()]);
  409.         foreach ($articleTagsList as $articleTag) {
  410.             $tagResult->add([
  411.                 "id" => $articleTag->getIdTag()->getId(),
  412.                 "title" => $articleTag->getIdTag()->getTitle(),
  413.             ]);
  414.         }
  415.         return $this->json([
  416.             "id" => $article->getId(),
  417.             "admin_id" => $article->getIdAdmin()->getId(),
  418.             "title" => $article->getTitle(),
  419.             "subtitle" => $article->getSubtitle(),
  420.             "slug" => $article->getSlug(),
  421.             "creation_date" => $article->getCreationDate(),
  422.             "publication_date" => $article->getPublicationDate(),
  423.             "source" => $article->getSource(),
  424.             "imgUrl" => $article->getImgUrl(),
  425.             "texte" => $article->getTexte(),
  426.             "is_pro" => $article->getIsPro(),
  427.             "tags" => $tagResult->toArray(),
  428.             "etat" => $article->getEtat(),
  429.             "extrait" => $article->getExtrait(),
  430.             "categories" => $categorieResult->toArray()
  431.         ]);
  432.     }
  434.      /**
  435.      * @Route("/admin-article/{id}", name="getArticleByID", methods={"GET","HEAD"})
  436.      */
  437.     public function getArticleById(Article $article): Response
  438.     {
  439.         $categorieResult = new ArrayCollection();
  440.         
  441.         $articleCategoriesList = $this->getDoctrine()
  442.             ->getRepository(ArticleCategorie::class)
  443.             ->findBy(["id_article" => $article->getId()]);
  444.         foreach ($articleCategoriesList as $articleCategorie) {
  445.             $categorieResult->add([
  446.                 "id" => $articleCategorie->getIdCategorie()->getId(),
  447.                 "title" => $articleCategorie->getIdCategorie()->getTitle(),
  448.             ]);
  449.         }
  450.         $tagResult = new ArrayCollection();
  451.         $articleTagsList = $this->getDoctrine()
  452.             ->getRepository(ArticleTag::class)
  453.             ->findBy(["id_article" => $article->getId()]);
  454.         foreach ($articleTagsList as $articleTag) {
  455.             $tagResult->add([
  456.                 "id" => $articleTag->getIdTag()->getId(),
  457.                 "title" => $articleTag->getIdTag()->getTitle(),
  458.             ]);
  459.         }
  460.         return $this->json([
  461.             "id" => $article->getId(),
  462.             "admin_id" => $article->getIdAdmin()->getId(),
  463.             "title" => $article->getTitle(),
  464.             "subtitle" => $article->getSubtitle(),
  465.             "slug" => $article->getSlug(),
  466.             "creation_date" => $article->getCreationDate(),
  467.             "publication_date" => $article->getPublicationDate(),
  468.             "source" => $article->getSource(),
  469.             "imgUrl" => $article->getImgUrl(),
  470.             "texte" => $article->getTexte(),
  471.             "is_pro" => $article->getIsPro(),
  472.             "tags" => $tagResult->toArray(),
  473.             "etat" => $article->getEtat(),
  474.             "extrait" => $article->getExtrait(),
  475.             "categories" => $categorieResult->toArray()
  476.         ]);
  477.     }
  480.     /**
  481.      * @Route("/article", name="postArticle", methods={"POST"})
  482.      */
  483.     public function postArticle(Request $request, FileUploader $fileUploader): Response
  484.     {
  485.         if (!$request->query->get('token')) {
  486.             return new Response(json_encode([
  487.                 "message" => "Pas de token n'a été spécifié",
  488.                 "status" => 401,
  489.             ]), 401);
  490.         }
  492.         $entityManager = $this->getDoctrine()->getManager();
  493.         /** @var Token */
  494.         $token = $this->getDoctrine()
  495.             ->getRepository(Token::class)
  496.             ->findOneBy(['token' =>  $request->query->get('token')]);
  497.         if (!$token || !($token->getIdAdmin())) {
  498.             return new Response(json_encode([
  499.                 "message" => "Pas de token trouvé dans la base de données. Veuillez vous reconnecter.",
  500.                 "status" => 404,
  501.             ]));
  502.         }
  504.         // get token age
  505.         $dateDiff = $token->getCreationDate()->diff(new DateTime());
  506.         // if the token if older than 7 days
  507.         if ($dateDiff->d > 7) {
  508.             $entityManager->remove($token);
  509.             $entityManager->flush();
  510.             return $this->json([
  511.                 'message' => 'Ce token est obselète. Veuillez vous reconnecter.',
  512.                 'path' => 'src/Controller/ClientController.php',
  513.                 "status" => 401,
  514.             ]);
  515.         }
  517.         $article = new Article();
  518.         if (isset($_FILES["imageAvant"]) && $_FILES['imageAvant']['size'] != 0) {
  519.             $newfilename = $fileUploader->uploadFormData($_FILES["imageAvant"], "images/article/");
  520.             $article->setImgUrl($newfilename);
  522.         }
  524.         $admin = $this->getDoctrine()
  525.         ->getRepository(Administrateur::class)
  526.         ->findBy(['id' => intval($request->query->get('admin'))]);
  528.         
  529.         $categorie = $this->getDoctrine()
  530.         ->getRepository(Categorie::class)
  531.         ->findOneBy(['id' => intval($_POST["categorie"])]);
  532.        
  533.         
  534.         $article->setTitle($_POST["titre"]);
  535.         $article->setSubTitle($_POST["sousTitre"]);
  536.         $article->setExtrait($_POST["extrait"]);
  537.         $article->setTexte($_POST["texte"]);
  538.         $article->setSource($_POST["source"]);
  539.         $article->setIsPro($_POST["type"]);
  540.         $article->setSlug($_POST["slug"]);
  541.         $article->setEtat($_POST["etat"]);
  542.         $article->setIdAdmin($admin[0]);
  543.         $article->setCreationDate(new \DateTime());
  544.         $article->setPublicationDate(new \DateTime());
  545.         $entityManager = $this->getDoctrine()->getManager();
  546.         $entityManager->persist($article);
  548.         $categorieArticle = new ArticleCategorie();
  549.         $categorieArticle->setIdArticle($article);
  550.         $categorieArticle->setIdCategorie($categorie);
  551.         $entityManager->persist($categorieArticle);
  552.         $entityManager->flush();
  554.         return $this->json([
  555.             "status" => 200,
  556.         ]);
  558.     }
  560.     
  561.     /**
  562.     * @Route("article/{id}/block", name="suspendreArticleByID", methods={"PUT"})
  563.     */
  565.     public function suspendreArticleByID(Article $article, Request $request){
  567.         if (!$request->query->get('token')) {
  568.             return new Response(json_encode([
  569.                 "message" => "Pas de token n'a été spécifié",
  570.                 "status" => 401,
  571.             ]), 401);
  572.         }
  574.         $entityManager = $this->getDoctrine()->getManager();
  575.         /** @var Token */
  576.         $token = $this->getDoctrine()
  577.             ->getRepository(Token::class)
  578.             ->findOneBy(['token' =>  $request->query->get('token')]);
  579.         if (!$token || !($token->getIdAdmin())) {
  580.             return new Response(json_encode([
  581.                 "message" => "Pas de token trouvé dans la base de données. Veuillez vous reconnecter.",
  582.                 "status" => 404,
  583.             ]));
  584.         }
  586.         // get token age
  587.         $dateDiff = $token->getCreationDate()->diff(new DateTime());
  588.         // if the token if older than 7 days
  589.         if ($dateDiff->d > 7) {
  590.             $entityManager->remove($token);
  591.             $entityManager->flush();
  592.             return $this->json([
  593.                 'message' => 'Ce token est obselète. Veuillez vous reconnecter.',
  594.                 'path' => 'src/Controller/ClientController.php',
  595.                 "status" => 401,
  596.             ]);
  597.         }
  599.         $entityManager = $this->getDoctrine()->getManager();
  600.         $article->setEtat(3);
  601.         $article->setPublicationDate(new DateTime());
  602.         $entityManager->flush();
  604.         return $this->json([
  605.             "status" => 200,
  606.         ]);
  608.     }
  610.       /**
  611.     * @Route("article/{id}/publish", name="publieArticleByID", methods={"PUT"})
  612.     */
  614.     public function publieArticleByID(Article $article, Request $request){
  616.         if (!$request->query->get('token')) {
  617.             return new Response(json_encode([
  618.                 "message" => "Pas de token n'a été spécifié",
  619.                 "status" => 401,
  620.             ]), 401);
  621.         }
  623.         $entityManager = $this->getDoctrine()->getManager();
  624.         /** @var Token */
  625.         $token = $this->getDoctrine()
  626.             ->getRepository(Token::class)
  627.             ->findOneBy(['token' =>  $request->query->get('token')]);
  628.         if (!$token || !($token->getIdAdmin())) {
  629.             return new Response(json_encode([
  630.                 "message" => "Pas de token trouvé dans la base de données. Veuillez vous reconnecter.",
  631.                 "status" => 404,
  632.             ]));
  633.         }
  635.         // get token age
  636.         $dateDiff = $token->getCreationDate()->diff(new DateTime());
  637.         // if the token if older than 7 days
  638.         if ($dateDiff->d > 7) {
  639.             $entityManager->remove($token);
  640.             $entityManager->flush();
  641.             return $this->json([
  642.                 'message' => 'Ce token est obselète. Veuillez vous reconnecter.',
  643.                 'path' => 'src/Controller/ClientController.php',
  644.                 "status" => 401,
  645.             ]);
  646.         }
  648.         $entityManager = $this->getDoctrine()->getManager();
  649.         $article->setEtat(0);
  650.         $article->setPublicationDate(new DateTime());
  651.         $entityManager->flush();
  653.         return $this->json([
  654.             "status" => 200,
  655.         ]);
  657.     }
  659.     /**
  660.      * @Route("/article/edit/{id}", name="editArticlesByID", methods={"POST"})
  661.      */
  662.     public function editArticlesByID(Article $article, Request $request, FileUploader $fileUploader) : Response
  663.     {
  664.         if (!$request->query->get('token')) {
  665.             return new Response(json_encode([
  666.                 "message" => "Pas de token n'a été spécifié",
  667.                 "status" => 401,
  668.             ]), 401);
  669.         }
  671.         $entityManager = $this->getDoctrine()->getManager();
  672.         /** @var Token */
  673.         $token = $this->getDoctrine()
  674.             ->getRepository(Token::class)
  675.             ->findOneBy(['token' =>  $request->query->get('token')]);
  676.         if (!$token || !($token->getIdAdmin())) {
  677.             return new Response(json_encode([
  678.                 "message" => "Pas de token trouvé dans la base de données. Veuillez vous reconnecter.",
  679.                 "status" => 404,
  680.             ]));
  681.         }
  683.         // get token age
  684.         $dateDiff = $token->getCreationDate()->diff(new DateTime());
  685.         // if the token if older than 7 days
  686.         if ($dateDiff->d > 7) {
  687.             $entityManager->remove($token);
  688.             $entityManager->flush();
  689.             return $this->json([
  690.                 'message' => 'Ce token est obselète. Veuillez vous reconnecter.',
  691.                 'path' => 'src/Controller/ClientController.php',
  692.                 "status" => 401,
  693.             ]);
  694.         }
  696.         if (isset($_FILES["imageAvant"]) && $_FILES['imageAvant']['size'] != 0) {
  697.                 $newfilename = $fileUploader->uploadFormData($_FILES["imageAvant"], "images/article/");
  698.                $article->setImgUrl($newfilename);
  700.         }
  701.        
  702.         $article->setTitle($_POST["titre"]);
  703.         $article->setSubTitle($_POST["sousTitre"]);
  704.         $article->setSlug($_POST["slug"]);
  705.         $article->setExtrait($_POST["extrait"]);
  706.         $article->setTexte($_POST["texte"]);
  707.         $article->setSource($_POST["source"]);
  708.         $article->setIsPro($_POST["type"]);
  709.         $article->setEtat($_POST["etat"]);
  710.         $article->setPublicationDate(new \DateTime());
  711.         $entityManager = $this->getDoctrine()->getManager();
  712.         $entityManager->persist($article);
  713.         $entityManager->flush();
  715.         $categorieArticle = $this->getDoctrine()
  716.         ->getRepository(ArticleCategorie::class)
  717.         ->findOneBy(['id_article' => $article]);
  719.         if ($_POST['categorie'] != $categorieArticle->getIdCategorie()->getId()){
  720.             $categorie = $this->getDoctrine()
  721.             ->getRepository(Categorie::class)
  722.             ->findOneBy(['id' => intval($_POST["categorie"])]);
  723.             $categorieArticle->setIdCategorie($categorie);
  724.             $entityManager->persist($categorieArticle);
  725.             $entityManager->flush();
  726.         }
  728.       
  729.         return $this->json([
  730.             "status" => 200,
  731.         ]);
  733.     }
  736.     
  737.     /**
  738.      * @Route("/articles/publish", name="getAllArticlesPublish", methods={"GET","HEAD"})
  739.      */
  740.     public function getAllArticlesPublish(Request $request): Response
  741.     {
  742.             $articles = $this->getDoctrine()
  743.                 ->getRepository(Article::class)
  744.                 ->findBy(['etat' => 0]);
  745.         $result = new ArrayCollection();
  746.         foreach ($articles as $article) {
  747.             $categorieResult = new ArrayCollection();
  748.             $articleCategoriesList = $this->getDoctrine()
  749.                 ->getRepository(ArticleCategorie::class)
  750.                 ->findBy(["id_article" => $article->getId()]);
  751.             foreach ($articleCategoriesList as $articleCategorie) {
  752.                 $categorieResult->add([
  753.                     "id" => $articleCategorie->getIdCategorie()->getId(),
  754.                     "title" => $articleCategorie->getIdCategorie()->getTitle(),
  755.                 ]);
  756.             }
  757.             $tagResult = new ArrayCollection();
  758.             $articleTagList = $this->getDoctrine()
  759.             ->getRepository(ArticleTag::class)
  760.             ->findBy(["id_article" => $article->getId()]);
  761.         foreach ($articleTagList as $articleTag) {
  762.             $tagResult->add([
  763.                 "id" => $articleTag->getIdTag()->getId(),
  764.                 "title" => $articleTag->getIdTag()->getTitle(),
  765.             ]);
  766.         }
  768.             $admin =  $this->getDoctrine()
  769.             ->getRepository(Administrateur::class)
  770.             ->findOneBy(["id" => $article->getIdAdmin()]);
  771.             $etat_libelle = "";
  772.             switch ( $article->getEtat()){
  773.                 case 0:
  774.                     $etat_libelle = "Publié";
  775.                     break;
  776.                 case 1:
  777.                     $etat_libelle = "Brouillon";
  778.                     break;
  779.                 case 2:
  780.                     $etat_libelle = "Suspendu";
  781.                     break;
  782.                 case 3:
  783.                     $etat_libelle = "Corbeille";
  784.                     break;
  785.             }
  787.             $extrait = $article->getExtrait();
  788.             if ($extrait == ""){
  789.                 $extrait = strip_tags($article->getTexte());
  790.             }
  791.             $result->add([
  792.                 "id" => $article->getId(),
  793.                 "title" => $article->getTitle(),
  794.                 "subtitle" => $article->getSubtitle(),
  795.                 "date" => $article->getPublicationDate(),
  796.                 "source" => $article->getSource(),
  797.                 "imgUrl" => $article->getImgUrl(),
  798.                 'description' => $extrait,
  799.                 "category" => $categorieResult[0],
  800.                 "categoryId" =>$categorieResult[0]['id'],
  801.                 "categoryTitle"=>$categorieResult[0]['title'],
  802.                 "tag" => $tagResult,
  803.                 "admin" => $admin->getName().' '.$admin->getLastName(),
  804.                 "isPro" => $article->getIsPro(),
  805.                 "etat_libelle" => $etat_libelle,
  806.                 "etat" => $article->getEtat()
  807.             ]);
  808.         }
  809.         return $this->json([
  810.             "articles" => $result->toArray()
  811.         ]);
  812.     }
  815. /**
  816.      * @Route("/articles/test", name="getArticlesTest", methods={"GET","HEAD"})
  817.      */
  818.     public function getArticlesTest(Request $request): Response
  819.     {
  820.         if (!$request->query->get('nom')){
  821.             return $this->json([
  822.                 "list" => array(
  823.                     array( "nom" => 'Pierre'),
  824.                     array( "nom" => 'Paul')
  825.                 )
  826.             ]);
  827.         } else {
  828.             if ($request->query->get('nom') == "Paul") {
  829.                 return $this->json([
  830.                     "list" => array(
  831.                         array( "nom" => 'Paul')
  832.                     )
  833.                 ]);
  834.             } elseif ($request->query->get('nom') == "Pierre") {
  835.                 return $this->json([
  836.                     "list" => array(
  837.                         array( "nom" => 'Pierre')
  838.                     )
  839.                 ]);
  840.             } else {
  841.                 return $this->json([
  842.                     "list" => array(
  843.                         array( "nom" => 'Jacques'),
  844.                         array( "nom" => 'Paul')
  845.                     )
  846.                 ]);
  847.             }
  848.         }
  849.        
  850.     }
  852.     
  853. }