src/Controller/GestionComerciale/AlerteController.php line 23

Open in your IDE?
  1. <?php
  2. namespace App\Controller\GestionComerciale;
  3. use App\Entity\GestionComerciale\Activite;
  4. use App\Entity\GestionComerciale\Alerte;
  5. use Doctrine\ORM\EntityManagerInterface;
  6. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  7. use Symfony\Component\HttpFoundation\Request;
  8. use Symfony\Component\HttpFoundation\JsonResponse;
  9. use Symfony\Component\HttpFoundation\Response;
  10. use Symfony\Component\Routing\Annotation\Route;
  11. use Symfony\Component\Validator\Validator\ValidatorInterface;
  12. use Symfony\Contracts\Translation\TranslatorInterface;
  13. class AlerteController extends AbstractController
  14. {
  15.     /**
  16.      * @Route("/activite-page/{id}", name="dtc_activite_page")
  17.      */
  18.     public function activitePageAction(Request $requestActivite $activiteEntityManagerInterface $em)
  19.     {
  20.         $repo_activite $em->getRepository(Activite::class);
  21.         $activite->setTimestamp(new \Datetime());
  22.         $valide true;
  23.         $raz    false;
  24.         $em->persist($activite);
  25.         $em->flush();
  26.         $em->refresh($activite);
  27.         $invites null;
  28.         if (is_object($activite->getDateFin())) {
  29.             $valide false;
  30.             //Si personne n'est venu sur la page on raz de la dateFin
  31.             $invites $repo_activite->getUtilisateursPage($activite);
  32.             if (count($invites) == 0) {
  33.                 $valide true;
  34.                 $activite->setDateFin(null);
  35.                 $em->persist($activite);
  36.                 $em->flush();
  37.                 $em->refresh($activite);
  38.                 $raz true;
  39.             }
  40.         }
  41.         // $invites = $repo_activite->findBy(array("objet"=>$activite->getObjet(),"action"=>$activite->getAction(),"idObjet"=>$activite->getIdObjet()));
  42.         if (is_null($invites)) {
  43.             $invites $repo_activite->getUtilisateursPage($activite);
  44.         }
  45.         $total_utilisateurs count($invites);
  46.         $rendu              $this->renderView('GestionComerciale/Activite/utilisateurs.html.twig', ['invites' => $invites]);
  47.         return new JsonResponse(['raz' => $raz'valide' => $valide'rendu' => $rendu'totalUtilisateurs' => $total_utilisateurs], 200, ['Content-Type' => 'application/json']);
  48.     }
  49.     /**
  50.      * @Route("/alerte/{type}/{id}", name="dtc_alerte")
  51.      */
  52.     public function alerteAction(Request $requestEntityManagerInterface $em)
  53.     {
  54.         //var_dump('test');
  55.         $user $this->getUser();
  56. //        $currentRoute = dirname($_SERVER['SERVER_PROTOCOL']) . "://" . $_SERVER['HTTP_HOST'] . $_SERVER['REQUEST_URI'];
  57. //        dump($currentRoute);
  58.         $currentRoute $_SERVER['REQUEST_URI'];
  59.         //echo "toto".$currentRoute;
  60.         $route         $request->request->get('route');
  61.         $repo_activite $em->getRepository(Activite::class);
  62.         $acti          $repo_activite->findOneBy([
  63.                                                        'url' => $currentRoute,
  64.                                                    ]);
  65.         $repo_alerte   $em->getRepository(Alerte::class);
  66.         $aler          $repo_alerte->findOneBy([
  67.                                                      'url'      => $currentRoute,
  68.                                                      'supprime' => false,
  69.                                                  ]);
  70.         $onglet        $request->request->get('onglet');
  71.         if (is_object($aler) && $aler->getSupprime() == false) {
  72.             $lu              $aler->getLu();
  73.             $refus           $aler->getRefus();
  74.             $quitter         $aler->getQuitter();
  75.             $nomEmetteur     $aler->getEmetteur()->getNom();
  76.             $prenomEmetteur  $aler->getEmetteur()->getPrenom();
  77.             $nomRecepteur    $aler->getRecepteur()->getNom();
  78.             $prenomRecepteur $aler->getRecepteur()->getPrenom();
  79.             $skypeRecepteur  $aler->getRecepteur()->getSkype();
  80.             $telRecepteur    $aler->getRecepteur()->getTelephone();
  81.         } else {
  82.             $lu              "Null";
  83.             $refus           "Null";
  84.             $quitter         false;
  85.             $nomEmetteur     "null";
  86.             $prenomEmetteur  "null";
  87.             $nomRecepteur    "null";
  88.             $prenomRecepteur "null";
  89.             $telRecepteur    null;
  90.             $skypeRecepteur  null;
  91.         }
  92.         if (is_object($acti)) {
  93.             $timestampactivite $acti->getTimestamp();
  94.             $timestampactuelle = new \DateTime();
  95.             $time              $timestampactuelle->diff($timestampactivite);
  96.             if ($acti->getUtilisateur() == $user) {
  97.                 $acti->setTimestamp(new \DateTime());
  98.                 $em->persist($acti);
  99.                 $em->flush();
  100.                 if ($lu == false) {
  101.                     $aler->setLu(true);
  102.                     $em->persist($aler);
  103.                     $em->flush();
  104.                     $lock 3;
  105.                     return new JsonResponse(
  106.                         [
  107.                             'valide'          => '0',
  108.                             'url'             => $currentRoute,
  109.                             'lu'              => $lu,
  110.                             'lock'            => $lock,
  111.                             'refus'           => $refus,
  112.                             'quitter'         => $quitter,
  113.                             'nomEmetteur'     => $nomEmetteur,
  114.                             'prenomEmetteur'  => $prenomEmetteur,
  115.                             'nomRecepteur'    => $nomRecepteur,
  116.                             'prenomRecepteur' => $prenomRecepteur,
  117.                             'telRecepteur'    => $telRecepteur,
  118.                             'skypeRecepteur'  => $skypeRecepteur,
  119.                         ]
  120.                     );
  121.                 } else {
  122.                     $lock 3;
  123.                     return new JsonResponse(
  124.                         [
  125.                             'valide'          => '0',
  126.                             'url'             => $currentRoute,
  127.                             'lu'              => $lu,
  128.                             'lock'            => $lock,
  129.                             'refus'           => $refus,
  130.                             'quitter'         => $quitter,
  131.                             'nomEmetteur'     => $nomEmetteur,
  132.                             'prenomEmetteur'  => $prenomEmetteur,
  133.                             'nomRecepteur'    => $nomRecepteur,
  134.                             'prenomRecepteur' => $prenomRecepteur,
  135.                             'telRecepteur'    => $telRecepteur,
  136.                             'skypeRecepteur'  => $skypeRecepteur,
  137.                         ]
  138.                     );
  139.                 }
  140.             }
  141.             if ($time->format('%s') >= 15 || $time->format('%i') >= || $time->format('%h') >= || $time->format('%d') >= || $time->format('%m') >= || $time->format(
  142.                     '%y'
  143.                 ) >= && $acti->getUtilisateur() != $user) {
  144.                 if (is_object($aler) && $aler->getSupprime() == false) {
  145.                     if ($aler->getEmetteur() == $user) {
  146.                         $aler->setSupprime(true);
  147.                         $em->persist($aler);
  148.                         $em->flush();
  149.                         $lock 2;
  150.                         return new JsonResponse(
  151.                             [
  152.                                 'valide'          => '0',
  153.                                 'url'             => $currentRoute,
  154.                                 'lock'            => $lock,
  155.                                 'titre'           => 'Un utilisateur est dejà sur cette page ',
  156.                                 'supprime'        => $aler->getSupprime(),
  157.                                 'nomEmetteur'     => $aler->getEmetteur()->getNom(),
  158.                                 'prenomEmetteur'  => $aler->getEmetteur()->getPrenom(),
  159.                                 'nomRecepteur'    => $aler->getRecepteur()->getNom(),
  160.                                 'prenomRecepteur' => $aler->getRecepteur()->getPrenom(),
  161.                                 'telRecepteur'    => $telRecepteur,
  162.                                 'skypeRecepteur'  => $skypeRecepteur,
  163.                             ]
  164.                         );
  165.                     } else {
  166.                         $lock 4;
  167.                         return new JsonResponse(
  168.                             [
  169.                                 'valide'          => '0',
  170.                                 'url'             => $currentRoute,
  171.                                 'lu'              => $lu,
  172.                                 'lock'            => $lock,
  173.                                 'supprime'        => $aler->getSupprime(),
  174.                                 'nomEmetteur'     => $aler->getEmetteur()->getNom(),
  175.                                 'prenomEmetteur'  => $aler->getEmetteur()->getPrenom(),
  176.                                 'nomRecepteur'    => $aler->getRecepteur()->getNom(),
  177.                                 'prenomRecepteur' => $aler->getRecepteur()->getPrenom(),
  178.                                 'skypeRecepteur'  => $skypeRecepteur,
  179.                                 'telRecepteur'    => $telRecepteur,
  180.                             ]
  181.                         );
  182.                     }
  183.                 } else {
  184.                     $lock 4;
  185.                     return new JsonResponse(['valide' => '0''url' => $currentRoute'lu' => $lu'lock' => $lock]);
  186.                 }
  187.                 $acti->setTimestamp(new \DateTime());
  188.                 $acti->setUtilisateur($user);
  189.                 $em->persist($acti);
  190.                 $em->flush();
  191.             } else {
  192.                 if ($acti->getUtilisateur() != $user) {
  193.                     if (is_object($aler)) {
  194.                         $refus   $aler->getRefus();
  195.                         $quitter $aler->getQuitter();
  196.                         if ($refus == 2) {
  197.                             $acti->setUtilisateur($user);
  198.                             $aler->setSupprime(true);
  199.                             $em->persist($acti);
  200.                             $em->persist($aler);
  201.                             $em->flush();
  202.                             $lock 1;
  203.                             return new JsonResponse(
  204.                                 [
  205.                                     'valide'          => '0',
  206.                                     'url'             => $acti->getUrl(),
  207.                                     'lock'            => $lock,
  208.                                     'refus'           => $refus,
  209.                                     'quitter'         => $aler->getQuitter(),
  210.                                     'supprime'        => $aler->getSupprime(),
  211.                                     'nomEmetteur'     => $aler->getEmetteur()->getNom(),
  212.                                     'prenomEmetteur'  => $aler->getEmetteur()->getPrenom(),
  213.                                     'nomRecepteur'    => $aler->getRecepteur()->getNom(),
  214.                                     'prenomRecepteur' => $aler->getRecepteur()->getPrenom(),
  215.                                     'telRecepteur'    => $telRecepteur,
  216.                                     'skypeRecepteur'  => $skypeRecepteur,
  217.                                 ]
  218.                             );
  219.                         }
  220.                         if ($quitter == true) {
  221.                             $aler->setRefus(1);
  222.                             $aler->setQuitter(false);
  223.                             $em->persist($aler);
  224.                             $em->flush();
  225.                             $lock 1;
  226.                             return new JsonResponse(
  227.                                 [
  228.                                     'valide'          => '0',
  229.                                     'url'             => $acti->getUrl(),
  230.                                     'lock'            => $lock,
  231.                                     'refus'           => $refus,
  232.                                     'quitter'         => $aler->getQuitter(),
  233.                                     'supprime'        => $aler->getSupprime(),
  234.                                     'nomEmetteur'     => $aler->getEmetteur()->getNom(),
  235.                                     'prenomEmetteur'  => $aler->getEmetteur()->getPrenom(),
  236.                                     'nomRecepteur'    => $aler->getRecepteur()->getNom(),
  237.                                     'prenomRecepteur' => $aler->getRecepteur()->getPrenom(),
  238.                                     'telRecepteur'    => $telRecepteur,
  239.                                     'skypeRecepteur'  => $skypeRecepteur,
  240.                                 ]
  241.                             );
  242.                         } else {
  243.                             $aler->setTimestamp(new \DateTime());
  244.                             $aler->setEmetteur($user);
  245.                             $aler->setSupprime(false);
  246.                             $aler->setQuitter(false);
  247.                             $aler->setRecepteur($acti->getUtilisateur());
  248.                             $aler->setURL($acti->getUrl());
  249.                             $em->persist($aler);
  250.                             $em->flush();
  251.                             $lock 1;
  252.                             return new JsonResponse(
  253.                                 [
  254.                                     'valide'          => '0',
  255.                                     'url'             => $acti->getUrl(),
  256.                                     'lock'            => $lock,
  257.                                     'refus'           => $refus,
  258.                                     'quitter'         => $quitter,
  259.                                     'supprime'        => $aler->getSupprime(),
  260.                                     'nomEmetteur'     => $aler->getEmetteur()->getNom(),
  261.                                     'prenomEmetteur'  => $aler->getEmetteur()->getPrenom(),
  262.                                     'nomRecepteur'    => $aler->getRecepteur()->getNom(),
  263.                                     'prenomRecepteur' => $aler->getRecepteur()->getPrenom(),
  264.                                     'telRecepteur'    => $telRecepteur,
  265.                                     'skypeRecepteur'  => $skypeRecepteur,
  266.                                 ]
  267.                             );
  268.                         }
  269.                     } else {
  270.                         $aler = new Alerte();
  271.                         $aler->setEmetteur($user);
  272.                         $aler->setRecepteur($acti->getUtilisateur());
  273.                         $aler->setRoute($route);
  274.                         $aler->setLu(false);
  275.                         $aler->setOnglet($onglet);
  276.                         $aler->setSupprime(false);
  277.                         $aler->setRefus(0);
  278.                         $aler->setURL($acti->getUrl());
  279.                         $em->persist($aler);
  280.                         $em->flush();
  281.                         $lock 1;
  282.                         return new JsonResponse(
  283.                             [
  284.                                 'valide'          => '0',
  285.                                 'url'             => $acti->getUrl(),
  286.                                 'onglet'          => $onglet,
  287.                                 'lock'            => $lock,
  288.                                 'quitter'         => $aler->getQuitter(),
  289.                                 'supprime'        => $aler->getSupprime(),
  290.                                 'nomEmetteur'     => $aler->getEmetteur()->getNom(),
  291.                                 'prenomEmetteur'  => $aler->getEmetteur()->getPrenom(),
  292.                                 'nomRecepteur'    => $aler->getRecepteur()->getNom(),
  293.                                 'prenomRecepteur' => $aler->getRecepteur()->getPrenom(),
  294.                                 'telRecepteur'    => $aler->getRecepteur()->getTelephone(),
  295.                                 'skypeRecepteur'  => $aler->getRecepteur()->getSkype(),
  296.                             ]
  297.                         );
  298.                     }
  299.                 } else {
  300.                     $lock 4;
  301.                     return new JsonResponse(
  302.                         [
  303.                             'valide'          => '0',
  304.                             'url'             => $currentRoute,
  305.                             'lu'              => $lu,
  306.                             'lock'            => $lock,
  307.                             'refus'           => $refus,
  308.                             'quitter'         => $quitter,
  309.                             'supprime'        =>
  310.                                 "null",
  311.                             'nomEmetteur'     => $nomEmetteur,
  312.                             'prenomEmetteur'  => $prenomEmetteur,
  313.                             'nomRecepteur'    => $nomRecepteur,
  314.                             'prenomRecepteur' => $prenomRecepteur,
  315.                             'telRecepteur'    => $telRecepteur,
  316.                             'skypeRecepteur'  => $skypeRecepteur,
  317.                         ]
  318.                     );
  319.                 }
  320.             }
  321.         } else {
  322.             $test strstr($currentRoute'/notif'true);
  323.             $acti = new Activite;
  324.             $acti->setUtilisateur($user);
  325.             $acti->setURL($currentRoute);
  326.             $em->persist($acti);
  327.             $em->flush();
  328.             $lock 4;
  329.             return new JsonResponse(['valide' => '0''url' => $currentRoute'lu' => $lu'lock' => $lock'route' => $route]);
  330.         }
  331.     }
  332.     /**
  333.      * @Route("/alerte/refus/{type}/{id}", name="dtc_alerte_refus")
  334.      */
  335.     public function alerteRefusAction(Request $requestEntityManagerInterface $em)
  336.     {
  337.         $currentRoute dirname($_SERVER['SERVER_PROTOCOL'])."://".$_SERVER['HTTP_HOST'].$_SERVER['REQUEST_URI'];
  338.         $url          str_replace("refus/"""$currentRoute);
  339.         $repo_alerte  $em->getRepository(Alerte::class);
  340.         $aler         $repo_alerte->findOneBy([
  341.                                                     'url'      => $url,
  342.                                                     'supprime' => false,
  343.                                                 ]);
  344.         if (is_object($aler)) {
  345.             $aler->setRefus(1);
  346.             $em->persist($aler);
  347.             $em->flush();
  348.             return new JsonResponse(['valide' => '0''refus' => 1'url' => $url]);
  349.         } else {
  350.             return new JsonResponse(['valide' => '0''refus' => 0'url' => $url]);
  351.         }
  352.     }
  353.     /**
  354.      * @Route("/alerte/quitter/{type}/{id}", name="dtc_alerte_quitter")
  355.      */
  356.     public function alerteQuitterAction(Request $requestEntityManagerInterface $em)
  357.     {
  358.         $currentRoute dirname($_SERVER['SERVER_PROTOCOL'])."://".$_SERVER['HTTP_HOST'].$_SERVER['REQUEST_URI'];
  359.         $url          str_replace("quitter/"""$currentRoute);
  360.         $repo_alerte  $em->getRepository(Alerte::class);
  361.         $aler         $repo_alerte->findOneBy([
  362.                                                     'url'      => $url,
  363.                                                     'supprime' => false,
  364.                                                 ]);
  365.         if (is_object($aler)) {
  366.             $aler->setQuitter(true);
  367.             $em->persist($aler);
  368.             $em->flush();
  369.             return new JsonResponse(['valide' => '0''quitter' => true'url' => $url]);
  370.         } else {
  371.             return new JsonResponse(['valide' => '0''quitter' => false'url' => $url]);
  372.         }
  373.     }
  374.     /**
  375.      * @Route("/alerte/accord/{type}/{id}", name="dtc_alerte_accord")
  376.      */
  377.     public function alerteAccordAction(Request $requestEntityManagerInterface $em)
  378.     {
  379.         $currentRoute dirname($_SERVER['SERVER_PROTOCOL'])."://".$_SERVER['HTTP_HOST'].$_SERVER['REQUEST_URI'];
  380.         $url          str_replace("accord/"""$currentRoute);
  381.         $repo_alerte  $em->getRepository(Alerte::class);
  382.         $aler         $repo_alerte->findOneBy([
  383.                                                     'url'      => $url,
  384.                                                     'supprime' => false,
  385.                                                 ]);
  386.         if (is_object($aler)) {
  387.             $aler->setRefus(2);
  388.             $aler->setNotif(1);
  389.             $em->persist($aler);
  390.             $em->flush();
  391.             return new JsonResponse(['valide' => '0''refus' => 2'url' => $url'titre' => "test"]);
  392.         } else {
  393.             return new JsonResponse(['valide' => '0''refus' => 0'url' => $url'titre' => "lalalalala"]);
  394.         }
  395.     }
  396.     /**
  397.      * @Route("/alerte_notif", name="dtc_alerte_notif")
  398.      */
  399.     public function alerteNotifAction(Request $requestEntityManagerInterface $em)
  400.     {
  401.         $user $this->getUser();
  402.         $repo_alerte $em->getRepository(Alerte::class);
  403.         $aler        $repo_alerte->findOneBy([
  404.                                                    'emetteur' => $user,
  405.                                                    'supprime' => false,
  406.                                                    'notif'    => true,
  407.                                                    'quitter'  => true,
  408.                                                ]);
  409.         $aler2       $repo_alerte->findOneBy([
  410.                                                    'emetteur' => $user,
  411.                                                    'supprime' => false,
  412.                                                ]);
  413.         if (is_object($aler)) {
  414.             $test $aler->getUrl();
  415.             $test str_replace("164.177.114.40"""$test);
  416.             $test str_replace("192.168.1.6"""$test);
  417.             $test preg_replace('/[^0-9]/'''$test);
  418.             //164.177.114.40
  419.             //192.168.1.6
  420.             $onglet          $aler->getOnglet();
  421.             $nomRecepteur    $aler->getRecepteur()->getNom();
  422.             $prenomRecepteur $aler->getRecepteur()->getPrenom();
  423.             return new Response(
  424.                 json_encode(
  425.                     [
  426.                         'valide'          => '0',
  427.                         'notif'           => 1,
  428.                         'user'            => $user->getId(),
  429.                         'route'           => $aler->getRoute(),
  430.                         'id'              => $test,
  431.                         'onglet'          => $onglet,
  432.                         "nomRecepteur"    => $nomRecepteur,
  433.                         "prenomRecepteur" => $prenomRecepteur,
  434.                     ]
  435.                 ),
  436.                 200,
  437.                 ['Content-Type' => 'application/json']
  438.             );
  439.         }
  440.         if (is_object($aler2)) {
  441.             $repo_activite $em->getRepository(Activite::class);
  442.             $acti          $repo_activite->findOneBy([
  443.                                                            'url' => $aler2->getUrl(),
  444.                                                        ]);
  445.             if (is_object($acti)) {
  446.                 $timestampactivite $acti->getTimestamp();
  447.                 $timestampactuelle = new \DateTime();
  448.                 $time              $timestampactuelle->diff($timestampactivite);
  449.                 $nomRecepteur      $aler2->getRecepteur()->getNom();
  450.                 $prenomRecepteur   $aler2->getRecepteur()->getPrenom();
  451.                 $onglet            $aler2->getOnglet();
  452.                 $test              preg_replace('/[^0-9]/'''$aler2->getUrl());
  453.                 $nomRecepteur      $aler2->getRecepteur()->getNom();
  454.                 $prenomRecepteur   $aler2->getRecepteur()->getPrenom();
  455.                 if ($time->format('%s') >= 15 || $time->format('%i') >= || $time->format('%h') >= || $time->format('%d') >= || $time->format('%m') >= || $time->format(
  456.                         '%y'
  457.                     ) >= && $acti->getUtilisateur() != $user) {
  458.                     return new JsonResponse(
  459.                         [
  460.                             'valide'          => '0',
  461.                             'notif'           => 1,
  462.                             'user'            => $user->getId(),
  463.                             'route'           => $aler2->getRoute(),
  464.                             'id'              => $test,
  465.                             'onglet'          => $onglet,
  466.                             "nomRecepteur"    => $nomRecepteur,
  467.                             "prenomRecepteur" => $prenomRecepteur,
  468.                         ]
  469.                     );
  470.                 } else {
  471.                     return new JsonResponse(
  472.                         [
  473.                             'valide'          => '0',
  474.                             'notif'           => 0,
  475.                             'user'            => $user->getId(),
  476.                             'route'           => $aler2->getRoute(),
  477.                             'id'              => $test,
  478.                             'onglet'          => $onglet,
  479.                             "nomRecepteur"    => $nomRecepteur,
  480.                             "prenomRecepteur" => $prenomRecepteur,
  481.                         ]
  482.                     );
  483.                 }
  484.             }
  485.         } else {
  486.             return new JsonResponse(['valide' => '0''notif' => 0'user' => $user->getId()]);
  487.         }
  488.     }
  489.     /**
  490.      * @Route("/alerte_notif/refus", name="dtc_alerte_notif_refus")
  491.      */
  492.     public function alerteNotifRefusAction(Request $requestEntityManagerInterface $em)
  493.     {
  494.         $user $this->getUser();
  495.         $repo_alerte $em->getRepository(Alerte::class);
  496.         $aler        $repo_alerte->findOneBy([
  497.                                                    'emetteur' => $user,
  498.                                                    'supprime' => false,
  499.                                                    'notif'    => true,
  500.                                                    'quitter'  => true,
  501.                                                ]);
  502.         $aler2       $repo_alerte->findOneBy([
  503.                                                    'emetteur' => $user,
  504.                                                    'supprime' => false,
  505.                                                ]);
  506.         if (is_object($aler)) {
  507.             $aler->setNotif(0);
  508.             $aler->setSupprime(1);
  509.             $em->persist($aler);
  510.             $em->flush();
  511.             return new JsonResponse(['valide' => '0''notif' => 0'user' => $user->getId()]);
  512.         }
  513.         if (is_object($aler2)) {
  514.             $repo_activite $em->getRepository(Activite::class);
  515.             $acti          $repo_activite->findOneBy([
  516.                                                            'url' => $aler2->getUrl(),
  517.                                                        ]);
  518.             if (is_object($acti)) {
  519.                 $aler2->setNotif(0);
  520.                 $aler2->setSupprime(1);
  521.                 $em->persist($aler2);
  522.                 $em->flush();
  523.                 return new JsonResponse(['valide' => '0''notif' => 0'user' => $user->getId()]);
  524.             } else {
  525.                 return new JsonResponse(['valide' => '0''notif' => 1'user' => $user->getId()]);
  526.             }
  527.         } else {
  528.             return new JsonResponse(['valide' => '0''notif' => 1'user' => $user->getId()]);
  529.         }
  530.     }
  531. }