src/Controller/Admin/CommandeCrudController.php line 230

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 AbstractBaseCrudController
  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', methods: ['POST'])]
  210.     public function showByEquipeDetail(CommandArticle $commande, $parentId, Request $request, EntityManagerInterface $entityManager): Response
  211.     {
  212.         $this->validateRequestCsrfToken($request, 'delete');
  213.         $id = $commande->getId();
  214.         $url = $this->adminUrlGenerator
  215.             ->setController(CommandeCrudController::class)
  216.             ->setAction(Action::EDIT)
  217.             ->setEntityId($parentId)
  218.             ->generateUrl();
  220.         $entityManager->remove($commande);
  221.         $entityManager->flush();
  223.         return $this->redirect($url);
  224.     }
  226.     #[Route('/show/cart', name: 'show_cart')]
  227.     public function showCart(RequestStack $requestStack, EntityManagerInterface $entityManager): Response
  228.     {
  229.         $session = $requestStack->getSession();
  230.         $listCommand = $session->get('listCommand', []);
  231.         $somme = 0;
  232.         $newList = [];
  233.         foreach ($listCommand as $elem) {
  234.             $ca = new CommandArticle();
  235.             $find = $entityManager->getRepository(Article::class)->find($elem['id']);
  236.             $ca->setArticle($find);
  237.             $ca->setQuantite($elem['quantity']);
  238.             $somme = $somme + ($find->getPrix() * $elem['quantity']);
  239.             $ca->setPrixUnitaire($find->getPrix());
  240.             array_push($newList, $ca);
  241.         }
  242.         return $this->render('commande/index.html.twig', ['listCommand' => $newList, 'somme' => $somme]);
  243.     }
  245.     #[Route('/make/command/delete/{id}', name: 'make_command_delete', methods: ['POST'])]
  246.     public function deleteCommand(Request $request, $id, RequestStack $requestStack): Response
  247.     {
  248.         $this->validateRequestCsrfToken($request, 'ajax');
  249.         $session = $requestStack->getSession();
  250.         $listCommand = $session->get('listCommand', []);
  251.         $exist = false;
  252.         $i = 0;
  253.         while ($i < count($listCommand) && $exist == false) {
  254.             if ($listCommand[$i]['id'] == $id) {
  255.                 $exist = true;
  256.                 array_splice($listCommand, $i, 1);
  257.             } else {
  258.                 $i++;
  259.             }
  260.         }
  261.         $session->set('listCommand', $listCommand);
  262.         //return $this->render('commande/index.html.twig',['listCommand' => $listCommand]);
  263.         return $this->redirectToRoute('show_cart');
  264.     }
  265.     #[Route('/make/article/delete/{id}', name: 'make_article_delete', methods: ['POST'])]
  266.     public function deleteCommand2(Request $request, CommandArticle $command, EntityManagerInterface $entityManager): JsonResponse
  267.     {
  268.         $this->validateRequestCsrfToken($request, 'ajax');
  269.         $entityManager->remove($command);
  270.         $entityManager->flush();
  272.         return new JsonResponse(['data' => $command], Response::HTTP_OK, ['Content-Type', 'application/json']);
  273.     }
  275.     #[Route('/delete/command/{id}', name: 'delete_command', methods: ['POST'])]
  276.     public function deleteCommand3(Request $request, Commande $command, EntityManagerInterface $entityManager): Response
  277.     {
  278.         $this->validateRequestCsrfToken($request, 'delete');
  279.         $entityManager->remove($command);
  280.         $entityManager->flush();
  281.         return $this->redirectToRoute('index_article');
  282.     }
  284.     /**
  285.      * @Route("/make/command", name="make_command", methods={"POST"})
  286.      */
  287.     public function add(Request $request, RequestStack $requestStack, SerializerInterface $serializer, Security $security): JsonResponse
  288.     {
  289.         $this->validateRequestCsrfToken($request, 'ajax');
  291.         $session = $requestStack->getSession();
  292.         $listCommand = $session->get('listCommand', []);
  294.         $data = json_decode($request->getContent(), true);
  296.         $exist = false;
  297.         $i = 0;
  298.         while ($i < count($listCommand) && $exist == false) {
  299.             if ($listCommand[$i]['id'] == $data['id']) {
  300.                 $exist = true;
  301.             } else {
  302.                 $i++;
  303.             }
  304.         }
  305.         if ($exist == true) {
  306.             $listCommand[$i]['quantity'] = $data["quantity"];
  307.         } else {
  308.             array_push($listCommand, $data);
  309.         }
  311.         $session->set('listCommand', $listCommand);
  312.         return new JsonResponse(['data' => $listCommand], Response::HTTP_OK, ['Content-Type', 'application/json']);
  313.     }
  315.      /**
  316.      * @Route("/make/command/after/save/{id}/{quantity}", name="make_command_after_save", methods={"POST"})
  317.      */
  318.     public function addAfterSave(CommandArticle $command, $quantity, Request $request, EntityManagerInterface $entityManager): JsonResponse
  319.     {
  320.         $this->validateRequestCsrfToken($request, 'ajax');
  322.         $command->setQuantite($quantity);
  323.         $entityManager->persist($command);
  324.         $entityManager->flush();
  327.         return new JsonResponse(['data' => 'done'], Response::HTTP_OK, ['Content-Type', 'application/json']);
  328.     }
  330.     /**
  331.      * @Route("/refuse/command/{id}/{motifs}", name="refuse_command", methods={"POST"})
  332.      */
  333.     public function refuseCommand(Commande $command, $motifs, Request $request, EntityManagerInterface $entityManager): JsonResponse
  334.     {
  335.         $this->validateRequestCsrfToken($request, 'ajax');
  337.         $command->setMotifs($motifs);
  338.         $command->setEtat('Refuse');
  339.         $entityManager->persist($command);
  340.         $entityManager->flush();
  341.         return new JsonResponse(['data' => 'done'], Response::HTTP_OK, ['Content-Type', 'application/json']);
  342.     }
  344.     #[Route('/make/command/confirm', name: 'make_command_confirm')]
  345.     public function showByArticleDetail(Request $request, EntityManagerInterface $entityManager, 
  346.     Security $security, RequestStack $requestStack,
  347.     GouvernoratRepository $gouvernoratRepository,
  348.     UniteRegionalRepository $uniteRegionalRepository,
  349.     AdresseRepository $adresseRepository,
  350.     NotificationManager $notificationManager
  351.     ): Response
  352.     {
  353.         if ($request->isMethod('POST')) {
  354.             $this->validateRequestCsrfToken($request, 'submit');
  355.         }
  357.         // $data = json_decode($request->getContent(), true);
  358.         $session = $requestStack->getSession();
  359.         $listCommandArticle = $session->get('listCommand', []);
  360.         $edit_demande_url =  $this->adminUrlGenerator
  361.                 ->setController(CommandeCrudController::class)
  362.                 ->setAction(Action::INDEX)
  363.                 ->generateUrl();
  364.         if (count($listCommandArticle) > 0) {
  365.             $commande = new Commande();
  366.             $sommeT = 0;
  367.             foreach ($listCommandArticle as $elem) {
  368.                 $somme = 0;
  369.                 $commandeArticle = new CommandArticle();
  370.                 $find = $entityManager->getRepository(Article::class)->find($elem['id']);
  371.                 $commandeArticle->setArticle($find);
  372.                 $commandeArticle->setQuantite($elem['quantity']);
  373.                 $somme = $somme + ($find->getPrix() * $elem['quantity']);
  374.                 $commandeArticle->setPrixUnitaire($find->getPrix());
  375.                 // $entityManager->persist($commandeArticle);
  376.                 $commande->addCommande($commandeArticle);
  377.                 $sommeT = $sommeT + $somme;
  378.             }
  379.             $commande->setTotalPrice($sommeT);
  380.             $commande->setDate(new \DateTime());
  381.             $commande->setMotifs("");
  382.             $commande->setEmail($request->request->get('email', ' '));
  383.             $commande->setAdresse($request->request->get('adresse', ' '));
  384.             $commande->setTel($request->request->get('tel', ' '));
  385.             $commande->setUser($security->getUser());
  386.             $uniteRegionals = $uniteRegionalRepository->findAll();
  387.                 foreach($uniteRegionals as $uniteRegional){
  388.                    $adresse = $adresseRepository->findOneBy(
  389.                     [
  390.                         'id' => $uniteRegional->getAdresse(),
  391.                         'gouvernorat' => (int)$request->request->get('gouvernourat', null)
  392.                     ]);
  393.                 }
  394.             $gouv = $gouvernoratRepository->findOneBy(['id' => (int)$request->request->get('gouvernourat', null)]);
  396.             $commande->setGouvernorat($gouv);
  397.             if($adresse){
  398.                 $commande->setAdresseUNITE($adresse->getAdresse());
  399.                 $commande->setCODEPOSTALUNITE($adresse->getCodePostale());
  400.             }
  401.          
  402.             $listCommand = [];
  403.             $session->set('listCommand', $listCommand);
  405.             $this->addFlash('success', $this->trans('flash.order_sent'));
  407.             $entityManager->persist($commande);
  408.             $entityManager->flush();
  409.             $notification_message = 'Nouvelle Commande !   ';
  410.             $admins = $this->em->getRepository(User::class)->findByRole('ROLE_ADMIN');
  412.             foreach($admins as $admin){
  413.                 $notificationManager->pushMessage('Nouvelle Commande !', $notification_message, $admin, $edit_demande_url);
  415.             }
  416.         }
  417.         //return $this->render('commande/index.html.twig',['listCommand' => $listCommand, 'somme' => $sommeT]);
  418.         //return $this->redirectToRoute('show_article_detail', ['id' => $article->getId()]);
  419.         return $this->redirectToRoute('show_cart');
  420.     }
  422.     #[Route('/command/detail/{id}', name: 'command_detail')]
  423.     public function detailCommand(Commande $command,
  424.      EntityManagerInterface $entityManager, 
  425.     UniteRegionalRepository $uniteRegionalRepository,
  426.     AdresseRepository $adresseRepository
  427.     ): Response
  428.     {
  429.         $somme = 0;
  430.         foreach ($command->getCommandes() as $elem) {
  431.             $somme = $somme + ($elem->getPrixUnitaire() * $elem->getQuantite());
  432.         }
  433.         $command->setTotalPrice($somme);
  434.         $entityManager->persist($command);
  435.         $entityManager->flush();
  436.         $gouv = $command->getGouvernorat()->getId();
  437.         $unite_regional  = $uniteRegionalRepository->findByGouvernorat($gouv);
  438.        
  439.        
  441.         if (!empty($unite_regional)) {
  442.             $adresse = $adresseRepository->findById($unite_regional[0]->getAdresse()->getId());
  443.             $adresse = $adresse[0]; // Access the first element if it exists
  444.             $unite_regional = $unite_regional[0];
  445.             $adresseEtat = true;
  447.         } else {
  448.             // Handle the case when the address is not found
  449.             // You can set $adresse to a default value or show an error message.
  450.             // For example, you can set $adresse to an empty array:
  451.             $adresse = [];
  452.             $unite_regional=[];
  453.             $adresseEtat = false;
  454.         }
  455.                 return $this->render('commande/commande_detail.html.twig', [
  456.          'command' => $command,
  457.          'unite_regional' =>$unite_regional, 
  458.          'adresseEtat' =>$adresseEtat, 
  459.          'adresse' => $adresse]);
  460.     }
  462.     #[Route('/command/history/', name: 'command_history')]
  463.     public function historyCommand(Security $security, Request $request, EntityManagerInterface $entityManager, PaginatorInterface $paginator): Response
  464.     {
  465.         $donnees = $entityManager->getRepository(Commande::class)->findBy(["user" => $security->getUser()], ['id' => 'DESC']);
  466.         $commands = $paginator->paginate(
  467.             $donnees,
  468.             $request->query->getInt('page', 1),
  469.             10
  470.         );
  471.         return $this->render('commande/commande_history.html.twig', ['commands' => $commands]);
  472.     }
  474.     public function excelExport(EntityManagerInterface $entityManager, ExportExl $exportExlService) {
  476.         $data = $entityManager->getRepository(Commande::class)->findAll();
  477.         $file_full_name =  $exportExlService->xlsExportModel($data);
  478.         return $this->file($file_full_name);
  479.     }
  480.     public function configureFilters(Filters $filters): Filters
  481.     {
  482.         return $filters
  483.         ->add(ArrayFilter::new('etat', 'Etat')->setChoices(array_combine(Commande::STATUS_ARRAY, Commande::STATUS_ARRAY)));
  484.     }
  487.     #[Route('/notif/countCommandArticleByUser', name: 'count_command_article_by_user')]
  488. public function countCommandArticleByUser(RequestStack $requestStack, EntityManagerInterface $entityManager): JsonResponse
  489. {
  490.     $session = $requestStack->getSession();
  491.         $listCommand = $session->get('listCommand', []);
  492.         $count = 0;
  493.         $newList = [];
  494.         foreach ($listCommand as $elem) {
  495.             $ca = new CommandArticle();
  496.             $find = $entityManager->getRepository(Article::class)->find($elem['id']);
  497.             $ca->setArticle($find);
  498.             $ca->setQuantite($elem['quantity']);
  499.             $count = $count + 1;
  500.          
  501.         }
  503.     return $this->json(['count' => $count]);
  504. }
  505. }