src/Controller/CategorieController.php line 42

Open in your IDE?
  1. <?php
  2. namespace App\Controller;
  3. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  4. use Symfony\Component\HttpFoundation\Response;
  5. use Symfony\Component\Routing\Annotation\Route;
  6. use App\Repository\CategorieRepository;
  7. use Knp\Component\Pager\PaginatorInterface;
  8. use Symfony\Component\HttpFoundation\Request;
  9. use App\Form\CategorieType;
  10. use Doctrine\ORM\EntityManagerInterface;
  11. use Symfony\Component\Security\Core\Security;
  12. use App\Entity\Categorie;
  13. use App\Entity\Article;
  14. class CategorieController extends AbstractController
  15. {
  16.     private $security;
  17.     public function __construct(Security $security)
  18.     {
  19.         $this->security $security;
  20.     }
  21.     #[Route('/categorie'name'app_categorie')]
  22.     public function index(): Response
  23.     {
  24.         return $this->render('categorie/index.html.twig', [
  25.             'controller_name' => 'CategorieController',
  26.         ]);
  27.     }
  28.     //LISTES DES CATEGORIES
  29.     #[Route('/categorieliste'name'app_liste_categorie')]
  30.     public function list(CategorieRepository $categorieRepository,Request $request,PaginatorInterface $paginator): Response
  31.     {
  32.         
  33.         $categories $categorieRepository->findAll();
  34.         $queryBuilder $categorieRepository->createQueryBuilder('c');
  35.          /* PAGINATION */
  36.          $pagination $paginator->paginate(
  37.             $queryBuilder// Requête paginée
  38.             $request->query->getInt('page'1), // Numéro de page
  39.             // Nbx d'éléments par page
  40.         );
  41.         return $this->render('categorie/list.html.twig', [
  42.             'categories' => $categories,
  43.             'pagination' => $pagination,
  44.         ]);
  45.     }
  46.     #[Route('/categorieajout'name'app_ajout_categorie')]
  47.     public function new(Request $requestEntityManagerInterface $entityManagerCategorieRepository $categorieRepository): Response
  48.     {
  49.         #$categories = $categorieRepository->findAll();
  50.         $categories = new Categorie();
  51.         $form $this->createForm(CategorieType::class, $categories);
  52.         //permet d'hydrater
  53.         $form->handleRequest($request);
  54.         if ($form->isSubmitted() && $form->isValid()) {
  55.             $entityManager->persist($categories);
  56.             $entityManager->flush();
  57.             $this->addFlash('success''Categorie ajouté avec succès!');
  58.             return $this->redirectToRoute('app_ajout_article'); 
  59.         }
  60.         return $this->render('categorie/new.html.twig', [
  61.             'form' => $form->createView(),
  62.             'categories' => $categories,
  63.         ]);
  64.     }
  65.     #[Route('/categoriesuppression/{id}'name'app_suppression_categorie')]
  66.     public function delete(Request $requestEntityManagerInterface $entityManager $id): Response
  67.     {
  68.         $categorie $entityManager->getRepository(Categorie::class)->find($id);
  69.         if (!$categorie) {
  70.             throw $this->createNotFoundException('La catégorie n\'existe pas');
  71.         }
  72.         // Vérifier que l'utilisateur connecté est le créateur de la catégorie 
  73.         $user $this->getUser();
  74.         $articles $categorie->getHaves();
  75.         
  76.         // Vérifier que l'USER connecté est le créateur de la catégorie
  77.         $userIsOwner false;
  78.         foreach ($articles as $article) {
  79.             if ($article->getUser() === $user) {
  80.                 $userIsOwner true;
  81.                 break;
  82.             }
  83.         }
  84.         if (!$userIsOwner) {
  85.             throw $this->createAccessDeniedException('Vous n\'êtes pas autorisé à supprimer cette catégorie');
  86.         }
  87.        // Supprimer les articles et les posts associés
  88.     foreach ($articles as $article) {
  89.         foreach ($article->getBelongs() as $post) {
  90.             $entityManager->remove($post);
  91.         }
  92.         $entityManager->remove($article);
  93.     }
  94.             $entityManager->remove($categorie);
  95.             $entityManager->flush();
  96.             return $this->redirectToRoute('app_mes_categories');  
  97.     }
  98.     #[Route('/categoriemodification/{id}'name'app_modification_categorie')]
  99.     public function edit(Request $requestCategorieRepository $categorieRepositoryEntityManagerInterface $entityManager$id): Response
  100.     {
  101.         $categories $categorieRepository->findAll();
  102.         //Recupere la catégorie avec ID
  103.         $categoriedeID $entityManager->getRepository(Categorie::class)->find($id);
  104.         if (!$categoriedeID) {
  105.             throw $this->createNotFoundException('La catégorie n\'existe pas');
  106.         }
  107.     
  108.         // Récupérer l'user connecté
  109.         $user $this->getUser();
  110.     
  111.         // Vérifier que l'user connecté a des articles dans cette catégorie
  112.         $articles $categoriedeID->getHaves();
  113.         $userIsOwner false;
  114.         foreach ($articles as $article) {
  115.             if ($article->getUser() === $user) {
  116.                 $userIsOwner true;
  117.                 break;
  118.             }
  119.         }
  120.     
  121.         // Création et traitement du formulaire
  122.         $form $this->createForm(CategorieType::class, $categoriedeID);
  123.         $form->handleRequest($request);
  124.     
  125.         if ($form->isSubmitted() && $form->isValid()) {
  126.             $entityManager->flush();
  127.             return $this->redirectToRoute('app_mes_categories');
  128.         }
  129.     
  130.         return $this->render('categorie/edit.html.twig', [
  131.             'categorie' => $categoriedeID,
  132.             'form' => $form->createView(),
  133.             'categories' => $categories,
  134.         ]);
  135.     }
  136.     
  137. //MES CATEGORIES 
  138. //AFFICHE LES CATEGORIES MAIS montre qu'1 catégorie -> se réfere au ID de table CATEGORIE
  139.    #[Route('/MesCategories'name'app_mes_categories')]
  140.    public function mescategories(EntityManagerInterface $entityManager): Response
  141.    {  
  142.        $user $this->getUser();
  143.        // Récupérer les catégories crées par un mm USER
  144.        $articles $entityManager->getRepository(Article::class)->findBy(['user' => $user]);
  145.        $categories = [];
  146.     
  147.     foreach ($articles as $article) {
  148.         //Entité article -> getCategorie permet de récupérer la catégorie issue de la table article
  149.         $categorie $article->getCategorie();
  150.         //in_array cherche la 1er valeur ds un Tableau 2eme valeur
  151.         if ($categorie && !in_array($categorie$categories)) {
  152.             $categories[] = $categorie;
  153.         }
  154.     }
  155.        return $this->render('categorie/mescategories.html.twig', [
  156.            'categories' => $categories,
  157.        ]);
  158.    }
  159.    
  160. }