src/Controller/ImmeubleController.php line 107

  1. <?php
  3. namespace App\Controller;
  5. use App\Entity\Articles;
  6. use App\Entity\Categories;
  7. use App\Entity\Images;
  8. use App\Entity\Immeubles;
  9. use App\Entity\ImmeubleVariable;
  10. use App\Repository\ArticlesRepository;
  11. use App\Repository\BoutiquesRepository;
  12. use App\Repository\CategoriesRepository;
  13. use App\Repository\ImagesRepository;
  14. use App\Repository\ImmeublesRepository;
  15. use App\Repository\QuartiersRepository;
  16. use App\Repository\UserRepository;
  17. use App\Repository\VariableConstantsRepository;
  18. use App\Repository\VariablesRepository;
  19. use App\Repository\VillesRepository;
  20. use App\services\ImageOptimizer;
  21. use Doctrine\ORM\EntityManagerInterface;
  22. use JetBrains\PhpStorm\Immutable;
  23. use Knp\Component\Pager\PaginatorInterface;
  24. use phpDocumentor\Reflection\Types\Boolean;
  25. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  26. use Symfony\Component\HttpFoundation\File\Exception\FileException;
  27. use Symfony\Component\HttpFoundation\Request;
  28. use Symfony\Component\HttpFoundation\Response;
  29. use Symfony\Component\Notifier\Notification\Notification;
  30. use Symfony\Component\Notifier\NotifierInterface;
  31. use Symfony\Component\Routing\Annotation\Route;
  33. #[Route('/immeuble', name: 'app_immeuble')]
  34. class ImmeubleController extends AbstractController
  35. {
  36.     private CategoriesRepository $categoriesRepository;
  37.     private VariablesRepository $variablesRepository ;
  38.     private VariableConstantsRepository $variableConstantsRepository;
  39.     private VillesRepository $villesRepository ;
  40.     private QuartiersRepository $quartiersRepository ;
  41.     private ImmeublesRepository $immeublesRepository ;
  42.     private UserRepository $userRepository ;
  43.     private ImagesRepository $imagesRepository;
  44.     private ImageOptimizer $imageOptimizer ;
  46.     private BoutiquesRepository $boutiqueRepository;
  48.     /**
  49.      * @param CategoriesRepository $categoriesRepository
  50.      * @param VariablesRepository $variablesRepository
  51.      * @param VariableConstantsRepository $variableConstantsRepository
  52.      * @param VillesRepository $villesRepository
  53.      * @param QuartiersRepository $quartiersRepository
  54.      * @param ImmeublesRepository $immeublesRepository
  55.      * @param UserRepository $userRepository
  56.      * @param ImagesRepository $imagesRepository
  57.      */
  59.     public function __construct(CategoriesRepository $categoriesRepository, VariablesRepository $variablesRepository,
  60.                                 VariableConstantsRepository $variableConstantsRepository, VillesRepository $villesRepository,
  61.                                 QuartiersRepository $quartiersRepository, ImmeublesRepository $immeublesRepository,
  62.                                 UserRepository $userRepository, ImagesRepository $imagesRepository, ImageOptimizer $imageOptimizer, BoutiquesRepository $boutiqueRepository)
  63.     {
  64.         $this->categoriesRepository = $categoriesRepository;
  65.         $this->variablesRepository = $variablesRepository;
  66.         $this->variableConstantsRepository = $variableConstantsRepository;
  67.         $this->villesRepository = $villesRepository;
  68.         $this->quartiersRepository = $quartiersRepository;
  69.         $this->immeublesRepository = $immeublesRepository;
  70.         $this->userRepository = $userRepository;
  71.         $this->ImagesRepository = $imagesRepository;
  72.         $this->imageOptimizer = $imageOptimizer;
  73.         $this->boutiqueRepository = $boutiqueRepository;
  74.     }
  77.     #[Route('/', name: 'index')]
  78.     public function index(Request $request, PaginatorInterface $paginator): Response
  79.     {
  80.         $search = false ;
  81.         $donnees=[];
  82.         $lastImmeubles = $this->immeublesRepository->findBy(["status"=> UtilsFunctions::PUBLICATION_STATUS], ["pubDate"=>"DESC"],6);
  84.         if($request->isMethod("POST")){
  85.             $search = true ;
  86.             $categs = $_POST["categs"] ?? null;
  87.             $villes = $_POST["villes"] ?? null;
  88.             $quartiers = $_POST["quartiers"] ?? null;
  89.             $res=  $this->immeublesRepository->searchImmeuble($request,$villes, $quartiers, $categs);
  90.             foreach ($res as $key=>$value){
  91.                 $donnees[] = $this->convertToImmeuble($value);
  92.             }
  93.         }else{
  94.             $donnees = $this->immeublesRepository->findBy(["status"=> UtilsFunctions::PUBLICATION_STATUS], ["pubDate"=>"DESC",], 1000);
  95.         }
  96.         $immeubles=null;
  97.         if(count($donnees) > 0){
  98.             $immeubles = $paginator->paginate(
  99.                 $donnees,
  100.                 $request->query->getInt('page', 1),15);
  101.         }
  104.         return $this->render('immeuble/index.html.twig', [
  105.             'immeubles' => $immeubles,
  106.             'lastImmeubles'=> $lastImmeubles,
  107.             'search'=> $search 
  108.         ]);
  109.     }
  110.     #[Route('search/{slugCategorie}', name: 'categorie')]
  111.     public function searchByCategorie(Request $request, PaginatorInterface $paginator, $slugCategorie): Response
  112.     {
  113.         $search = true ;
  114.         $categories = $this->categoriesRepository->findOneBy(["slug"=>trim($slugCategorie)]);
  115.         $donnees=[];
  116.         $searchCategorie = $categories ;
  117.         $lastImmeubles = $this->immeublesRepository->findBy(["status"=> UtilsFunctions::PUBLICATION_STATUS], ["pubDate"=>"DESC"],6);
  119.         
  120.         if($request->isMethod("POST")){
  122.             $categs = $_POST["categs"] ?? null;
  123.             $villes = $_POST["villes"] ?? null;
  124.             $quartiers = $_POST["quartiers"] ?? null;
  125.             $res=  $this->immeublesRepository->searchImmeuble($request,$villes, $quartiers, $categs);
  126.             foreach ($res as $key=>$value){
  127.                 $donnees[] = $this->convertToImmeuble($value);
  128.             }
  129.         }else if(UtilsFunctions::IMMO_CODE == $categories->getCode()) {
  130.             $donnees = $this->immeublesRepository->findBy([], ["pubDate"=>"DESC",], 1000);
  131.         }else{
  132.             $donnees = $this->immeublesRepository->findBy(["categorie"=>$categories], ["pubDate"=>"DESC",], 1000);
  133.         }
  134.         $immeubles=null;
  135.         if(count($donnees) > 0){
  136.             $immeubles = $paginator->paginate(
  137.                 $donnees,
  138.                 $request->query->getInt('page', 1),15);
  139.         }
  142.         return $this->render('immeuble/index.html.twig', [
  143.             'immeubles' => $immeubles,
  144.             'searchCategorie'=>$searchCategorie,
  145.             'lastImmeubles'=> $lastImmeubles,
  146.             'search'=> $search 
  147.           
  148.         ]);
  150.     }
  152.     #[Route('add', name: 'add')]
  153.     public function add(Request $request,  EntityManagerInterface $entityManager): Response
  154.     {
  155.         if(!$this->getUser()){
  156.             return $this->redirectToRoute('app_login');
  157.         }
  158.         $categorie = $this->categoriesRepository->findOneBy(["code"=>UtilsFunctions::IMMO_CODE]);
  159.         $sousCateg= $this->categoriesRepository->findBy(["parent"=>$categorie],["libelle"=>'ASC']);
  160.         $variables = $this->variablesRepository->findBy(["Categorie"=>$categorie]);
  161.         $villes =  $this->villesRepository->findAll() ;
  162.         $immeuble = new Immeubles();
  163.         if($request->isMethod("POST") && ($this->isCsrfTokenValid('add-immeuble', $request->request->get('token')))) {
  164.             if(isset($_POST["variableValue"]))
  165.                 $variableValue = $_POST["variableValue"];
  166.             $immeuble = $this->buildImmeuble($request);
  167.             $photofile = $request->files->get("photo");
  168.             $newFilename = "";
  169.             $destination = "";
  170.             if (!empty($photofile)) {
  171.                 $destination = $this->getParameter('kernel.project_dir') . '/public/uploads/immeubles/' . trim($immeuble->getCode());
  172.                 $newFilename = uniqid() . "-" . $immeuble->getCode() . '.' . $photofile->guessExtension();
  173.                 $immeuble->setPhoto($newFilename);
  174.             }
  176.             if ($this->immeubleCheck($immeuble)) {
  177.                 try {
  178.                     $photofile->move($destination, $newFilename);
  179.                     $this->imageOptimizer->resize($destination.'/'.$newFilename);
  180.                 } catch (FileException $ex) {
  182.                 }
  183.                 $entityManager->persist($immeuble);
  184.                 $entityManager->flush();
  186.                 //save Variable value
  187.                 if(isset($_POST["variableValue"]))
  188.                 foreach($variableValue as $key => $value)
  189.                 {
  190.                     $v =$this->variablesRepository->findOneBy(["code"=>$key]);
  191.                    $immeubleVariable = new ImmeubleVariable();
  192.                    $immeubleVariable->setImmeuble($immeuble);
  193.                    $immeubleVariable->setVariable($v);
  194.                    $immeubleVariable->setValeur($value);
  195.                    $entityManager->persist($immeubleVariable);
  196.                    $entityManager->flush();
  197.                 }
  201.                 return $this->redirectToRoute('app_immeubledetail',['id'=>$immeuble->getId()]);
  203.             }
  204.         }
  207.             return $this->render('immeuble/add.html.twig', [
  208.             'sousCategories' => $sousCateg,
  209.             'variables'=> $variables,
  210.                 'villes'=>$villes
  211.         ]);
  212.     }
  213.     #[Route('detail/{id}', name: 'detail')]
  214.     public function detail(ImagesRepository $imagesRepository, Immeubles $immeuble):Response
  215.     {
  216.         return $this->render('immeuble/detail.html.twig', [
  217.             'immeuble' => $immeuble
  218.         ]);
  219.     }
  220.     #[Route('quartier', name: 'quartier')]
  221.     public function listquatierByville(Request $request,VillesRepository $villesRepository, QuartiersRepository $quartiersRepository)
  222.     {
  223.             $ouptut= array();
  224.             $idville= $request->request->get('id');
  225.             $ville= $villesRepository->findBy(["id"=>$idville]);
  226.             $quartiers = $quartiersRepository->findBy(["ville"=>$ville]);
  227.            
  228.             foreach($quartiers as $q ){
  229.                 
  230.                array_push($ouptut,array($q->getId(),$q->getNom()));
  231.             }
  232.            
  233.             return  new \Symfony\Component\HttpFoundation\JsonResponse($ouptut);
  234.       
  235.        
  236.     }
  237.     #[Route('detailslug/{slug}', name: 'detailslug')]
  238.     public function detailSlug(ImagesRepository $imagesRepository, Immeubles $immeuble):Response
  239.     {
  240.         $immeubles = $this->immeublesRepository->findBy(["categorie"=>$immeuble->getCategorie()], ["pubDate"=>"DESC"], 12);
  241.         $boutique = $immeuble->getVendeur()->getShop();
  242.         return $this->render('immeuble/public-detail.html.twig', [
  243.             'immeuble' => $immeuble,
  244.             'immeubles'=>$immeubles,
  245.             'boutique'=>$boutique,
  246.         ]);
  247.     }
  248.     #[Route('publier/{id}', name: 'publication')]
  249.     public function publierImmeuble(ImmeublesRepository $immeublesRepository, Immeubles $immeubles, EntityManagerInterface $entityManager,NotifierInterface $notifier): Response
  250.     {
  252.         if ($immeubles->getId() > 0) {
  253.             $immeubles->setStatus(UtilsFunctions::PUBLICATION_STATUS);
  254.             $immeubles->setPubDate(new \DateTimeImmutable());
  255.             $entityManager->persist($immeubles);
  256.             $entityManager->flush();
  257.             $notifier->send(new Notification("Operation réussie  publication effectuée",['browser']));
  259.         } else {
  260.             return $this->render('errorrs/notfound.html.twig', [
  261.                 'immeuble' => $immeubles
  262.             ]);
  263.         }
  264.         return $this->render('immeuble/detail.html.twig', [
  265.             'immeuble' => $immeubles
  266.         ]);
  267.     }
  268.     #[Route('suspendre/{id}', name: 'suspension')]
  269.     public function suspendreImmeuble(ImmeublesRepository $immeublesRepository,  Immeubles $immeubles, EntityManagerInterface $entityManager, NotifierInterface $notifier): Response{
  271.         if($immeubles->getId() > 0){
  272.             $immeubles->setStatus(UtilsFunctions::NO_PUBLICATION_STATUS);
  273.             $immeubles->setPubDate(new \DateTimeImmutable());
  274.             $entityManager->persist($immeubles);
  275.             $entityManager->flush();
  276.             $notifier->send(new Notification("Operation réussie  l'immeuble est suspendu",['browser']));
  278.         }else{
  279.             return $this->render('errorrs/notfound.html.twig', [
  280.                 'immeubles' => $immeubles
  281.             ]);
  282.         }
  283.         return $this->render('vehicule/detail.html.twig', [
  284.             'immeubles' => $immeubles
  285.         ]);
  286.     }
  287.     #[Route('delete/{id}', name: 'supprimer')]
  288.     public function supprimerImmeuble(ImmeublesRepository $immeublesRepository, Immeubles $immeubles, EntityManagerInterface $entityManager): Response{
  290.         if($immeubles->getId() > 0){
  291.             $immeubles->setStatus(UtilsFunctions::DELETE_STATUS);
  292.             $entityManager->persist($immeubles);
  293.             $entityManager->flush();
  295.         }else{
  296.             return $this->render('errorrs/notfound.html.twig', [
  297.                 'immeubles' => $immeubles
  298.             ]);
  299.         }
  300.         return $this->redirectToRoute('app_vendor_home_index');
  301.     }
  303.     #[Route('image/{id}', name: 'addimage')]
  304.     public function addImage(Request $request,  EntityManagerInterface $entityManager,ImmeublesRepository $immeublesRepository, Immeubles $immeubles){
  306.         if($request->isMethod("POST") && ($this->isCsrfTokenValid('add-immeuble', $request->request->get('token')))) {
  307.             $immeublesId = $request->request->get('id');
  308.             $immeubleForImage = $immeublesRepository->find($immeublesId);
  309.             $image1 = $request->files->get("image1");
  310.             $image2 = $request->files->get("image2");
  311.             $image3 = $request->files->get("image3");
  312.             $image4 = $request->files->get("image4");
  313.             $this->deleteOldImage($immeubleForImage);
  314.             $this->saveImage($immeubleForImage,$image1, $entityManager);
  315.             $this->saveImage($immeubleForImage,$image2,$entityManager);
  316.             $this->saveImage($immeubleForImage,$image3, $entityManager);
  317.             $this->saveImage($immeubleForImage,$image4, $entityManager);
  318.             return $this->redirectToRoute('app_immeubledetail',['id'=>$immeublesId]);
  319.         }
  322.         return $this->render('immeuble/add-image.html.twig', [
  323.             'immeuble' => $immeubles
  324.         ]);
  326.     }
  327.     public function saveImage(Immeubles $immeuble, $imageFile, EntityManagerInterface $entityManager){
  328.         $imageTosave = new Images();
  330.         if (!empty($imageFile)) {
  331.             $destination = $this->getParameter('kernel.project_dir') . '/public/uploads/immeubles/' . trim($immeuble->getCode());
  332.             $code = UtilsFunctions::generateRandomString(4);
  333.             $newFilename = uniqid() . "-" .$code . '.' . $imageFile->guessExtension();
  334.             $imageTosave->setCode($code);
  335.             $imageTosave->setNom($newFilename);
  336.             $imageTosave->setImmeuble($immeuble);
  337.             try {
  338.                 $imageFile->move($destination, $newFilename);
  339.                 $this->imageOptimizer->resize($destination.'/'.$newFilename);
  340.                 $entityManager->persist($imageTosave);
  341.                 $entityManager->flush();
  342.             } catch (FileException $ex) {
  343.                 throw new \Exception('Erreur enregistrement du fichier image');   
  344.             }
  345.         }
  346.     }
  348.     public function deleteOldImage(Immeubles $immeuble){
  349.         $images = $immeuble->getImages() ;
  350.         if(!$images->isEmpty()){
  351.             for($i=0; $i < $images->count() ; $i++){
  352.                 $image = $images->get($i);
  353.                 $this->imagesRepository->remove($image);
  354.             }
  355.         }
  358.     }
  359.     public  function buildImmeuble($request):Immeubles
  360.     {
  361.         $immeuble = new Immeubles();
  362.         $immeuble->setLibelle($request->request->get('libelle'));
  363.         $immeuble->setDescription($request->request->get('description'));
  364.         $prix = !empty($request->request->get('prix'))?$request->request->get('prix'):0 ;
  365.         $immeuble->setPrix($prix);
  366.         $isnoprice= !empty($request->request->get('isNoprice'));
  367.         $immeuble->setIsNoprice($isnoprice);
  368.         $immeuble->setStatus(UtilsFunctions::NO_PUBLICATION_STATUS);
  369.         $immeuble->setCategorie($this->categoriesRepository->find($request->request->get('categorie')));
  370.         $immeuble->setVille($this->villesRepository->find($request->request->get('ville')));
  371.         $quartierId = $request->request->get("quartier");
  372.         if(!empty($quartierId)){
  373.             $quartier = $this->quartiersRepository->find($quartierId);
  374.             if($quartier != null)
  375.                 $immeuble->setQuartier($quartier);
  376.         }
  377.         $immeuble->setVendeur($this->getUser());
  378.         $immeuble->setSlug(substr($immeuble->getLibelle(),0,6)."-".UtilsFunctions::generateRandomString(5));
  379.         $immeuble->setCode(UtilsFunctions::generateRandomString(8));
  380.         $immeuble->setTypeoperation($request->request->get("typeoperation"));
  381.         $immeuble->setCreatedAt(new \DateTimeImmutable());
  382.         return  $immeuble;
  383.     }
  385.     private function immeubleCheck($immeuble):bool
  386.     {
  387.         return true;
  388.     }
  390.     private function  convertToImmeuble($value):Immeubles{
  391.         $immeuble = new Immeubles();
  392.         $immeuble->setId($value["id"]);
  393.         $immeuble->setVendeur($this->userRepository->find($value["vendeur_id"]));
  394.         $immeuble->setLibelle($value['libelle']);
  395.         $immeuble->setDescription($value["description"]);
  396.         $immeuble->setSlug($value["slug"]);
  397.         $immeuble->setCode($value["code"]);
  398.         $immeuble->setTypeoperation($value["typeoperation"]);
  399.         $immeuble->setStatus($value["status"]);
  400.         $immeuble->setPrix($value["prix"]);
  401.         $immeuble->setIsNoprice($value["is_noprice"]);
  402.         $immeuble->setPhoto($value["photo"]);
  403.         $immeuble->setVille($this->villesRepository->find($value["ville_id"]));
  404.         if(!empty($value["quartier_id"]))
  405.             $immeuble->setQuartier($this->quartiersRepository->find($value["quartier_id"]));
  406.         $immeuble->setCreatedAt( new \DateTimeImmutable($value["created_at"]));
  407.         $immeuble->setPubDate( new \DateTimeImmutable($value["pub_date"]));
  408.         $immeuble->setCategorie($this->categoriesRepository->find($value["categorie_id"]));
  409.         return $immeuble ;
  410.     }
  412. }