src/Controller/AdminController.php line 77

Open in your IDE?
  1. <?php
  3. namespace App\Controller;
  5. use App\Entity\Admin;
  6. use App\Entity\Enterprise;
  7. use App\Entity\User;
  8. use App\Form\AdminUserFormType;
  9. use App\Form\EnterpriseFormType;
  10. use App\Form\EnterpriseUserFormType;
  11. use App\Repository\AdminRepository;
  12. use App\Service\EmailNotification;
  13. use App\Service\FileUploader;
  14. use App\Service\SMSService;
  15. use Doctrine\ORM\EntityManagerInterface;
  16. use Exception;
  17. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  18. use Symfony\Component\Form\FormFactoryInterface;
  19. use Symfony\Component\HttpFoundation\File\Exception\FileException;
  20. use Symfony\Component\HttpFoundation\File\UploadedFile;
  21. use Symfony\Component\HttpFoundation\JsonResponse;
  22. use Symfony\Component\HttpFoundation\Request;
  23. use Symfony\Component\HttpFoundation\Response;
  24. use Symfony\Component\PasswordHasher\Hasher\UserPasswordHasherInterface;
  25. use Symfony\Component\Routing\Annotation\Route;
  27. class AdminController extends AbstractController
  28. {
  29.     private $em;
  31.     private $rpe;
  32.     private $rpu;
  33.     private $rpa;
  35.     /**
  36.      * @param $em
  37.      * @param $rpe
  38.      * @param $rpu
  39.      * @param $rpa
  40.      */
  41.     public function __construct(EntityManagerInterface $em)
  42.     {
  43.         $this->em = $em;
  44.         $this->enterpriseRepository = $em->getRepository(Enterprise::class);
  45.         $this->userRepository = $em->getRepository(User::class);
  46.         $this->adminRepository = $em->getRepository(Admin::class);
  47.     }
  49.     /*
  50.      * Dashboard
  51.      */
  53.     #[Route('/admin', name: 'admin')]
  54.     public function admin(): Response
  55.     {
  56.         return $this->render('admin/dashboard/index.html.twig', [
  57.             'page' => 'd',
  58.             'numberSMS' => $this->enterpriseRepository->countMessages(),
  59.             'numberEnterprise' => $this->enterpriseRepository->countEntreprises(),
  60.             'numberAdmin' => $this->adminRepository->countAdmins(),
  61.             'numberUserClients' => $this->userRepository->countClients(),
  63.             //'enterprises' => $this->enterpriseRepository->findBy([], ['id' => 'DESC']),
  64.             // 'years' => $years
  65.         ]);
  66.     }
  68.     #[Route('/admin/getstats', name: 'admin_getstats')]
  69.     public function getstats(): JSonResponse
  70.     {
  71.         extract($_GET);
  72.         $msg = '';
  73.         $resp = array(
  74.             'msg' => '', 'chart' => []
  75.         );
  76. //        dd($this->rps->getStats($ide, $year));
  77.         $ide = $this->getUser()->getEnterprise()->getId();
  78.         $year = date('Y');
  79.         $stats = ($this->adminRepository->getStats($ide, $year));
  80. //        dd($stats);
  83.         $chart = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
  84.         foreach ($stats as $row) {
  85.             $chart[$row['month'] - 1] += $row['numbersms'];
  86.         }
  87. //            dd($chart);
  89.         $resp['chart'] = $chart;
  90. //                dd($resp['chart']);
  92.         return $this->json($resp);
  93.     }
  95.     #[Route('/getyears', name: 'getyears')]
  96.     public function getyears()
  97.     {
  98.         extract($_GET);
  100.         return new JsonResponse($this->adminRepository->getYears($id));
  101.     }
  104.     /*
  105.      * Entreprises
  106.      */
  108.     #[Route('/admin/enterprise', name: 'admin_enterprise')]
  109.     public function enterprise(Request $request, EntityManagerInterface $entityManager, FormFactoryInterface $formFactory): Response
  110.     {
  111.         $enterprise = new Enterprise();
  112.         $form = $formFactory->createNamed('', EnterpriseFormType::class, $enterprise, [            
  113.             //'action' => $this->generateUrl('admin_enterprise_create')
  114.         ]);
  116.         return $this->render('admin/enterprise/index.html.twig', [
  117.                 'page' => 'e',
  118.                 'form' => $form->createView(),
  119.                 'enterprises' => $this->enterpriseRepository->findBy([], ['id' => 'DESC']),
  121.                 'numberSMS' => $this->enterpriseRepository->countMessages(),
  122.                 'numberEnterprise' => $this->enterpriseRepository->countEntreprises(),
  123.                 'numberAdmin' => $this->adminRepository->countAdmins(),
  124.                 'numberUserClients' => $this->userRepository->countClients(),
  125.             ]
  126.         );
  127.     }
  129.     #[Route('/admin/enterprise/create', name: 'admin_enterprise_create')]
  130.     public function enterprise_create(Request $request,SMSService $service): JsonResponse
  131.     {
  133.         extract($_GET, EXTR_OVERWRITE);
  134.         $nbreEnterprise = $this->enterpriseRepository->count([]);
  135.         $enterprise = new Enterprise();
  136.         $enterprise->setName($name);
  137.         $enterprise->setPhone($phone);
  138.         $enterprise->setEmail($email);
  139.         $enterprise->setAddress($address);
  141.         $resp = array('status' => 'failed', 'msg' => "L'ajout ne s'est pas effectue", 'e' => null);
  142.         $this->adminRepository->createTable($enterprise->getName());
  144.         $enterprise->setTableName($name . "tab");
  146.         $enterprise->setCreditSMS(($creditSMS == '') ? 0 : (int)$creditSMS);
  149.         $this->enterpriseRepository->add($enterprise, true);
  151.         $nbreNouveauEnterprise = $this->enterpriseRepository->count([]);
  152.         dd($nbreNouveauEnterprise .'-'.'sdsdsdsd');
  154.         $result = ($nbreEnterprise != $nbreNouveauEnterprise);
  156.         $lastEnterprise = $this->enterpriseRepository->findBy([], ['id' => 'DESC'], 1);
  157. //        $result = (0 == 0);
  158.         if ($result) {
  159.             $resp['status'] = 'success';
  160.             $resp['msg'] = "L' entreprise a bien ete ajoutee";// . $conn->error;
  161.             $resp['number'] = $nbreNouveauEnterprise;
  162.             $updateEnterprise = $lastEnterprise[0];
  163.             //$service->internalSMSNotification('SMS PLATFORM',$phone,'Bienvenu sur SMS PLATFORM,le compte de l\'entreprise '.$name.' a bien ete cree.');
  164.             $resp['e'] = array(
  165.                 $updateEnterprise->getId(),
  166.                 $updateEnterprise->getName(),
  167.                 $updateEnterprise->getPhone(),
  168.                 $updateEnterprise->getEmail(),
  169.                 $updateEnterprise->getAddress(),
  170.                 $updateEnterprise->getCreditSMS()
  171.             );;
  172.             $resp['ifFerme'] = $ifFerme;
  173.         }
  175.         return new JSonResponse($resp);
  176.     }
  178.     #[Route('/admin/enterprise/update/{id}', name: 'admin_enterprise_update')]
  179.     public function enterprise_update($id, Request $request): JSonResponse
  180.     {
  181.         extract($_GET, EXTR_OVERWRITE);
  182.         $enterprise = $this->enterpriseRepository->find($id);
  183.         $oldtablename = $enterprise->getTablename();
  184.         $oldname = $enterprise->getName();
  185. //        dd('ALTER TABLE `'.$oldtablename.'` RENAME TO `' . $name.'tab`');
  186. //            dd([$oldname,$oldtablename,$name]);
  187.         if ($name != $oldname) {
  188.             $enterprise->setName($name);
  189.             $this->adminRepository->executeSQL('ALTER TABLE ' . $oldtablename . ' RENAME TO `' . $name . 'tab`');
  190.             $enterprise->setTablename($name . 'tab');
  192.         }
  193.         $enterprise->setPhone($phone);
  194.         $enterprise->setEmail($email);
  195.         $enterprise->setAddress($address);
  196.         $this->em->flush();
  198.         $updateEnterprise = $this->enterpriseRepository->findOneBy(['id' => $id]);
  199.         $resp = array('status' => 'failed', 'msg' => "La modification n'a pas pu s'effectuer", 'e' => null);
  201.         if ($enterprise->equals($updateEnterprise)) {
  202.             $resp['status'] = 'success';
  203.             $resp['msg'] = "La modification s'est effectue";
  205.             $resp['e'] = array(
  206.                 $updateEnterprise->getId(),
  207.                 $updateEnterprise->getName(),
  208.                 $updateEnterprise->getPhone(),
  209.                 $updateEnterprise->getEmail(),
  210.                 $updateEnterprise->getAddress(),
  211.                 $updateEnterprise->getCreditSMS()
  212.             );
  213.             $resp['ifFerme'] = $ifFerme;
  214.         }
  215.         return $this->json($resp);
  216. //        return $this->redirectToRoute('admin_enterprise');
  217.     }
  219.     #[Route('/admin/enterprise/delete/{id}', name: 'admin_enterprise_delete')]
  220.     public function enterprise_delete($id, Request $request): JSonResponse
  221.     {
  222.         $enterprise = $this->enterpriseRepository->find($id);
  223. //        dd($enterprise);
  224. //        $this->rps->deleteTable($enterprise->getName());
  225.         $msg = '';
  226.         try {
  227.             $this->adminRepository->executeSQL('DROP TABLE `'.$enterprise->getTableName().'`');
  228.         }
  229.         catch (Exception $e){
  230.             $msg = 'Un probleme est survenu lors de la suppression de la table de l\'entreprise.';
  231.         }
  233.         $nbre1 = $this->enterpriseRepository->count([]);
  234.         $this->enterpriseRepository->remove($enterprise, true);
  235.         $nbre2 = $this->enterpriseRepository->count([]);
  236.         $resp = array('status' => 'failed', 'msg' => "La suppression n'a pas pu s'effectuer");
  238.         if ($nbre1 != $nbre2) {
  239.             $resp['status'] = 'success';
  240.             $resp['msg'] = $msg."L'entreprise a ete supprimee";
  241.             $resp['number'] = $nbre2;
  242.             $resp['id'] = $id;
  243.         }
  244.         return $this->json($resp);
  245. //        return $this->redirectToRoute('admin_enterprise');
  246.     }
  248.     #[Route('/admin/enterprise/reload', name: 'admin_enterprise_reload')]
  249.     public function enterprise_reload(Request $request,SMSService $service): JSonResponse
  250.     {
  251.         extract($_GET);
  252.         $success = true;
  253.         $resp = array(
  254.             'status' => 'success',
  255.             'msg' => 'Les comptes ont ete recharges',
  257.             'numberSMS' => null
  258.         );
  259.         $names = array();
  260.         $ids = array();
  261.         $word = ($operation == 'a') ? 'credite' : 'debite';
  263.         foreach ($entreprises as $id) {
  264.             $enterprise = $this->enterpriseRepository->find($id);
  265.             $numberSMS = $enterprise->getCreditSMS();
  266.             if ($operation == 'a') $numberSMS += (int)$number;
  267.             else $numberSMS -= (int)$number;
  268.             $enterprise->setCreditSMS($numberSMS);
  271.             $this->em->flush();
  273.             $updateEnterprise = new Enterprise();
  275.             $updateEnterprise = $this->enterpriseRepository->findOneBy(['id' => $id, 'creditSMS' => $numberSMS]);
  277.             $numberSMS = $enterprise->getCreditSMS();
  278.             if (!$enterprise->equals($updateEnterprise)) {
  279.                 array_push($names, $enterprise->getName());
  280.                 $success = false;
  281.             } else {
  282.                 array_push($ids, $id);
  283.                 $resp['numberSMS'] = $numberSMS;
  284.                 $resp['ifFerme'] = $ifFerme;
  285.                 //$service->internalSMSNotification('SMS PLATFORM',$enterprise->getPhone(),'Le compte SMS de '.$enterprise->getName().' a bien ete '.$word.'\nNouveau Solde : '.$numberSMS);
  287.             }
  289.         }
  290.         if (!$success) {
  291.             $resp['status'] = 'failed';
  292.             //Construction du message d'erreur
  293.             $msg = 'Le';
  294.             if (count($names) == 1) {
  295.                 $msg .= ' compte de ' . $names[0] . ' n\' a pas pu etre ' . $word;
  296.             } else {
  297.                 $msg .= 's comptes des entreprises ' . implode(',', $names) . 'n \'ont pas pu etre ' . $word . 's';
  298.             }
  299.             $resp['msg'] = $msg;
  300.         }
  302.         $resp['ids'] = $ids;
  304.         return $this->json($resp);
  305. //        return $this->redirectToRoute('admin_enterprise');
  306.     }
  308.     #[Route('/admin/enterprise/check', name: 'admin_enterprise_check')]
  309.     public function enterprise_check(Request $request): JSonResponse
  310.     {
  311.         extract($_GET);
  312.         $msg = '';
  313.         $resp = array(
  314.             'name' => true, 'phone' => true
  315.         );
  316.         $uniqueName = $this->enterpriseRepository->count(['name' => $name]) > 0;
  317.         $uniquePhone = $this->enterpriseRepository->count(['phone' => $phone]) > 0;
  318.         if ($ide != '') {
  319.             $enterpriseWithSameName = $this->enterpriseRepository->findOneBy(['name' => $name]);
  320.             if ($enterpriseWithSameName != null) {
  322.                 $uniqueName = $enterpriseWithSameName->getId() != $ide;
  323.             }
  324.             $enterpriseWithSamePhone = $this->enterpriseRepository->findOneBy(['phone' => $phone]);
  325.             if ($enterpriseWithSamePhone != null) {
  327.                 $uniquePhone = $enterpriseWithSamePhone->getId() != $ide;
  328.             }
  330.         }
  331.         if ($uniqueName) {
  332.             $resp['name'] = false;
  333.         }
  334.         if ($uniquePhone) {
  335.             $resp['phone'] = false;
  336.         }
  337.         return $this->json($resp);
  338.     }
  341.     /*
  342.      * Messages
  343.      */
  345.     #[Route('/admin/message', name: 'admin_message')]
  346.     public function message(): Response
  347.     {
  348.         return $this->render('admin/message/index.html.twig', [
  349.             'page' => 'm',
  350.             'enterprises' => $this->enterpriseRepository->findBy([], ['id' => 'DESC']),
  351.             'numberSMS' => $this->enterpriseRepository->countMessages(),
  352.             'numberEnterprise' => $this->enterpriseRepository->countEntreprises(),
  353.             'numberAdmin' => $this->adminRepository->countAdmins(),
  354.             'numberUserClients' => $this->userRepository->countClients(),
  357.             //'numberSMS' => $this->rpa->countAllMessages('0','','','000'),
  358.             //'numberEnterprise' => $this->rpe->count([]),
  359.             //'numberAdmin' => $numberAdmin,
  360.             //'numberUserClients' => $numberUserClients,
  362.         ]);
  363.     }
  365.     /*
  366.      * Parametres
  367.      */
  369.     #[Route('/admin/setting', name: 'admin_setting')]
  370.     public function setting(FormFactoryInterface $formFactory): Response
  371.     {
  372.         $user = new User();
  373.         $form = $formFactory->createNamed('', EnterpriseUserFormType::class, $user);
  375. //        foreach ($users as $user) {
  376. //            if (in_array('ROLE_ADMIN', $user->getRoles())) $numberAdmin++;
  377. //            else $numberUserClients++;
  378. //        }
  379.         return $this->render('admin/setting/index.html.twig', [
  380.             'page' => 's',
  381.             'numberSMS' => $this->enterpriseRepository->countMessages(),
  382.             'numberEnterprise' => $this->enterpriseRepository->countEntreprises(),
  383.             'numberAdmin' => $this->adminRepository->countAdmins(),
  384.             'numberUserClients' => $this->userRepository->countClients(),
  385.             'form' => $form->createView()
  386.         ]);
  387.     }
  389.     #[Route('/admin/setting/update/{id}', methods: ['GET', 'POST'], name: 'admin_setting_update')]
  390.     public function setting_update($id, Request $request, FileUploader $fileUploader, EntityManagerInterface $entityManager): JSonResponse
  391.     {
  392.         extract($_POST);
  393.         extract($_FILES);
  394.         $entityRepository = $this->userRepository;
  395.         $user = $entityRepository->find($id);
  396.         if ($user == null) {
  397.             $entityRepository = $this->adminRepository;
  398.             $user = $entityRepository -> find($id);
  399.         }
  400.         $imgsdirectory = $fileUploader->getTargetDirectory() . '/';
  401.         if ($username != $user->getUsername() && !($image)) {
  402.             $userNameImage = $username . $this->adminRepository->index(3) . '.' . pathinfo($user->getImage(), PATHINFO_EXTENSION);
  403.             rename($imgsdirectory . $user->getImage(), $imgsdirectory . $userNameImage);
  404.             $user->setImage($userNameImage);
  405.         }
  406.         $user->setUsername($username);
  407.         $user->setEmail($email);
  408.         $user->setPhone($phone);
  410.         $resp = array('status' => 'failed', 'msg' => "La modification n'a pas pu s'effectuer", 'e' => null);
  411.         if (isset($image) && $image['name'] != '') {
  413.             try {
  414.                 $path = $image['tmp_name'];
  415.                 $originalName = $image['name'];
  416.                 $type = $image['type'];
  417.                 $error = $image['error'];
  418.                 $fileImage = new UploadedFile($path, $originalName, $type, $error);
  419. //                dd($imgsdirectory . $user->getImage());
  420.                 $filename = $imgsdirectory . $user->getImage();
  421.                 if (file_exists($filename) && $user->getImage() != '') unlink($filename);
  423.                 if ($path != '') {
  424.                     $fileName = $fileUploader->upload($fileImage, $user);
  425.                     $user->setImage($fileName);
  427.                 }
  428.             } catch (FileException $e) {
  429.                 $resp['status'] = 'failed';
  430.                 $resp['msg'] = 'Desole,nous n\'avons pas pu changer votre image';
  431.             }
  432.         }
  433.         $this->em->flush();
  435.         $updateUser = $entityRepository->findOneBy(['id' => $id]);
  437.         if ($user->equals($updateUser)) {
  438.             $resp['status'] = 'success';
  439.             $resp['msg'] = "La modification s'est effectue";
  440.             $resp['id'] = $id;
  441.             $resp['u'] = array(
  442.                 $updateUser->getUsername(),
  443.                 $updateUser->getPhone(),
  444.                 $updateUser->getEmail(),
  445.                 $updateUser->getImage()
  446.             );
  447.         }
  448.         return new JsonResponse($resp);
  449.     }
  451.     #[Route('admin/setting/changepassword/{id}', name: 'admin_setting_changepassword')]
  452.     public function changepassword($id, Request $request, UserPasswordHasherInterface $userPasswordHasher, EntityManagerInterface $entityManager): JSonResponse
  453.     {
  454.         extract($_GET);
  455.         $entityRepository = $this->rpu;
  456.         $user = $entityRepository->find($id);
  457.         if ($user == null) {
  458.             $entityRepository = $this->adminRepository;
  459.             $user = $entityRepository -> find($id);
  460.         }
  461.         $resp = array('status' => 'failed', 'msg' => "La modification n'a pas pu s'effectuer");
  463.         // encode the plain password
  465.         if (!password_verify($oldpass, $user->getPassword())) {
  466.             $resp['status'] = 'failed';
  467.             $resp['msg'] = 'Le premier mot de passe ne correspond pas';
  468.             return $this->json($resp);
  469.         }
  471.         // encode the plain password
  472.         $user->setPassword(
  473.             $userPasswordHasher->hashPassword(
  474.                 $user, $newpass
  475.             )
  476.         );
  477.         $this->em->flush();
  478.         $updateUser = $entityRepository->findOneBy(['id' => $id]);
  480.         if ($user->equals($updateUser)) {
  481.             $resp['status'] = 'success';
  482.             $resp['msg'] = "Votre mot de passe a bien ete modifiee";
  483.         }
  484.         return new JsonResponse($resp);
  485.     }
  487.     /*
  488.       * Change Theme
  489.     */
  490.     #[Route('/theme', name: 'theme', methods: ['GET'])]
  491.     public function theme(): JsonResponse
  492.     {
  494.         extract($_GET);
  496.         if($this->getUser())
  497.         {
  498.             if($this->getUser()->isTheme() == true )
  499.             {
  500.                 $this->getUser()->setTheme(false);
  501.             }
  502.             else
  503.             {
  504.                 $this->getUser()->setTheme(true);
  505.             }
  506.         }
  507.         
  508.         $this->em->flush();
  509.         
  510.         $resp['status'] = 'success';
  512.         return new JsonResponse($resp);
  513.     }
  515.     #[Route('/admin/users/clients', name: 'admin_users_clients')]
  516.     public function clients(Request $request, EntityManagerInterface $entityManager, FormFactoryInterface $formFactory): Response
  517.     {
  518.         $user = new User();
  519.         $form = $formFactory->createNamed('', EnterpriseUserFormType::class, $user);
  520.         return $this->render('admin/users/clients/index.html.twig', [
  521.                 'page' => 'clients',
  522.                 'form' => $form->createView(),
  524.                 'numberSMS' => $this->enterpriseRepository->countMessages(),
  525.                 'numberEnterprise' => $this->enterpriseRepository->countEntreprises(),
  526.                 'numberAdmin' => $this->adminRepository->countAdmins(),
  527.                 'numberUserClients' => $this->userRepository->countClients(),
  528.             ]
  529.         );
  530.     }
  533.     #[Route('/admin/users/admins', name: 'admin_users_admins')]
  534.     public function admins(AdminRepository $adminRepository, FormFactoryInterface $formFactory): Response
  535.     {
  536.         $user = new User();
  537.         $form = $formFactory->createNamed('', AdminUserFormType::class, $user);
  538.         return $this->render('admin/users/admins/index.html.twig', [
  539.                 'page' => 'a',
  540.                 'form' => $form->createView(),
  541.                 'admins' => $adminRepository->findBy([], ['id' => 'DESC']),
  543.                 'numberSMS' => $this->enterpriseRepository->countMessages(),
  544.                 'numberEnterprise' => $this->enterpriseRepository->countEntreprises(),
  545.                 'numberAdmin' => $this->adminRepository->countAdmins(),
  546.                 'numberUserClients' => $this->userRepository->countClients(),
  547.             ]
  548.         );
  549.     }
  551.     #[Route('/admin/users/{type}/check', name: 'admin_clients_check')]
  552.     public function user_check($type, Request $request): JSonResponse
  553.     {
  554.         // ide : Identifiant utilisateur
  555.         // enterprise : Identifiant entreprise(type == user)
  556.         // username : Nom utilisateur
  557.         // phone : Telephone utilisateur
  558.         extract($_GET);
  560.         $msg = '';
  561.         $resp = array(
  562.             'name' => true, 'phone' => true
  563.         );
  564.         $entityRepository = null;
  565.         $enterprise = null;
  566.         if ($type == 'user'){
  567.             $entityRepository = $this->userRepository;
  568.             if ($enterprise) $enterprise = $this->enterpriseRepository->find($enterprise);
  569.         }
  570.         else{
  571.             $entityRepository = $this->adminRepository;
  572.         }
  574.             //$test = $entityRepository->findBy(['username' => $username, 'enterprise' => $enterprise]);
  576.             $uniqueName = $entityRepository->count(['username' => $username, 'enterprise' => $enterprise]) > 0;
  577.             $uniquePhone = $entityRepository->count(['username' => $phone, 'enterprise' => $enterprise]) > 0;
  578.             if ($ide != '') {
  579.                 $userWithSameName = $entityRepository->findOneBy(['username' => $username, 'enterprise' => $enterprise], ['id' => 'ASC']);
  580.                 if ($userWithSameName != null) {
  582.                     $uniqueName = $userWithSameName->getId() != $ide;
  583.                 }
  584.                 $userWithSamePhone = $entityRepository->findOneBy(['phone' => $phone, 'enterprise' => $enterprise]);
  585.                 if ($userWithSamePhone != null) {
  587.                     $uniquePhone = $userWithSamePhone->getId() != $ide;
  588.                 }
  590.             }
  596.         if ($uniqueName) {
  597.             $resp['name'] = false;
  598.         }
  599.         if ($uniquePhone) {
  600.             $resp['phone'] = false;
  601.         }
  602. //        dd($resp);
  603.         return $this->json($resp);
  604.     }
  606.     #[Route('/admin/users/{type}/create', name: 'admin_users_clients_create')]
  607.     public function users_clients_create($type,FileUploader $fileUploader, Request $request, UserPasswordHasherInterface $userPasswordHasher, EntityManagerInterface $entityManager): JSonResponse
  608.     {
  609.         extract($_POST);
  610.         extract($_FILES);
  611.         if ($type == 'admin'){
  612.             $entityRepository =  $this->adminRepository;
  613.             $user = new Admin();
  614.             $personneType = "administrateur";
  615.         }
  616.         else{
  617.             $entityRepository = $this->userRepository;
  618.             $user = new User();
  619.             $personneType = "utilisateur";
  620.         }
  621.         $user->setUsername($username);
  622.         $user->setEmail($email);
  623.         $user->setPhone($phone);
  624.         $user->setRoles([$roles]);
  626.         if (isset($enterprise)) {
  627.             $user->setEnterprise($this->enterpriseRepository->find($enterprise));
  628.         }
  630.         if (isset($image) && $image['name'] != '') {
  631.             try {
  632.                 $path = $image['tmp_name'];
  633.                 $originalName = $image['name'];
  634.                 $type = $image['type'];
  635.                 $error = $image['error'];
  636.                 $fileImage = new UploadedFile($path, $originalName, $type, $error);
  638.                 $fileName = $fileUploader->upload($fileImage, $user);
  639.                 $user->setImage($fileName);
  640.             } catch (FileException $e) {
  641.                 $resp['status'] = 'failed';
  642.                 $resp['msg'] = 'Desole,nous n\'avons pu ajouter l\'image de l\'utilisateur';
  643.             }
  644.         }
  646.         $nbreUser = $entityRepository->count([]);
  649.         // encode the plain password
  650.         $password = $password == '' ? '123456' : $password;
  652.         $user->setPassword(
  653.             $userPasswordHasher->hashPassword(
  654.                 $user, $password
  655.             )
  656.         );
  657.         $entityRepository->add($user,true);
  659.         $nbreUser1 = $entityRepository->count([]);
  660.         $resp = array('status' => 'failed', 'msg' => "L'ajout ne s'est pas effectue", 'e' => null);
  661.         $result = $nbreUser1 != $nbreUser;
  663.         if ($result) {
  664.             $resp['status'] = 'success';
  665.             $resp['msg'] = "L' ". $personneType ." a bien ete ajoutee";// . $conn->error;
  666.             $resp['number'] = $nbreUser1;
  667.             $lastUser = $entityRepository->findBy([], ['id' => 'DESC'], 1);
  668.             $updateUser = $lastUser[0];
  670.             $resp['ifFerme'] = $ifFerme;
  671.         }
  673.         // do anything else you need here, like send an email
  675.         return new JsonResponse($resp);
  676.     }
  678.     #[Route('/admin/users/{type}/update/{id}', name: 'admin_users_clients_update')]
  679.     public function users_clients_update($type, $id, FileUploader $fileUploader, Request $request, UserPasswordHasherInterface $userPasswordHasher, EntityManagerInterface $entityManager): JSonResponse
  680.     {
  681.         extract($_POST);
  682.         extract($_FILES);
  683.         $entityRepository = ($type == "admin")? $this->adminRepository : $this->rpu;
  684.         $user = $entityRepository->find($id);
  686.         $user->setUsername($username);
  687.         $user->setEmail($email);
  688.         $user->setPhone($phone);
  689.         $user->setRoles([$roles]);
  690.         if (isset($enterprise)) $user->setEnterprise($this->enterpriseRepository->find($enterprise));
  692.         if (isset($image) && $image['name'] != '') {
  694.             try {
  695.                 $path = $image['tmp_name'];
  696.                 $originalName = $image['name'];
  697.                 $type = $image['type'];
  698.                 $error = $image['error'];
  699.                 $fileImage = new UploadedFile($path, $originalName, $type, $error);
  700. //                dd($imgsdirectory . $user->getImage());
  701.                 $imgsdirectory = $fileUploader->getTargetDirectory() . '/';
  702.                 $filename = $imgsdirectory . $user->getImage();
  703.                 if (file_exists($filename) && $user->getImage() != '') unlink($filename);
  705.                 $fileName = $fileUploader->upload($fileImage, $user);
  706.                 $user->setImage($fileName);
  707.             } catch (FileException $e) {
  708.                 $resp['status'] = 'failed';
  709.                 $resp['msg'] = 'Desole,nous n\'avons pas pu changer votre image';
  710.             }
  711.         }
  713.         // encode the plain
  714.         if ($password != '')
  715.             $user->setPassword(
  716.                 $userPasswordHasher->hashPassword(
  717.                     $user, $password
  718.                 )
  719.             );
  720.         $this->em->flush();
  722.         $updateUser = $entityRepository->findOneBy(['id' => $id]);
  723.         $resp = array('status' => 'failed', 'msg' => "La modification n'a pas pu s'effectuer", 'e' => null);
  725.         if ($user->equals($updateUser)) {
  726.             $resp['status'] = 'success';
  727.             $resp['msg'] = "La modification s'est effectue";
  729.             $resp['ifFerme'] = $ifFerme;
  730.         }
  731.         return new JsonResponse($resp);
  732.     }
  734.     #[Route('/admin/users/{type}/delete/{id}', name: 'admin_users_clients_delete')]
  735.     public function users_clients_delete($type,$id, FileUploader $fileUploader, Request $request): JSonResponse
  736.     {
  737.         $entityRepository = null;
  738.         $personneType = '';
  739.         if ($type == "admin"){
  740.             $entityRepository = $this->adminRepository ;
  741.             $personneType = "administrateur";
  742.         }
  743.         else{
  744.             $entityRepository = $this->rpu ;
  745.             $personneType = "utilisateur";
  746.         }
  747.         $user = $entityRepository->find($id);
  748.         $nbre1 = $entityRepository->count([]);
  749.         $imgsdirectory = $fileUploader->getTargetDirectory() . '/';
  750.         $filename = $imgsdirectory . $user->getImage();
  751.         if (file_exists($filename) && $user->getImage() != '') unlink($filename);
  752.         $entityRepository->remove($user, true);
  753.         $nbre2 = $entityRepository->count([]);
  754.         $resp = array('status' => 'failed', 'msg' => "La suppression n'a pas pu s'effectuer");
  755.         if ($nbre1 != $nbre2) {
  756.             $resp['status'] = 'success';
  758.             $resp['msg'] = "L' ".$personneType." a bien ete supprime";
  759.             $resp['number'] = $nbre2;
  760.             $resp['id'] = $id;
  761.         }
  762.         return $this->json($resp);
  763. //        return $this->redirectToRoute('admin_enterprise');
  764.     }
  766.     #[Route('/route', name: 'route')]
  767.     public function route(Request $request, MailerInterface $mailer): Response
  768.     {
  769.         $this->adminRepository->find(2)->setEnterprise(null);
  770.         $this->adminRepository->find(145)->setEnterprise(null);
  771.         $this->adminRepository->find(146)->setEnterprise(null);
  772.         return new Response($this->adminRepository->getTable(null));
  774.     }
  776. }