src/Controller/ArticleController.php line 186

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.         ]);
  269.     }
  270.     
  271.     return $this->json([
  272.         "articles" => $result->toArray(),
  273.     ]);
  274.     
  275.     }
  277.     /**
  278.      * @Route("/articles/categories", name="getArticlesCategories", methods={"GET","HEAD"})
  279.      */
  280.     public function getArticlesCategories(): Response
  281.     {
  282.         /** @var Categorie[]*/
  283.         $categories = $this->getDoctrine()
  284.             ->getRepository(Categorie::class)
  285.             ->findAll();
  286.         $result = new ArrayCollection();
  287.         foreach ($categories as $categorie) {
  288.             $result->add([
  289.                 "id" => $categorie->getId(),
  290.                 "libelle" => $categorie->getTitle(),
  291.             ]);
  292.         }
  293.         return $this->json([
  294.             "content" => $result->toArray(),
  295.             "status" => 200,
  296.         ]);
  297.     }
  301.        /**
  302.      * @Route("/articles/categories/withArticle", name="getArticlesCategoriesWithArticle", methods={"GET","HEAD"})
  303.      */
  304.     public function getArticlesCategoriesWithArticle(): Response
  305.     {
  306.         /** @var Categorie[]*/
  307.         $categories = $this->getDoctrine()
  308.             ->getRepository(Categorie::class)
  309.             ->findCategorieWithArticle();
  310.         return $this->json([
  311.             "content" => $categories,
  312.             "status" => 200,
  313.         ]);
  314.     }
  316.       /**
  317.      * @Route("/articles/pro/categories/withArticle", name="getArticlesCategoriesWithArticlePro", methods={"GET","HEAD"})
  318.      */
  319.         public function getArticlesCategoriesWithArticlePro(): Response
  320.         {
  321.             /** @var Categorie[]*/
  322.             $categories = $this->getDoctrine()
  323.                 ->getRepository(Categorie::class)
  324.                 ->findCategorieWithArticlePro();
  325.             return $this->json([
  326.                 "content" => $categories,
  327.                 "status" => 200,
  328.             ]);
  329.         }
  332.     /**
  333.      * @Route("/articles/pro", name="getArticlesPro", methods={"GET","HEAD"})
  334.      */
  335.     public function getArticlesPro(Request $request): Response
  336.     {
  338.         $isProValues = [1, 2];
  339.         $etat = 0;
  340.         $limit = $request->query->get('limit', null); 
  341.         
  342.         $articles = $this->getDoctrine()
  343.             ->getRepository(Article::class)
  344.             ->findByIsProAndEtat($isProValues, $etat, $limit);
  346.         $result = new ArrayCollection();
  347.         foreach ($articles as $article) {
  348.             $categorieResult = new ArrayCollection();
  349.             $articleCategoriesList = $this->getDoctrine()
  350.                 ->getRepository(ArticleCategorie::class)
  351.                 ->findBy(["id_article" => $article->getId()]);
  352.             foreach ($articleCategoriesList as $articleCategorie) {
  353.                 $categorieResult->add([
  354.                     "id" => $articleCategorie->getIdCategorie()->getId(),
  355.                     "title" => $articleCategorie->getIdCategorie()->getTitle(),
  356.                 ]);
  357.             }
  359.             $extrait = $article->getExtrait();
  360.             if ($extrait == ""){
  361.                 $extrait = strip_tags($article->getTexte());
  362.             }
  364.             $result->add([
  365.                 "id" => $article->getId(),
  366.                 "title" => $article->getTitle(),
  367.                 "subtitle" => $article->getSubtitle(),
  368.                 "date" =>  $article->getPublicationDate(),
  369.                 "slug" => $article->getSlug(),
  370.                 "source" => $article->getSource(),
  371.                 "imgUrl" => $article->getImgUrl(),
  372.                 'description' =>$extrait,
  373.                 "externalId" => $article->getExternalId(),
  374.                 "externalLink" => $article->getExternalLink(),
  375.                 "category" => $categorieResult[0],
  376.                 "categoryId" =>$categorieResult[0]['id'],
  377.                 "categoryTitle"=>$categorieResult[0]['title'],
  378.             ]);
  379.         }
  380.         return $this->json([
  381.             "articles" => $result->toArray()
  382.         ]);
  383.     }
  385.     /**
  386.      * @Route("/article/{slug}", name="getArticleBySlug", methods={"GET","HEAD"})
  387.      */
  388.     public function getArticleBySlug($slug): Response
  389.     {
  390.         $categorieResult = new ArrayCollection();
  391.         $article = $this->getDoctrine()
  392.         ->getRepository(Article::class)
  393.         ->findOneBy(["slug" => $slug]);
  394.         
  395.         $articleCategoriesList = $this->getDoctrine()
  396.             ->getRepository(ArticleCategorie::class)
  397.             ->findBy(["id_article" => $article->getId()]);
  398.         foreach ($articleCategoriesList as $articleCategorie) {
  399.             $categorieResult->add([
  400.                 "id" => $articleCategorie->getIdCategorie()->getId(),
  401.                 "title" => $articleCategorie->getIdCategorie()->getTitle(),
  402.             ]);
  403.         }
  404.         $tagResult = new ArrayCollection();
  405.         $articleTagsList = $this->getDoctrine()
  406.             ->getRepository(ArticleTag::class)
  407.             ->findBy(["id_article" => $article->getId()]);
  408.         foreach ($articleTagsList as $articleTag) {
  409.             $tagResult->add([
  410.                 "id" => $articleTag->getIdTag()->getId(),
  411.                 "title" => $articleTag->getIdTag()->getTitle(),
  412.             ]);
  413.         }
  414.         return $this->json([
  415.             "id" => $article->getId(),
  416.             "admin_id" => $article->getIdAdmin()->getId(),
  417.             "title" => $article->getTitle(),
  418.             "subtitle" => $article->getSubtitle(),
  419.             "slug" => $article->getSlug(),
  420.             "creation_date" => $article->getCreationDate(),
  421.             "publication_date" => $article->getPublicationDate(),
  422.             "source" => $article->getSource(),
  423.             "imgUrl" => $article->getImgUrl(),
  424.             "texte" => $article->getTexte(),
  425.             "is_pro" => $article->getIsPro(),
  426.             "tags" => $tagResult->toArray(),
  427.             "etat" => $article->getEtat(),
  428.             "extrait" => $article->getExtrait(),
  429.             "categories" => $categorieResult->toArray()
  430.         ]);
  431.     }
  433.      /**
  434.      * @Route("/admin-article/{id}", name="getArticleByID", methods={"GET","HEAD"})
  435.      */
  436.     public function getArticleById(Article $article): Response
  437.     {
  438.         $categorieResult = new ArrayCollection();
  439.         
  440.         $articleCategoriesList = $this->getDoctrine()
  441.             ->getRepository(ArticleCategorie::class)
  442.             ->findBy(["id_article" => $article->getId()]);
  443.         foreach ($articleCategoriesList as $articleCategorie) {
  444.             $categorieResult->add([
  445.                 "id" => $articleCategorie->getIdCategorie()->getId(),
  446.                 "title" => $articleCategorie->getIdCategorie()->getTitle(),
  447.             ]);
  448.         }
  449.         $tagResult = new ArrayCollection();
  450.         $articleTagsList = $this->getDoctrine()
  451.             ->getRepository(ArticleTag::class)
  452.             ->findBy(["id_article" => $article->getId()]);
  453.         foreach ($articleTagsList as $articleTag) {
  454.             $tagResult->add([
  455.                 "id" => $articleTag->getIdTag()->getId(),
  456.                 "title" => $articleTag->getIdTag()->getTitle(),
  457.             ]);
  458.         }
  459.         return $this->json([
  460.             "id" => $article->getId(),
  461.             "admin_id" => $article->getIdAdmin()->getId(),
  462.             "title" => $article->getTitle(),
  463.             "subtitle" => $article->getSubtitle(),
  464.             "slug" => $article->getSlug(),
  465.             "creation_date" => $article->getCreationDate(),
  466.             "publication_date" => $article->getPublicationDate(),
  467.             "source" => $article->getSource(),
  468.             "imgUrl" => $article->getImgUrl(),
  469.             "texte" => $article->getTexte(),
  470.             "is_pro" => $article->getIsPro(),
  471.             "tags" => $tagResult->toArray(),
  472.             "etat" => $article->getEtat(),
  473.             "extrait" => $article->getExtrait(),
  474.             "categories" => $categorieResult->toArray()
  475.         ]);
  476.     }
  479.     /**
  480.      * @Route("/article", name="postArticle", methods={"POST"})
  481.      */
  482.     public function postArticle(Request $request, FileUploader $fileUploader): Response
  483.     {
  484.         if (!$request->query->get('token')) {
  485.             return new Response(json_encode([
  486.                 "message" => "Pas de token n'a été spécifié",
  487.                 "status" => 401,
  488.             ]), 401);
  489.         }
  491.         $entityManager = $this->getDoctrine()->getManager();
  492.         /** @var Token */
  493.         $token = $this->getDoctrine()
  494.             ->getRepository(Token::class)
  495.             ->findOneBy(['token' =>  $request->query->get('token')]);
  496.         if (!$token || !($token->getIdAdmin())) {
  497.             return new Response(json_encode([
  498.                 "message" => "Pas de token trouvé dans la base de données. Veuillez vous reconnecter.",
  499.                 "status" => 404,
  500.             ]));
  501.         }
  503.         // get token age
  504.         $dateDiff = $token->getCreationDate()->diff(new DateTime());
  505.         // if the token if older than 7 days
  506.         if ($dateDiff->d > 7) {
  507.             $entityManager->remove($token);
  508.             $entityManager->flush();
  509.             return $this->json([
  510.                 'message' => 'Ce token est obselète. Veuillez vous reconnecter.',
  511.                 'path' => 'src/Controller/ClientController.php',
  512.                 "status" => 401,
  513.             ]);
  514.         }
  516.         $article = new Article();
  517.         if (isset($_FILES["imageAvant"]) && $_FILES['imageAvant']['size'] != 0) {
  518.             $newfilename = $fileUploader->uploadFormData($_FILES["imageAvant"], "images/article/");
  519.             $article->setImgUrl($newfilename);
  521.         }
  523.         $admin = $this->getDoctrine()
  524.         ->getRepository(Administrateur::class)
  525.         ->findBy(['id' => intval($request->query->get('admin'))]);
  527.         
  528.         $categorie = $this->getDoctrine()
  529.         ->getRepository(Categorie::class)
  530.         ->findOneBy(['id' => intval($_POST["categorie"])]);
  531.        
  532.         
  533.         $article->setTitle($_POST["titre"]);
  534.         $article->setSubTitle($_POST["sousTitre"]);
  535.         $article->setExtrait($_POST["extrait"]);
  536.         $article->setTexte($_POST["texte"]);
  537.         $article->setSource($_POST["source"]);
  538.         $article->setIsPro($_POST["type"]);
  539.         $article->setSlug($_POST["slug"]);
  540.         $article->setEtat($_POST["etat"]);
  541.         $article->setIdAdmin($admin[0]);
  542.         $article->setCreationDate(new \DateTime());
  543.         $article->setPublicationDate(new \DateTime());
  544.         $entityManager = $this->getDoctrine()->getManager();
  545.         $entityManager->persist($article);
  547.         $categorieArticle = new ArticleCategorie();
  548.         $categorieArticle->setIdArticle($article);
  549.         $categorieArticle->setIdCategorie($categorie);
  550.         $entityManager->persist($categorieArticle);
  551.         $entityManager->flush();
  553.         return $this->json([
  554.             "status" => 200,
  555.         ]);
  557.     }
  559.     
  560.     /**
  561.     * @Route("article/{id}/block", name="suspendreArticleByID", methods={"PUT"})
  562.     */
  564.     public function suspendreArticleByID(Article $article, Request $request){
  566.         if (!$request->query->get('token')) {
  567.             return new Response(json_encode([
  568.                 "message" => "Pas de token n'a été spécifié",
  569.                 "status" => 401,
  570.             ]), 401);
  571.         }
  573.         $entityManager = $this->getDoctrine()->getManager();
  574.         /** @var Token */
  575.         $token = $this->getDoctrine()
  576.             ->getRepository(Token::class)
  577.             ->findOneBy(['token' =>  $request->query->get('token')]);
  578.         if (!$token || !($token->getIdAdmin())) {
  579.             return new Response(json_encode([
  580.                 "message" => "Pas de token trouvé dans la base de données. Veuillez vous reconnecter.",
  581.                 "status" => 404,
  582.             ]));
  583.         }
  585.         // get token age
  586.         $dateDiff = $token->getCreationDate()->diff(new DateTime());
  587.         // if the token if older than 7 days
  588.         if ($dateDiff->d > 7) {
  589.             $entityManager->remove($token);
  590.             $entityManager->flush();
  591.             return $this->json([
  592.                 'message' => 'Ce token est obselète. Veuillez vous reconnecter.',
  593.                 'path' => 'src/Controller/ClientController.php',
  594.                 "status" => 401,
  595.             ]);
  596.         }
  598.         $entityManager = $this->getDoctrine()->getManager();
  599.         $article->setEtat(3);
  600.         $article->setPublicationDate(new DateTime());
  601.         $entityManager->flush();
  603.         return $this->json([
  604.             "status" => 200,
  605.         ]);
  607.     }
  609.       /**
  610.     * @Route("article/{id}/publish", name="publieArticleByID", methods={"PUT"})
  611.     */
  613.     public function publieArticleByID(Article $article, Request $request){
  615.         if (!$request->query->get('token')) {
  616.             return new Response(json_encode([
  617.                 "message" => "Pas de token n'a été spécifié",
  618.                 "status" => 401,
  619.             ]), 401);
  620.         }
  622.         $entityManager = $this->getDoctrine()->getManager();
  623.         /** @var Token */
  624.         $token = $this->getDoctrine()
  625.             ->getRepository(Token::class)
  626.             ->findOneBy(['token' =>  $request->query->get('token')]);
  627.         if (!$token || !($token->getIdAdmin())) {
  628.             return new Response(json_encode([
  629.                 "message" => "Pas de token trouvé dans la base de données. Veuillez vous reconnecter.",
  630.                 "status" => 404,
  631.             ]));
  632.         }
  634.         // get token age
  635.         $dateDiff = $token->getCreationDate()->diff(new DateTime());
  636.         // if the token if older than 7 days
  637.         if ($dateDiff->d > 7) {
  638.             $entityManager->remove($token);
  639.             $entityManager->flush();
  640.             return $this->json([
  641.                 'message' => 'Ce token est obselète. Veuillez vous reconnecter.',
  642.                 'path' => 'src/Controller/ClientController.php',
  643.                 "status" => 401,
  644.             ]);
  645.         }
  647.         $entityManager = $this->getDoctrine()->getManager();
  648.         $article->setEtat(0);
  649.         $article->setPublicationDate(new DateTime());
  650.         $entityManager->flush();
  652.         return $this->json([
  653.             "status" => 200,
  654.         ]);
  656.     }
  658.     /**
  659.      * @Route("/article/edit/{id}", name="editArticlesByID", methods={"POST"})
  660.      */
  661.     public function editArticlesByID(Article $article, Request $request, FileUploader $fileUploader) : Response
  662.     {
  663.         if (!$request->query->get('token')) {
  664.             return new Response(json_encode([
  665.                 "message" => "Pas de token n'a été spécifié",
  666.                 "status" => 401,
  667.             ]), 401);
  668.         }
  670.         $entityManager = $this->getDoctrine()->getManager();
  671.         /** @var Token */
  672.         $token = $this->getDoctrine()
  673.             ->getRepository(Token::class)
  674.             ->findOneBy(['token' =>  $request->query->get('token')]);
  675.         if (!$token || !($token->getIdAdmin())) {
  676.             return new Response(json_encode([
  677.                 "message" => "Pas de token trouvé dans la base de données. Veuillez vous reconnecter.",
  678.                 "status" => 404,
  679.             ]));
  680.         }
  682.         // get token age
  683.         $dateDiff = $token->getCreationDate()->diff(new DateTime());
  684.         // if the token if older than 7 days
  685.         if ($dateDiff->d > 7) {
  686.             $entityManager->remove($token);
  687.             $entityManager->flush();
  688.             return $this->json([
  689.                 'message' => 'Ce token est obselète. Veuillez vous reconnecter.',
  690.                 'path' => 'src/Controller/ClientController.php',
  691.                 "status" => 401,
  692.             ]);
  693.         }
  695.         if (isset($_FILES["imageAvant"]) && $_FILES['imageAvant']['size'] != 0) {
  696.                 $newfilename = $fileUploader->uploadFormData($_FILES["imageAvant"], "images/article/");
  697.                $article->setImgUrl($newfilename);
  699.         }
  700.        
  701.         $article->setTitle($_POST["titre"]);
  702.         $article->setSubTitle($_POST["sousTitre"]);
  703.         $article->setSlug($_POST["slug"]);
  704.         $article->setExtrait($_POST["extrait"]);
  705.         $article->setTexte($_POST["texte"]);
  706.         $article->setSource($_POST["source"]);
  707.         $article->setIsPro($_POST["type"]);
  708.         $article->setEtat($_POST["etat"]);
  709.         $article->setPublicationDate(new \DateTime());
  710.         $entityManager = $this->getDoctrine()->getManager();
  711.         $entityManager->persist($article);
  712.         $entityManager->flush();
  714.         $categorieArticle = $this->getDoctrine()
  715.         ->getRepository(ArticleCategorie::class)
  716.         ->findOneBy(['id_article' => $article]);
  718.         if ($_POST['categorie'] != $categorieArticle->getIdCategorie()->getId()){
  719.             $categorie = $this->getDoctrine()
  720.             ->getRepository(Categorie::class)
  721.             ->findOneBy(['id' => intval($_POST["categorie"])]);
  722.             $categorieArticle->setIdCategorie($categorie);
  723.             $entityManager->persist($categorieArticle);
  724.             $entityManager->flush();
  725.         }
  727.       
  728.         return $this->json([
  729.             "status" => 200,
  730.         ]);
  732.     }
  735.     
  736.     /**
  737.      * @Route("/articles/publish", name="getAllArticlesPublish", methods={"GET","HEAD"})
  738.      */
  739.     public function getAllArticlesPublish(Request $request): Response
  740.     {
  741.             $articles = $this->getDoctrine()
  742.                 ->getRepository(Article::class)
  743.                 ->findBy(['etat' => 0]);
  744.         $result = new ArrayCollection();
  745.         foreach ($articles as $article) {
  746.             $categorieResult = new ArrayCollection();
  747.             $articleCategoriesList = $this->getDoctrine()
  748.                 ->getRepository(ArticleCategorie::class)
  749.                 ->findBy(["id_article" => $article->getId()]);
  750.             foreach ($articleCategoriesList as $articleCategorie) {
  751.                 $categorieResult->add([
  752.                     "id" => $articleCategorie->getIdCategorie()->getId(),
  753.                     "title" => $articleCategorie->getIdCategorie()->getTitle(),
  754.                 ]);
  755.             }
  756.             $tagResult = new ArrayCollection();
  757.             $articleTagList = $this->getDoctrine()
  758.             ->getRepository(ArticleTag::class)
  759.             ->findBy(["id_article" => $article->getId()]);
  760.         foreach ($articleTagList as $articleTag) {
  761.             $tagResult->add([
  762.                 "id" => $articleTag->getIdTag()->getId(),
  763.                 "title" => $articleTag->getIdTag()->getTitle(),
  764.             ]);
  765.         }
  767.             $admin =  $this->getDoctrine()
  768.             ->getRepository(Administrateur::class)
  769.             ->findOneBy(["id" => $article->getIdAdmin()]);
  770.             $etat_libelle = "";
  771.             switch ( $article->getEtat()){
  772.                 case 0:
  773.                     $etat_libelle = "Publié";
  774.                     break;
  775.                 case 1:
  776.                     $etat_libelle = "Brouillon";
  777.                     break;
  778.                 case 2:
  779.                     $etat_libelle = "Suspendu";
  780.                     break;
  781.                 case 3:
  782.                     $etat_libelle = "Corbeille";
  783.                     break;
  784.             }
  786.             $extrait = $article->getExtrait();
  787.             if ($extrait == ""){
  788.                 $extrait = strip_tags($article->getTexte());
  789.             }
  790.             $result->add([
  791.                 "id" => $article->getId(),
  792.                 "title" => $article->getTitle(),
  793.                 "subtitle" => $article->getSubtitle(),
  794.                 "date" => $article->getPublicationDate(),
  795.                 "source" => $article->getSource(),
  796.                 "imgUrl" => $article->getImgUrl(),
  797.                 'description' => $extrait,
  798.                 "category" => $categorieResult[0],
  799.                 "categoryId" =>$categorieResult[0]['id'],
  800.                 "categoryTitle"=>$categorieResult[0]['title'],
  801.                 "tag" => $tagResult,
  802.                 "admin" => $admin->getName().' '.$admin->getLastName(),
  803.                 "isPro" => $article->getIsPro(),
  804.                 "etat_libelle" => $etat_libelle,
  805.                 "etat" => $article->getEtat()
  806.             ]);
  807.         }
  808.         return $this->json([
  809.             "articles" => $result->toArray()
  810.         ]);
  811.     }
  814. /**
  815.      * @Route("/articles/test", name="getArticlesTest", methods={"GET","HEAD"})
  816.      */
  817.     public function getArticlesTest(Request $request): Response
  818.     {
  819.         if (!$request->query->get('nom')){
  820.             return $this->json([
  821.                 "list" => array(
  822.                     array( "nom" => 'Pierre'),
  823.                     array( "nom" => 'Paul')
  824.                 )
  825.             ]);
  826.         } else {
  827.             if ($request->query->get('nom') == "Paul") {
  828.                 return $this->json([
  829.                     "list" => array(
  830.                         array( "nom" => 'Paul')
  831.                     )
  832.                 ]);
  833.             } elseif ($request->query->get('nom') == "Pierre") {
  834.                 return $this->json([
  835.                     "list" => array(
  836.                         array( "nom" => 'Pierre')
  837.                     )
  838.                 ]);
  839.             } else {
  840.                 return $this->json([
  841.                     "list" => array(
  842.                         array( "nom" => 'Jacques'),
  843.                         array( "nom" => 'Paul')
  844.                     )
  845.                 ]);
  846.             }
  847.         }
  848.        
  849.     }
  851.     
  852. }