src/Controller/Admin/CommandeCrudController.php line 229

Open in your IDE?
  1. <?php
  3. namespace App\Controller\Admin;
  5. use App\Entity\Article;
  6. use App\Entity\CommandArticle;
  7. use App\Entity\Commande;
  8. use App\Entity\User;
  9. use App\Service\NotificationManager;
  10. use DateTime;
  11. use EasyCorp\Bundle\EasyAdminBundle\Controller\AbstractCrudController;
  12. use EasyCorp\Bundle\EasyAdminBundle\Field\AssociationField;
  13. use EasyCorp\Bundle\EasyAdminBundle\Field\ChoiceField;
  14. use EasyCorp\Bundle\EasyAdminBundle\Field\CollectionField;
  15. use EasyCorp\Bundle\EasyAdminBundle\Field\IdField;
  16. use EasyCorp\Bundle\EasyAdminBundle\Field\IntegerField;
  17. use EasyCorp\Bundle\EasyAdminBundle\Field\TextareaField;
  18. use EasyCorp\Bundle\EasyAdminBundle\Field\TextField;
  19. use App\Form\CommandArticleType;
  20. use App\Repository\AdresseRepository;
  21. use App\Repository\GouvernoratRepository;
  22. use App\Repository\UniteRegionalRepository;
  23. use Doctrine\ORM\EntityManager;
  24. use EasyCorp\Bundle\EasyAdminBundle\Field\NumberField;
  25. use EasyCorp\Bundle\EasyAdminBundle\Config\Crud;
  26. use EasyCorp\Bundle\EasyAdminBundle\Field\DateField;
  27. use Symfony\Component\Routing\Annotation\Route;
  28. use Doctrine\ORM\EntityManagerInterface;
  29. use Symfony\Component\HttpFoundation\Response;
  30. use Symfony\Component\HttpFoundation\Request;
  31. use EasyCorp\Bundle\EasyAdminBundle\Router\AdminUrlGenerator;
  32. use EasyCorp\Bundle\EasyAdminBundle\Config\Action;
  33. use EasyCorp\Bundle\EasyAdminBundle\Config\Actions;
  34. use EasyCorp\Bundle\EasyAdminBundle\Context\AdminContext;
  35. use EasyCorp\Bundle\EasyAdminBundle\Field\Field;
  36. use Symfony\Component\HttpFoundation\JsonResponse;
  37. use Symfony\Component\Routing\RouterInterface;
  38. use Symfony\Component\Serializer\SerializerInterface;
  39. use Symfony\Component\Security\Core\Security;
  40. use Symfony\Component\HttpFoundation\RequestStack;
  41. use Knp\Component\Pager\PaginatorInterface;
  42. use EasyCorp\Bundle\EasyAdminBundle\Config\Assets;
  43. use EasyCorp\Bundle\EasyAdminBundle\Config\Asset;
  44. use EasyCorp\Bundle\EasyAdminBundle\Field\HiddenField;
  45. use App\Service\ExportExl;
  46. use EasyCorp\Bundle\EasyAdminBundle\Filter\ArrayFilter;
  47. use EasyCorp\Bundle\EasyAdminBundle\Config\Filters;
  52. class CommandeCrudController extends AbstractCrudController
  53. {
  55.     public $em;
  56.     private $adminUrlGenerator;
  58.     private $request;
  59.      /**
  60.      * @param EntityManagerInterface $em
  61.      */
  62.     public function __construct(EntityManagerInterface $em, RequestStack $request, AdminUrlGenerator $adminUrlGenerator)
  63.     {
  64.         $this->em = $em;
  65.         $this->adminUrlGenerator = $adminUrlGenerator;
  66.     }
  68.     public static function getEntityFqcn(): string
  69.     {
  70.         return Commande::class;
  71.     }
  73.     public function configureAssets(Assets $assets): Assets
  74.     {
  75.         return $assets->addJsFile(Asset::new('js/commandJs.js')->defer());
  76.     }
  79.     public function configureFields(string $pageName): iterable
  80.     {
  81.         return [
  82.             HiddenField::new('id')->hideOnIndex(),
  83.             AssociationField::new('user', 'nom utilisateur')->hideOnForm(),
  84.             DateField::new('date', 'Date')->setFormTypeOption('disabled', 'disabled')->setFormTypeOption('disabled', 'disabled'),
  85.             Field::new('tel','Tel')->setFormTypeOption('disabled', 'disabled')->setFormTypeOptions(["attr" => ['min' => '0', 'maxlength' => 8 ,'pattern'=>'\d{8}', 'oninput'=>"this.value = this.value.replace(/[^0-9.]/g, '').replace(/(\..*)\./g, '$1');"]])->setRequired(true),
  86.             TextField::new('email', 'Email')->setFormTypeOption('disabled', 'disabled'),
  87.             TextField::new('etat', 'Etat')->setFormTypeOption('disabled', 'disabled'),
  88.             // TextareaField::new('motifs', 'Motif de refus')->hideOnIndex(),
  89.             NumberField::new('totalPrice')->setFormTypeOption('disabled', 'disabled')->hideOnIndex(),
  90.             // CollectionField::new('commandes', 'Commandes')
  91.             //     ->allowAdd(true)
  92.             //     ->allowDelete(true)
  93.             //     ->setEntryIsComplex(true)
  94.             //     ->setEntryType(CommandArticleType::class)
  95.             //     ->setFormTypeOptions([
  96.             //         'by_reference' => 'true',
  97.             //         'mapped' => true,
  98.             //         'required' => true
  99.             //     ])->hideOnIndex()
  100.         ];
  101.     }
  103.     public function configureActions(Actions $actions): Actions
  104.     {
  106.         $excelExport = Action::new('excelExport', 'Excel')
  107.         ->setIcon('fa fa-download')
  108.         ->linkToCrudAction('excelExport')
  109.         ->setCssClass('btn')
  110.         ->createAsGlobalAction();
  111.         $actions->add(Crud::PAGE_INDEX, Action::DETAIL)
  112.             ->add(Crud::PAGE_INDEX, $excelExport)
  113.             ->remove(Crud::PAGE_INDEX, Action::NEW)
  114.             ->remove(Crud::PAGE_DETAIL, Action::EDIT)
  115.             ->remove(Crud::PAGE_EDIT, Action::SAVE_AND_CONTINUE)
  116.             ->remove(Crud::PAGE_EDIT, Action::SAVE_AND_RETURN)
  117.             ->remove(Crud::PAGE_INDEX, Action::DETAIL)
  118.             ->update(Crud::PAGE_INDEX, Action::EDIT, function (Action $action) {
  119.                 return $action->setLabel('Visualiser');
  120.             })
  121.             ->update(Crud::PAGE_NEW, Action::SAVE_AND_RETURN, function (Action $action) {
  122.                 return $action->setLabel('Enregistrer');
  123.             });
  124.         ;
  126.         $valider = Action::new('valider', 'Valider', 'fa fa-check-circle')
  127.             ->linkToCrudAction('validerLCommande')->displayIf(static function ($entity) {
  128.                 return $entity->getEtat() == 'En cours';
  129.             });
  131.         $refuser = Action::new('refuser', 'Refuser', 'fa fa-ban')
  132.             ->linkToUrl("#")->setHtmlAttributes(['id' => 'refuseBtn'])->displayIf(static function ($entity) {
  133.                 return $entity->getEtat() == 'En cours';
  134.             });
  136.         return $actions
  138.             ->add(Crud::PAGE_EDIT, $valider)
  139.           //  ->add(Crud::PAGE_EDIT, $refuser)
  140.             ->add(Crud::PAGE_INDEX, $valider)
  141.         ;
  142.     }
  144.     public function validerLCommande(EntityManagerInterface $entityManager,  RouterInterface $router ,AdminContext $context , NotificationManager  $notificationManager)
  145.     {
  146.         $lcommande = $context->getEntity()->getInstance();
  147.        
  148.         $lCommandArticle = $entityManager->getRepository(CommandArticle::class)->findBy([
  149.             'Commande' => $lcommande->getId()
  150.         ]);     
  151.            foreach ($lCommandArticle as $commandArticle) {
  152.             $qnt = 0;
  153.             $qnt = $commandArticle->getQuantite();
  154.             $article = $commandArticle->getArticle()->getId();
  155.             $larticleRepository = $entityManager->getRepository(Article::class);
  156.             $larticleRepository->updateArticleQuantity($commandArticle);
  157.             
  158.            }
  160.        $lcommande->setEtat('Valide');
  161.         $entityManager->persist($lcommande);
  162.         $entityManager->flush();
  164.         $url = $this->adminUrlGenerator
  165.             ->setController(CommandeCrudController::class)
  166.             ->setAction(Action::INDEX)
  167.             ->setEntityId($lcommande->getId())
  168.             ->generateUrl();
  170.             $urlCommande = $router->generate('command_detail', ['id' => $lcommande->getId()]);
  171.             $user = $entityManager->getRepository(User::class)->find($lcommande->getUser());
  172.            
  173.             $notification_message = 'Votre Commande a été validée !' . $lcommande->getId() . ' ';
  174.             $notificationManager->pushMessage('Votre Commande a été validée !', $notification_message, $user, $urlCommande);
  175.         return $this->redirect($url);
  177.         
  178.     }
  180.     // public function refuserLCommande(RequestStack $request, EntityManagerInterface $entityManager, AdminContext $context)
  181.     // {
  182.     //     $lcommande = $context->getEntity()->getInstance();
  183.     //     // $lcommande->setMotifs($context->getEntity()->getInstance()->getMotifs());
  184.     //     $lcommande->setEtat('Refuse');
  186.     //     $entityManager->persist($lcommande);
  187.     //     $entityManager->flush();
  189.     //     $url = $this->adminUrlGenerator
  190.     //         ->setController(CommandeCrudController::class)
  191.     //         ->setAction(Action::EDIT)
  192.     //         ->setEntityId($lcommande->getId())
  193.     //         ->generateUrl();
  195.     //     return $this->redirect($url);
  196.     // }
  198.     final public function configureCrud(Crud $crud): Crud
  199.     {
  200.         return $crud
  201.             ->setPageTitle(Crud::PAGE_INDEX, 'Liste des Commandes')
  202.             ->overrideTemplates([
  203.                 //'crud/new' => 'admin/Commande/Commande_edit.html.twig',
  204.                 'crud/edit' => 'admin/commande/commande_edit.html.twig',
  206.             ]);
  207.     }
  209.     #[Route('/delete/command/article/{id}/{parentId}', name: 'delete_command_article')]
  210.     public function showByEquipeDetail(CommandArticle $commande, $parentId, Request $request, EntityManagerInterface $entityManager): Response
  211.     {
  212.         $id = $commande->getId();
  213.         $url = $this->adminUrlGenerator
  214.             ->setController(CommandeCrudController::class)
  215.             ->setAction(Action::EDIT)
  216.             ->setEntityId($parentId)
  217.             ->generateUrl();
  219.         $entityManager->remove($commande);
  220.         $entityManager->flush();
  222.         return $this->redirect($url);
  223.     }
  225.     #[Route('/show/cart', name: 'show_cart')]
  226.     public function showCart(RequestStack $requestStack, EntityManagerInterface $entityManager): Response
  227.     {
  228.         $session = $requestStack->getSession();
  229.         $listCommand = $session->get('listCommand', []);
  230.         $somme = 0;
  231.         $newList = [];
  232.         foreach ($listCommand as $elem) {
  233.             $ca = new CommandArticle();
  234.             $find = $entityManager->getRepository(Article::class)->find($elem['id']);
  235.             $ca->setArticle($find);
  236.             $ca->setQuantite($elem['quantity']);
  237.             $somme = $somme + ($find->getPrix() * $elem['quantity']);
  238.             $ca->setPrixUnitaire($find->getPrix());
  239.             array_push($newList, $ca);
  240.         }
  241.         return $this->render('commande/index.html.twig', ['listCommand' => $newList, 'somme' => $somme]);
  242.     }
  244.     #[Route('/make/command/delete/{id}', name: 'make_command_delete')]
  245.     public function deleteCommand($id, RequestStack $requestStack): Response
  246.     {
  247.         $session = $requestStack->getSession();
  248.         $listCommand = $session->get('listCommand', []);
  249.         $exist = false;
  250.         $i = 0;
  251.         while ($i < count($listCommand) && $exist == false) {
  252.             if ($listCommand[$i]['id'] == $id) {
  253.                 $exist = true;
  254.                 array_splice($listCommand, $i, 1);
  255.             } else {
  256.                 $i++;
  257.             }
  258.         }
  259.         $session->set('listCommand', $listCommand);
  260.         //return $this->render('commande/index.html.twig',['listCommand' => $listCommand]);
  261.         return $this->redirectToRoute('show_cart');
  262.     }
  263.     #[Route('/make/article/delete/{id}', name: 'make_article_delete')]
  264.     public function deleteCommand2(CommandArticle $command, EntityManagerInterface $entityManager): JsonResponse
  265.     {
  266.         $entityManager->remove($command);
  267.         $entityManager->flush();
  269.         return new JsonResponse(['data' => $command], Response::HTTP_OK, ['Content-Type', 'application/json']);
  270.     }
  272.     #[Route('/delete/command/{id}', name: 'delete_command')]
  273.     public function deleteCommand3(Commande $command, EntityManagerInterface $entityManager): Response
  274.     {
  275.         //dd($command);
  276.         $entityManager->remove($command);
  277.         $entityManager->flush();
  278.         return $this->redirectToRoute('index_article');
  279.     }
  281.     /**
  282.      * @Route("/make/command", name="make_command", methods={"POST"})
  283.      */
  284.     public function add(Request $request, RequestStack $requestStack, SerializerInterface $serializer, Security $security): JsonResponse
  285.     {
  286.         $session = $requestStack->getSession();
  287.         $listCommand = $session->get('listCommand', []);
  289.         $data = json_decode($request->getContent(), true);
  291.         $exist = false;
  292.         $i = 0;
  293.         while ($i < count($listCommand) && $exist == false) {
  294.             if ($listCommand[$i]['id'] == $data['id']) {
  295.                 $exist = true;
  296.             } else {
  297.                 $i++;
  298.             }
  299.         }
  300.         if ($exist == true) {
  301.             $listCommand[$i]['quantity'] = $data["quantity"];
  302.         } else {
  303.             array_push($listCommand, $data);
  304.         }
  306.         $session->set('listCommand', $listCommand);
  307.         return new JsonResponse(['data' => $listCommand], Response::HTTP_OK, ['Content-Type', 'application/json']);
  308.     }
  310.      /**
  311.      * @Route("/make/command/after/save/{id}/{quantity}", name="make_command_after_save", methods={"POST"})
  312.      */
  313.     public function addAfterSave(CommandArticle $command, $quantity, Request $request, EntityManagerInterface $entityManager): JsonResponse
  314.     {
  315.         $command->setQuantite($quantity);
  316.         $entityManager->persist($command);
  317.         $entityManager->flush();
  320.         return new JsonResponse(['data' => 'done'], Response::HTTP_OK, ['Content-Type', 'application/json']);
  321.     }
  323.     /**
  324.      * @Route("/refuse/command/{id}/{motifs}", name="refuse_command", methods={"POST"})
  325.      */
  326.     public function refuseCommand(Commande $command, $motifs, Request $request, EntityManagerInterface $entityManager): JsonResponse
  327.     {
  328.         $command->setMotifs($motifs);
  329.         $command->setEtat('Refuse');
  330.         $entityManager->persist($command);
  331.         $entityManager->flush();
  332.         return new JsonResponse(['data' => 'done'], Response::HTTP_OK, ['Content-Type', 'application/json']);
  333.     }
  335.     #[Route('/make/command/confirm', name: 'make_command_confirm')]
  336.     public function showByArticleDetail(Request $request, EntityManagerInterface $entityManager, 
  337.     Security $security, RequestStack $requestStack,
  338.     GouvernoratRepository $gouvernoratRepository,
  339.     UniteRegionalRepository $uniteRegionalRepository,
  340.     AdresseRepository $adresseRepository,
  341.     NotificationManager $notificationManager
  342.     ): Response
  343.     {
  344.         // $data = json_decode($request->getContent(), true);
  345.         $session = $requestStack->getSession();
  346.         $listCommandArticle = $session->get('listCommand', []);
  347.         $edit_demande_url =  $this->adminUrlGenerator
  348.                 ->setController(CommandeCrudController::class)
  349.                 ->setAction(Action::INDEX)
  350.                 ->generateUrl();
  351.         if (count($listCommandArticle) > 0) {
  352.             $commande = new Commande();
  353.             $sommeT = 0;
  354.             foreach ($listCommandArticle as $elem) {
  355.                 $somme = 0;
  356.                 $commandeArticle = new CommandArticle();
  357.                 $find = $entityManager->getRepository(Article::class)->find($elem['id']);
  358.                 $commandeArticle->setArticle($find);
  359.                 $commandeArticle->setQuantite($elem['quantity']);
  360.                 $somme = $somme + ($find->getPrix() * $elem['quantity']);
  361.                 $commandeArticle->setPrixUnitaire($find->getPrix());
  362.                 // $entityManager->persist($commandeArticle);
  363.                 $commande->addCommande($commandeArticle);
  364.                 $sommeT = $sommeT + $somme;
  365.             }
  366.             $commande->setTotalPrice($sommeT);
  367.             $commande->setDate(new \DateTime());
  368.             $commande->setMotifs("");
  369.             $commande->setEmail($request->request->get('email', ' '));
  370.             $commande->setAdresse($request->request->get('adresse', ' '));
  371.             $commande->setTel($request->request->get('tel', ' '));
  372.             $commande->setUser($security->getUser());
  373.             $uniteRegionals = $uniteRegionalRepository->findAll();
  374.                 foreach($uniteRegionals as $uniteRegional){
  375.                    $adresse = $adresseRepository->findOneBy(
  376.                     [
  377.                         'id' => $uniteRegional->getAdresse(),
  378.                         'gouvernorat' => (int)$request->request->get('gouvernourat', null)
  379.                     ]);
  380.                 }
  381.             $gouv = $gouvernoratRepository->findOneBy(['id' => (int)$request->request->get('gouvernourat', null)]);
  383.             $commande->setGouvernorat($gouv);
  384.             if($adresse){
  385.                 $commande->setAdresseUNITE($adresse->getAdresse());
  386.                 $commande->setCODEPOSTALUNITE($adresse->getCodePostale());
  387.             }
  388.          
  389.             $listCommand = [];
  390.             $session->set('listCommand', $listCommand);
  392.             $this->addFlash('success', 'votre commande a bien été envoyée!');
  394.             $entityManager->persist($commande);
  395.             $entityManager->flush();
  396.             $notification_message = 'Nouvelle Commande !   ';
  397.             $admins = $this->em->getRepository(User::class)->findByRole('ROLE_ADMIN');
  399.             foreach($admins as $admin){
  400.                 $notificationManager->pushMessage('Nouvelle Commande !', $notification_message, $admin, $edit_demande_url);
  402.             }
  403.         }
  404.         //return $this->render('commande/index.html.twig',['listCommand' => $listCommand, 'somme' => $sommeT]);
  405.         //return $this->redirectToRoute('show_article_detail', ['id' => $article->getId()]);
  406.         return $this->redirectToRoute('show_cart');
  407.     }
  409.     #[Route('/command/detail/{id}', name: 'command_detail')]
  410.     public function detailCommand(Commande $command,
  411.      EntityManagerInterface $entityManager, 
  412.     UniteRegionalRepository $uniteRegionalRepository,
  413.     AdresseRepository $adresseRepository
  414.     ): Response
  415.     {
  416.         $somme = 0;
  417.         foreach ($command->getCommandes() as $elem) {
  418.             $somme = $somme + ($elem->getPrixUnitaire() * $elem->getQuantite());
  419.         }
  420.         $command->setTotalPrice($somme);
  421.         $entityManager->persist($command);
  422.         $entityManager->flush();
  423.         $gouv = $command->getGouvernorat()->getId();
  424.         $unite_regional  = $uniteRegionalRepository->findByGouvernorat($gouv);
  425.        
  426.        
  428.         if (!empty($unite_regional)) {
  429.             $adresse = $adresseRepository->findById($unite_regional[0]->getAdresse()->getId());
  430.             $adresse = $adresse[0]; // Access the first element if it exists
  431.             $unite_regional = $unite_regional[0];
  432.             $adresseEtat = true;
  434.         } else {
  435.             // Handle the case when the address is not found
  436.             // You can set $adresse to a default value or show an error message.
  437.             // For example, you can set $adresse to an empty array:
  438.             $adresse = [];
  439.             $unite_regional=[];
  440.             $adresseEtat = false;
  441.         }
  442.                 return $this->render('commande/commande_detail.html.twig', [
  443.          'command' => $command,
  444.          'unite_regional' =>$unite_regional, 
  445.          'adresseEtat' =>$adresseEtat, 
  446.          'adresse' => $adresse]);
  447.     }
  449.     #[Route('/command/history/', name: 'command_history')]
  450.     public function historyCommand(Security $security, Request $request, EntityManagerInterface $entityManager, PaginatorInterface $paginator): Response
  451.     {
  452.         $donnees = $entityManager->getRepository(Commande::class)->findBy(["user" => $security->getUser()], ['id' => 'DESC']);
  453.         $commands = $paginator->paginate(
  454.             $donnees,
  455.             $request->query->getInt('page', 1),
  456.             10
  457.         );
  458.         return $this->render('commande/commande_history.html.twig', ['commands' => $commands]);
  459.     }
  461.     public function excelExport(EntityManagerInterface $entityManager, ExportExl $exportExlService) {
  463.         $data = $entityManager->getRepository(Commande::class)->findAll();
  464.         $file_full_name =  $exportExlService->xlsExportModel($data);
  465.         return $this->file($file_full_name);
  466.     }
  467.     public function configureFilters(Filters $filters): Filters
  468.     {
  469.         return $filters
  470.         ->add(ArrayFilter::new('etat', 'Etat')->setChoices(array_combine(Commande::STATUS_ARRAY, Commande::STATUS_ARRAY)));
  471.     }
  474.     #[Route('/notif/countCommandArticleByUser', name: 'count_command_article_by_user')]
  475. public function countCommandArticleByUser(RequestStack $requestStack, EntityManagerInterface $entityManager): JsonResponse
  476. {
  477.     $session = $requestStack->getSession();
  478.         $listCommand = $session->get('listCommand', []);
  479.         $count = 0;
  480.         $newList = [];
  481.         foreach ($listCommand as $elem) {
  482.             $ca = new CommandArticle();
  483.             $find = $entityManager->getRepository(Article::class)->find($elem['id']);
  484.             $ca->setArticle($find);
  485.             $ca->setQuantite($elem['quantity']);
  486.             $count = $count + 1;
  487.          
  488.         }
  490.     return $this->json(['count' => $count]);
  491. }
  492. }