src/Controller/ProduitsController.php line 661

Open in your IDE?
  1. <?php
  3. namespace App\Controller;
  5. use App\Entity\Produits;
  6. use App\Form\ProduitsType;
  7. use App\Repository\AccessoireRepository;
  8. use App\Repository\FamilleAccessoireRepository;
  9. use App\Repository\ProduitsRepository;
  10. use Cocur\Slugify\Slugify;
  11. use Doctrine\ORM\EntityManagerInterface;
  12. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  13. use Symfony\Component\HttpFoundation\File\Exception\FileException;
  14. use Symfony\Component\HttpFoundation\Request;
  15. use Symfony\Component\HttpFoundation\Response;
  16. use Symfony\Component\HttpFoundation\JsonResponse;
  17. use Symfony\Component\Routing\Annotation\Route;
  18. use Doctrine\ORM\Tools\Pagination\Paginator;
  19. use Symfony\Component\Security\Core\Security;
  20. use DateTime;
  21. use DateTimeZone;
  22. use App\Entity\Trace;
  23. use Symfony\Component\PropertyAccess\PropertyAccess;
  24. use Psr\Log\LoggerInterface;
  25. use Doctrine\DBAL\Connection;
  27. #[Route('/produits')]
  28. class ProduitsController extends AbstractController
  29. {
  30.     private $security;
  32.     public function __construct(Security $security)
  33.     {
  34.         $this->security = $security;
  35.     }
  37.     #[Route('/filter_produits', name: 'app_produits_filter')]
  38.     public function filter(Request $request, ProduitsRepository $produitsRepository): Response
  39.     {
  40.         $nomprenom = preg_replace('/\s+/', ' ', trim($request->query->get('nomprenom')));
  42.         // Build the query
  43.         $queryBuilder = $produitsRepository->createQueryBuilder('p')
  44.             ->where('p.IsArchive = :isArchive')
  45.             ->setParameter('isArchive', false);
  47.         if (!empty($nomprenom)) {
  48.             $queryBuilder->andWhere('p.nom LIKE :nomprenom')
  49.                 ->setParameter('nomprenom', "%$nomprenom%");
  50.         }
  52.         $queryBuilder->orderBy('p.id', 'DESC');
  54.         // Get all results without pagination
  55.         $produits = $queryBuilder->getQuery()->getResult();
  57.         return $this->render('produits/recherche.html.twig', [
  58.             'produits' => $produits,
  59.             'nomprenom' => $nomprenom, // Pass the search term to the template
  60.         ]);
  61.     }
  63. //    #[Route('/filter_produits', name: 'app_produits_filter')]
  64. //    public function filter(Request $request, ProduitsRepository $produitsRepository): Response
  65. //    {
  66. ////        $nomprenom = $request->query->get('nomprenom');
  67. //        $nomprenom = preg_replace('/\s+/', ' ', trim($request->query->get('nomprenom')));
  68. //
  69. //        $page = $request->query->getInt('page', 1);
  70. //        $limit = 5;
  71. //
  72. //        // Build the query
  73. //        $queryBuilder = $produitsRepository->createQueryBuilder('p')
  74. //        ->where('p.IsArchive = :isArchive')
  75. //        ->setParameter('isArchive', false);
  76. ////            ->andWhere('p.IsArchive = false');
  77. //
  78. //        if (!empty($nomprenom)) {
  79. //            $queryBuilder->andWhere('p.nom LIKE :nomprenom')
  80. //                ->setParameter('nomprenom', "%$nomprenom%");
  81. //        }
  82. //
  83. //        $queryBuilder->orderBy('p.id', 'DESC');
  84. //
  85. //        // Get the query
  86. //        $query = $queryBuilder->getQuery();
  87. //
  88. //        // Apply pagination
  89. //        $paginator = new Paginator($query);
  90. //        $totalItems = count($paginator);
  91. //        $totalPages = ceil($totalItems / $limit);
  92. //
  93. //        $paginator->getQuery()
  94. //            ->setFirstResult($limit * ($page - 1))
  95. //            ->setMaxResults($limit);
  96. //
  97. //        // Convert paginator to array if needed
  98. //        $produits = iterator_to_array($paginator);
  99. //
  100. //        return $this->render('produits/recherche.html.twig', [
  101. ////            'setting' => $settingsRepository->find(1),
  102. //            'produits' => $produits,
  103. //            'currentPage' => $page,
  104. //            'totalPages' => $totalPages,
  105. //            'nomprenom' => $nomprenom, // Pass the search term to the template
  106. //        ]);
  107. //    }
  110.     #[Route('/archive', name: 'app_produits_archive', methods: ['GET'])]
  111.     public function archive(Request $request, ProduitsRepository $produitsRepository, Security $security): Response
  112.     {
  113.         $user = $security->getUser();
  114.         $roles = $user->getRoles();
  116.         // Pagination
  117.         $page = $request->query->getInt('page', 1);
  118.         $limit = 10;
  120.         // Requête de base : uniquement les produits archivés
  121.         $queryBuilder = $produitsRepository->createQueryBuilder('p')
  122.             ->where('p.IsArchive = :isArchive')
  123.             ->setParameter('isArchive', true)
  124.             ->orderBy('p.id', 'DESC');
  126.         // Filtrage selon le rôle
  127. //        if (in_array('ROLE_ULTRATEX', $roles)) {
  128. //            $queryBuilder
  129. //                ->andWhere('p.societe = :societe')
  130. //                ->setParameter('societe', 'Ultratex');
  131. //        }
  132. //        elseif (in_array('ROLE_ULTRACONFECTION', $roles)) {
  133. //            $queryBuilder
  134. //                ->andWhere('p.societe = :societe')
  135. //                ->setParameter('societe', 'Ultraconfection');
  136. //        }
  137.         // ROLE_ADMIN voit tous les produits archivés
  139.         // Pagination
  140.         $paginator = new Paginator($queryBuilder);
  141.         $allproduit = $paginator->getQuery()
  142.             ->setFirstResult($limit * ($page - 1))
  143.             ->setMaxResults($limit)
  144.             ->getResult();
  146.         $totalItems = count($paginator);
  147.         $totalPages = ceil($totalItems / $limit);
  149.         return $this->render('produits/archive.html.twig', [
  150.             'produits' => $allproduit,
  151.             'currentPage' => $page,
  152.             'totalPages' => $totalPages,
  153.         ]);
  154.     }
  158.     #[Route('/', name: 'app_produits_index', methods: ['GET'])]
  159.     public function index(Request $request, ProduitsRepository $produitsRepository, Security $security): Response
  160.     {
  161.         $user = $security->getUser();
  162.         $roles = $user->getRoles();
  163. //        dump($roles);
  164.         // Configuration de la pagination
  165.         $page = $request->query->getInt('page', 1);
  166.         $limit = 10;
  168.         // Construction de la requête
  169.         $queryBuilder = $produitsRepository->createQueryBuilder('p')
  170.             ->where('p.IsArchive = :isArchive')
  171.             ->setParameter('isArchive', false)
  172.             ->orderBy('p.id', 'DESC');
  174.         // Filtrage en fonction des rôles
  175. //        if (in_array('ROLE_ULTRATEX', $roles)) {
  176. //            dump('tx');
  177. //            $queryBuilder
  178. //                ->andWhere('p.societe = :societe')
  179. //                ->setParameter('societe', 'Ultratex');
  180. //        }
  181. //        elseif (in_array('ROLE_ULTRACONFECTION', $roles)) {
  182. //            dump("conf");
  183. //            $queryBuilder
  184. //                ->andWhere('p.societe = :societe')
  185. //                ->setParameter('societe', 'Ultraconfection');
  186. //        }
  187.         // ROLE_ADMIN verra tout, donc pas de filtre supplémentaire
  189.         // Application de la pagination
  190.         $paginator = new Paginator($queryBuilder);
  192.         $allproduit = $paginator->getQuery()
  193.             ->setFirstResult($limit * ($page - 1))
  194.             ->setMaxResults($limit)
  195.             ->getResult();
  196. //        dd($allproduit);
  197.         $totalItems = count($paginator);
  198.         $totalPages = ceil($totalItems / $limit);
  199. //        dd($allproduit);
  201.         return $this->render('produits/index.html.twig', [
  202.             'produits' => $allproduit,
  203.             'currentPage' => $page,
  204.             'totalPages' => $totalPages,
  205.         ]);
  206.     }
  209. //    #[Route('/', name: 'app_produits_index', methods: ['GET'])]
  210. //    public function index(Request $request,ProduitsRepository $produitsRepository): Response
  211. //    {
  212. //
  213. //        // Configuration de la pagination
  214. //        $page = $request->query->getInt('page', 1);
  215. //        $limit = 10;
  216. //
  217. //        // Construction de la requête pour la pagination
  218. //        $queryBuilder = $produitsRepository->createQueryBuilder('p')
  219. //            ->where('p.IsArchive = :isArchive')
  220. //            ->setParameter('isArchive', false)
  221. //            ->orderBy('p.id', 'DESC');
  222. //
  223. //
  224. //        // Application de la pagination
  225. //        $paginator = new Paginator($queryBuilder);
  226. //        $allproduit = $paginator->getQuery()
  227. //            ->setFirstResult($limit * ($page - 1))
  228. //            ->setMaxResults($limit)
  229. //            ->getResult();
  230. //
  231. //        $totalItems = count($paginator);
  232. //        $totalPages = ceil($totalItems / $limit);
  233. //        return $this->render('produits/index.html.twig', [
  234. ////            'produits' => $produitsRepository->findAll(),
  235. //            'produits' =>$allproduit,
  236. //            'currentPage' => $page,
  237. //            'totalPages' => $totalPages,
  238. //        ]);
  239. //    }
  241.     #[Route('/new', name: 'app_produits_new', methods: ['GET', 'POST'])]
  242.     public function new(FamilleAccessoireRepository $familleAccessoireRepository,AccessoireRepository $accessoireRepository,Request $request, EntityManagerInterface $entityManager): Response
  243.     {
  244.         if (!$this->getUser()) {
  245.             return $this->redirectToRoute('app_login');
  246.         }
  247.         if (!$this->getUser()) {
  248.             return $this->redirectToRoute('app_login');
  249.         }
  250.         $facc = $familleAccessoireRepository->findAll();
  251.         $acc = $accessoireRepository->findBy(['IsArchive'=>false]);
  252.         $user = $this->security->getUser();
  253.         $role = $user->getRoles()[0] ?? null;
  254.         $produit = new Produits();
  255.         $form = $this->createForm(ProduitsType::class, $produit);
  256.         $form->handleRequest($request);
  258.         if ($form->isSubmitted() && $form->isValid()) {
  259.             $date = new \DateTime('now', new DateTimeZone('Africa/Tunis'));
  260.             $produit->setIsArchive(false);
  261.             $tissuStatus = $request->request->get('tissuStatus');
  262. //            dd($tissuStatus);
  263.             $societe = null;
  264.             if ($role === 'ROLE_ULTRATEX') {
  265.                 $societe = 'Ultratex';
  266.             } elseif ($role === 'ROLE_ULTRACONFECTION') {
  267.                 $societe = 'Ultraconfection';
  268.             }
  269.             $produit->setSociete($societe);
  271.             $logo = $form->get('image')->getData();
  272.             if ( $logo) {
  273.                 $originalLogoname = pathinfo( $logo->getClientOriginalName(), PATHINFO_FILENAME);
  274.                 $slugify = new Slugify();
  275.                 $a=  $slugify->slugify($originalLogoname, ['separator' => '-']);
  277.                 $newLogoname =  $a.'-'.uniqid().'.'.$logo->guessExtension();
  279.                 // Move the file to the directory where brochures are stored
  280.                 try {
  281.                     $logo->move(
  282.                         $this->getParameter('produit_directory'),
  283.                         $newLogoname
  284.                     );
  285.                 } catch (FileException $e) {
  286.                     // ... handle exception if something happens during file upload
  287.                 }
  288.                 $produit->setImage($newLogoname);
  289.             }
  290.             $produit->setDateajout($date);
  291.             $accessoires= $request->request->get('accessoire');
  293.             $accs= $accessoireRepository->findOneBy(['id'=>$accessoires,'IsArchive'=>false]);
  294. //            dd($accessoires,$accs);
  295.             $produit->setIsTissu($tissuStatus);
  296.             $produit->setAccessoire($accs);
  297.             $entityManager->persist($produit);
  298.             $entityManager->flush();
  299.             $this->addFlash('successproduit', 'Produit ajouté avec succès.');
  300.             if (!$this->getUser()) {
  301.                 return $this->redirectToRoute('app_login');
  302.             }
  303.             if (!$this->getUser()) {
  304.                 return $this->redirectToRoute('app_login');
  305.             }
  306.             // Trace de creation produit
  307.             /** @var \App\Entity\User $user */
  308.             $user = $this->security->getUser();
  309.             $role = $user->getRoles()[0] ?? null;
  310.             $email2 = $user->getEmail();
  311.             $nom = $produit->getNom();
  312.             $trace= new Trace();
  313.             $trace->setDate(new \DateTimeImmutable('now', new \DateTimeZone('Africa/Tunis')));
  314.             $trace->setEmail($email2);
  315.             $trace->setRole($role);
  316.             $trace->setAction("Création du produit '{$nom}'");
  317.             $trace->setUser($user);
  318.             $entityManager->persist($trace);
  319.             $entityManager->flush();
  320.             return $this->redirectToRoute('app_produits_index', [], Response::HTTP_SEE_OTHER);
  321.         }
  323.         return $this->renderForm('produits/new.html.twig', [
  324.             'produit' => $produit,
  325.             'form' => $form,
  326.             'acc'=>$acc,
  327.             'facc'=>$facc
  328.         ]);
  329.     }
  331.     #[Route('/{id}', name: 'app_produits_show', methods: ['GET'], requirements: ['id' => '\d+'])]
  332.     public function show(Produits $produit): Response
  333.     {
  334.         return $this->render('produits/show.html.twig', [
  335.             'produit' => $produit,
  336.         ]);
  337.     }
  339.     #[Route('/{id}/edit', name: 'app_produits_edit', methods: ['GET', 'POST'])]
  340.     public function edit(FamilleAccessoireRepository $familleAccessoireRepository,AccessoireRepository $accessoireRepository,Request $request, Produits $produit, EntityManagerInterface $entityManager): Response
  341.     {
  342.         $facc = $familleAccessoireRepository->findAll();
  343.         $acc = $accessoireRepository->findBy(['IsArchive'=>false]);
  344.         $img = $produit->getImage();
  345.         $form = $this->createForm(ProduitsType::class, $produit);
  346.         $form->handleRequest($request);
  347. //        dd($produit->getAccessoire(), $produit);
  348.         if ($form->isSubmitted() && $form->isValid()) {
  349.             $istissu = $request->request->get('tissuStatus');
  350.             $accessoire = $request->request->get('accessoire');
  351.             $accs = $accessoireRepository->findOneBy(['id'=>$accessoire,'IsArchive'=>false]);
  352. //          dd($istissu);
  353.             $logo = $form->get('image')->getData();
  354.             //detecter les champs
  355.             $produitOriginal = clone $produit;
  356.             $accessor = PropertyAccess::createPropertyAccessor();
  357.             $fields = ['nom', 'coleur', 'prix', 'image',  'tva', 'quantitelimite','stock','image'];
  358.             $changes = [];
  360.             foreach ($fields as $field) {
  361.                 $oldValue = $accessor->getValue($produitOriginal, $field);
  362.                 $newValue = $accessor->getValue($produit, $field);
  364.                 if ($oldValue !== $newValue) {
  365.                     $changes[] = "$field: '$oldValue' → '$newValue'";
  366.                 }
  367.             }
  368.             if ( $logo) {
  369.                 $originalLogoname = pathinfo( $logo->getClientOriginalName(), PATHINFO_FILENAME);
  370.                 $slugify = new Slugify();
  371.                 $a=  $slugify->slugify($originalLogoname, ['separator' => '-']);
  373.                 $newLogoname =  $a.'-'.uniqid().'.'.$logo->guessExtension();
  375.                 // Move the file to the directory where brochures are stored
  376.                 try {
  377.                     $logo->move(
  378.                         $this->getParameter('produit_directory'),
  379.                         $newLogoname
  380.                     );
  381.                 } catch (FileException $e) {
  382.                     // ... handle exception if something happens during file upload
  383.                 }
  384.                 $produit->setImage($newLogoname);
  385.             }
  386.             elseif ($logo === null) {
  387.                 $produit->setImage($img);
  388.             }
  389.             $produit->setAccessoire($accs);
  390.             $produit->setIsTissu($istissu);
  391. //           dd($produit);
  392.             
  393.             $entityManager->flush();
  394.             $this->addFlash('modifproduit', 'Produit modifié avec succès.');
  395.             /** @var \App\Entity\User $user */
  396.             $user = $this->security->getUser();
  397.             $role = $user->getRoles()[0] ?? null;
  398.             $email2 = $user->getEmail();
  399.             $trace= new Trace();
  400.             $trace->setDate(new \DateTimeImmutable('now', new \DateTimeZone('Africa/Tunis')));
  401.             $trace->setEmail($email2);
  402.             $trace->setRole($role);
  403.             $nom = $produit->getNom();
  404.             $action = "Modification du produit '{$nom}'";
  405.             /*if (!empty($changes)) {
  406.                 $action .= " | Champs modifiés : " . implode(', ', $changes);
  407.             } else {
  408.                 $action .= " | Aucun changement détecté.";
  409.             }*/
  410.             $trace->setAction($action);
  411.             $trace->setUser($user);
  412.             $entityManager->persist($trace);
  413.             $entityManager->flush();
  414.             return $this->redirectToRoute('app_produits_index', [], Response::HTTP_SEE_OTHER);
  415.         }
  418.         return $this->renderForm('produits/edit.html.twig', [
  419.             'produit' => $produit,
  420.             'form' => $form,
  421.             'acc'=>$acc,
  422.             'facc'=>$facc,
  423.             'accessoireChoisi' => $produit->getAccessoire(),
  424.         ]);
  425.     }
  427.     #[Route('/remove/{id}', name: 'app_produits_delete')]
  428.     public function delete(Request $request, Produits $produit, EntityManagerInterface $entityManager): Response
  429.     {
  430. //        if ($this->isCsrfTokenValid('delete'.$produit->getId(), $request->request->get('_token'))) {
  431.             $produit->setIsArchive(true);
  432.         $entityManager->persist($produit); // Ajout de persist pour s'assurer que le changement est suivi
  434.         //            $entityManager->remove($produit);
  435.             $entityManager->flush();
  436. //        }
  437.         // Trace Archivage du produit
  438.             /** @var \App\Entity\User $user */
  439.             $user = $this->security->getUser();
  440.             $role = $user->getRoles()[0] ?? null;
  441.             $email2 = $user->getEmail();
  442.             $nom = $produit->getNom();
  443.             $trace= new Trace();
  444.             $trace->setDate(new \DateTimeImmutable('now', new \DateTimeZone('Africa/Tunis')));
  445.             $trace->setEmail($email2);
  446.             $trace->setRole($role);
  447.             $trace->setAction("Archivage du produit '{$nom}'");
  448.             $trace->setUser($user);
  449.             $entityManager->persist($trace);
  450.             $entityManager->flush();
  451.         return $this->redirectToRoute('app_produits_index', [], Response::HTTP_SEE_OTHER);
  452.     }
  454.     #[Route('/remove-archive/{id}', name: 'app_produits_delete_archive')]
  455.     public function deletearchive(Request $request, Produits $produit, EntityManagerInterface $entityManager, Security $security): Response
  456.     {
  457.         $produit->setIsArchive(false);
  458.         $entityManager->persist($produit); // Ajout de persist pour s'assurer que le changement est suivi
  459.         $entityManager->flush();
  461.         // Trace Désarchivage du produit
  462.         $user = $security->getUser();
  463.         $role = $user->getRoles()[0] ?? null;
  464.         $email2 = $user->getEmail();
  465.         $nom = $produit->getNom();
  467.         $trace = new Trace();
  468.         $trace->setDate(new \DateTimeImmutable('now', new \DateTimeZone('Africa/Tunis')));
  469.         $trace->setEmail($email2);
  470.         $trace->setRole($role);
  471.         $trace->setAction("Désarchivage du produit '{$nom}'");
  472.         $trace->setUser($user);
  474.         $entityManager->persist($trace);
  475.         $entityManager->flush();
  477.         return $this->redirectToRoute('app_produits_archive', [], Response::HTTP_SEE_OTHER);
  478.     }
  480. //    #[Route('/remove-archive/{id}', name: 'app_produits_delete_archive')]
  481. //    public function deletearchive(Request $request, Produits $produit, EntityManagerInterface $entityManager): Response
  482. //    {
  483. ////        if ($this->isCsrfTokenValid('delete'.$produit->getId(), $request->request->get('_token'))) {
  484. //        $produit->setIsArchive(false);
  485. //        $entityManager->persist($produit);
  486. //        //            $entityManager->remove($produit);
  487. //        $entityManager->flush();
  488. ////        }
  489. //        // Trace Désarchivage du produit
  490. //            /** @var \App\Entity\User $user */
  491. //            $user = $this->security->getUser();
  492. //            $role = $user->getRoles()[0] ?? null;
  493. //            $email2 = $user->getEmail();
  494. //            $nom = $produit->getNom();
  495. //            $trace= new Trace();
  496. //            $trace->setDate(new \DateTimeImmutable('now', new \DateTimeZone('Africa/Tunis')));
  497. //            $trace->setEmail($email2);
  498. //            $trace->setRole($role);
  499. //            $trace->setAction("Désarchivage du produit '{$nom}'");
  500. //            $trace->setUser($user);
  501. //            $entityManager->persist($trace);
  502. //            $entityManager->flush();
  503. //        return $this->redirectToRoute('app_produits_archive', [], Response::HTTP_SEE_OTHER);
  504. //    }
  505.     //logique notification produits épuisés
  507. /*    #[Route('/produitsepuises', name: 'produitsepuises', methods: ['GET', 'POST'])]
  508.     public function produitsepuises(Connection $connection): JsonResponse
  509.     {
  510.         $user = $this->getUser();
  511. //        $role = $user->getRoles()[0] ?? null;
  512.         $roles = $this->getUser()->getRoles();
  514.         $sql = null;
  515.         $params = [];
  517.         if (in_array('ROLE_ULTRATEX', $roles)){
  518.             $sql = "
  519.                 SELECT * FROM produits p
  520.                 WHERE p.quantitelimite IS NOT NULL
  521.                   AND CAST(p.stock AS SIGNED) <= CAST(p.quantitelimite AS SIGNED)
  522.                   AND p.societe = :societe
  523.                 ORDER BY p.id DESC
  524.             ";
  525.             $params = ['societe' => 'Ultratex'];
  526.         }
  527.         elseif (in_array('ROLE_ULTRACONFECTION', $roles)){
  528.             $sql = "
  529.                 SELECT * FROM produits p
  530.                 WHERE p.quantitelimite IS NOT NULL
  531.                   AND CAST(p.stock AS SIGNED) <= CAST(p.quantitelimite AS SIGNED)
  532.                   AND p.societe = :societe
  533.                 ORDER BY p.id DESC
  534.             ";
  535.             $params = ['societe' => 'UltraConfection'];
  536.         } else {
  537.             return new JsonResponse([
  538.                 'nb_total' => 0,
  539.                 'suspensions' => []
  540.             ]);
  541.         }
  543.         $produits = $connection->fetchAllAssociative($sql, $params);
  545.         $response = [];
  546.         foreach ($produits as $produit) {
  547.             $response[] = [
  548.                 'id' => $produit['id'],
  549.                 'prix' => $produit['prix'],
  550.                 'nom' => $produit['nom'],
  551.                 'stock' => (int)$produit['stock'],
  552.                 'quantitelimite' => (int)$produit['quantitelimite'],
  553.             ];
  554.         }
  556.         return new JsonResponse([
  557.             'nb_total' => count($response),
  558.             'suspensions' => $response
  559.         ]);
  560.     }*/
  562.     #[Route('/produitsepuises', name: 'produitsepuises', methods: ['GET', 'POST'])]
  563.     public function produitsepuises(ProduitsRepository $produitsRepository): JsonResponse
  564.     {
  565. //        $user = $this->getUser();
  566. //        $roles = $user->getRoles();
  567. //
  568. //        if (in_array('ROLE_ULTRATEX', $roles)) {
  569. //            $societe = 'Ultratex';
  570. //        } elseif (in_array('ROLE_ULTRACONFECTION', $roles)) {
  571. //            $societe = 'UltraConfection';
  572. //        } else {
  573. //            return new JsonResponse([
  574. //                'nb_total' => 0,
  575. //                'suspensions' => []
  576. //            ]);
  577. //        }
  579.         // Récupérer tous les produits de la société
  580.         $produits = $produitsRepository->findAll();
  582.         $produitsAlerte = [];
  583.         $nbTotalAlertes = 0;
  585.         foreach ($produits as $produit) {
  586.             $alertesCouleurs = [];
  587.             $hasAlerteProduit = false;
  589.             // Vérifier les alertes par couleur (détails produit)
  590.             foreach ($produit->getDetailsproduits() as $detail) {
  591.                 $enAlerte = false;
  592.                 $message = '';
  594.                 // Récupérer les valeurs correctes
  595.                 $qte = $detail->getQte() ?? 0;
  596.                 $qtelimite = $detail->getQtelimite() ?? 0;
  598.                 if ($produit->getIsTissu()) {
  599.                     // Pour les tissus: vérifier le poids (qte = poids dans ce cas)
  600.                     if ($qtelimite > 0 && $qte < $qtelimite) {
  601.                         $enAlerte = true;
  602.                         $message = "Poids: {$qte} / Limite: {$qtelimite}";
  603.                     }
  604.                 } else {
  605.                     // Pour les non-tissus: vérifier la quantité
  606.                     if ($qtelimite > 0 && $qte < $qtelimite) {
  607.                         $enAlerte = true;
  608.                         $message = "Quantité: {$qte} / Limite: {$qtelimite}";
  609.                     }
  610.                 }
  612.                 if ($enAlerte) {
  613.                     $couleur = $detail->getCouleur();
  614.                     $alertesCouleurs[] = [
  615.                         'couleur_nom' => $couleur ? $couleur->getNom() : 'Sans couleur',
  616. //                        'couleur_code' => $couleur ? $couleur->getCode() : '#666',
  617.                         'message' => $message,
  618.                         'qte' => $qte,
  619.                         'qtelimite' => $qtelimite
  620.                     ];
  621.                     $hasAlerteProduit = true;
  622.                     $nbTotalAlertes++;
  623.                 }
  624.             }
  626.             // Vérifier les alertes au niveau produit
  627.             if (!$produit->getIsTissu()) {
  628.                 // Pour non-tissu: vérifier stock global vs quantitelimite
  629.                 $stock = $produit->getStock() ?? 0;
  630.                 $quantitelimite = $produit->getQuantitelimite() ?? 0;
  632.                 if ($quantitelimite > 0 && $stock < $quantitelimite) {
  633.                     $hasAlerteProduit = true;
  634.                     $nbTotalAlertes++;
  635.                 }
  636.             } else {
  637.                 // Pour tissu: vérifier totalepoid vs totpoidlimite
  638.                 $totalepoid = $produit->getTotalepoid() ?? 0;
  639.                 $totpoidlimite = $produit->getTotpoidlimite() ?? 0;
  641.                 if ($totpoidlimite > 0 && $totalepoid < $totpoidlimite) {
  642.                     $hasAlerteProduit = true;
  643.                     $nbTotalAlertes++;
  644.                 }
  645.             }
  647.             if ($hasAlerteProduit) {
  648.                 $produitsAlerte[] = [
  649.                     'id' => $produit->getId(),
  650.                     'nom' => $produit->getNom(),
  651.                     'reference' => $produit->getReference(),
  652.                     'is_tissu' => $produit->getIsTissu(),
  653.                     'stock' => $produit->getStock() ?? 0,
  654.                     'quantitelimite' => $produit->getQuantitelimite() ?? 0,
  655.                     'totalepoid' => $produit->getTotalepoid() ?? 0,
  656.                     'totpoidlimite' => $produit->getTotpoidlimite() ?? 0,
  657.                     'couleurs' => $alertesCouleurs
  658.                 ];
  659.             }
  660.         }
  661.         dump($nbTotalAlertes,$produitsAlerte);
  662.         return new JsonResponse([
  663.             'nb_total' => $nbTotalAlertes,
  664.             'suspensions' => $produitsAlerte
  665.         ]);
  666.     }
  668. //    #[Route('/produitsepuises', name: 'produitsepuises', methods: ['GET', 'POST'])]
  669. //    public function produitsepuises(Connection $connection,ProduitsRepository $produitsRepository): JsonResponse
  670. //    {
  671. //        $produits = $produitsRepository->findAll();
  672. ////        dump($produits);
  673. //        $user = $this->getUser();
  674. //        $roles = $user->getRoles();
  675. //
  676. //        $sql = null;
  677. //        $params = [];
  678. //
  679. //        if (in_array('ROLE_ULTRATEX', $roles)) {
  680. //            $societe = 'Ultratex';
  681. //        } elseif (in_array('ROLE_ULTRACONFECTION', $roles)) {
  682. //            $societe = 'UltraConfection';
  683. //        } else {
  684. //            return new JsonResponse([
  685. //                'nb_total' => 0,
  686. //                'suspensions' => []
  687. //            ]);
  688. //        }
  689. //
  690. //        $sql = "
  691. //    SELECT * FROM produits p
  692. //    WHERE (p.quantitelimite IS NOT NULL OR p.totpoidlimite IS NOT NULL)
  693. //    AND (
  694. //        (p.is_tissu = 1 AND CAST(p.totalepoid AS SIGNED) < CAST(p.totpoidlimite AS SIGNED))
  695. //        OR
  696. //        (COALESCE(p.is_tissu, 0) = 0 AND CAST(p.stock AS SIGNED) < CAST(p.quantitelimite AS SIGNED))
  697. //    )
  698. //    AND p.societe = :societe
  699. //    ORDER BY p.id DESC
  700. //";
  701. //
  702. //
  703. //
  704. //
  705. //        $params = ['societe' => $societe];
  706. //
  707. //        $produits = $connection->fetchAllAssociative($sql, $params);
  708. //
  709. //        $response = [];
  710. //        foreach ($produits as $produit) {
  711. //            $response[] = [
  712. //                'id' => $produit['id'],
  713. //                'prix' => $produit['prix'],
  714. //                'nom' => $produit['nom'],
  715. //                'stock' => (int) ($produit['stock'] ?? 0),
  716. //                'quantitelimite' => (int) ($produit['quantitelimite'] ?? 0),
  717. //                'totalepoid' => (float) ($produit['totalepoid'] ?? 0),
  718. //                'totpoidlimite' => (float) ($produit['totpoidlimite'] ?? 0),
  719. //                'is_tissu' => (bool) $produit['is_tissu'],
  720. //            ];
  721. //        }
  722. ////        dump(count($response),$response);
  723. //
  724. //        return new JsonResponse([
  725. //            'nb_total' => count($response),
  726. //            'suspensions' => $response
  727. //        ]);
  728. //    }
  729. //
  731. //    #[Route('/produitsepuises', name: 'produitsepuises', methods: ['GET', 'POST'])]
  732. //    public function produitsepuises(ProduitsRepository $produitsRepository): JsonResponse
  733. //    {
  734. //        $user = $this->security->getUser();
  735. //        $role = $user->getRoles()[0] ?? null;
  736. //        if ($role === 'ROLE_ULTRATEX') {
  737. //            $produits = $produitsRepository->findProduitsStockLimiteForUltratex();
  738. //        }
  739. //        elseif ($role === 'ROLE_ULTRACONFECTION') {
  740. //            $produits = $produitsRepository->findProduitsStockLimiteForUltraConfection();
  741. //        }
  742. //        //dd($produits);
  743. //        $response = [];
  744. //        foreach ($produits as $produit) {
  745. //            $response[] = [
  746. //                'id' => $produit->getId(),
  747. //                'prix' => $produit->getPrix(),
  748. //                'nom' => $produit->getNom(),
  749. //                'stock' => $produit->getStock(),
  750. //                'quantitelimite' => $produit->getQuantitelimite(),
  751. //            ];
  752. //        }
  753. //
  754. //        return new JsonResponse([
  755. //            'nb_total' => count($response),
  756. //            'suspensions' => $response
  757. //        ]);
  758. //    }
  759.     #[Route('/check-reference-used', name: 'check_reference_used', methods: ['GET', 'POST'])]
  760.     public function checkReferenceUsed(
  761.         Request $request,
  762.         ProduitsRepository $produitsRepository,
  763.         LoggerInterface $logger
  764.     ): JsonResponse {
  765.         $reference = $request->get('reference');
  766.         $logger->info('🔍 Requête AJAX reçue avec la référence : ' . $reference);
  768.         if (!$reference) {
  769.             $logger->warning(' Référence manquante dans la requête AJAX');
  770.             return new JsonResponse(['error' => 'Référence manquante'], 400);
  771.         }
  773.         $produit = $produitsRepository->findOneBy(['reference' => $reference]);
  775.         if ($produit) {
  776.             $logger->info('Référence déjà utilisée');
  777.         } else {
  778.             $logger->info('Référence libre');
  779.         }
  781.         return new JsonResponse(['used' => $produit !== null]);
  782.     }
  783. }