src/Services/user/LoginManager.php line 136

Open in your IDE?
  1. <?php
  3. /*
  4.  * Description of LoginManager
  5.  * Service de gestion des connexions et des droits des utilisateurs.
  6.  *
  7.  * @author Edmond
  8.  */
  10. namespace App\Services\user;
  12. use Symfony\Component\HttpFoundation\Session\SessionInterface;
  13. use \Doctrine\ORM\EntityManagerInterface;
  14. use App\Types\param\TypeParametre;
  15. use App\Services\param\ParametreManagerInterface;
  16. use App\Services\param\ParametreManager;
  17. use App\Services\param\DateManagerInterface;
  18. use App\Types\param\TypeDonnees;
  19. use Doctrine\ORM\Tools\Pagination\Paginator;
  20. use App\Types\user\TypeEtat;
  21. use App\Types\user\TypeProfil;
  22. use App\Types\user\TypeSexe;
  23. use App\Entity\user\Utilisateur;
  24. use App\Repository\user\UtilisateurRepository;
  25. use App\Repository\param\ParamRepository;
  26. use App\Entity\user\Profil;
  27. use App\Repository\user\connexionRepository;
  28. use App\Repository\user\ActionRepository;
  29. use App\Repository\user\ModuleRepository;
  30. use App\Repository\user\ControleurRepository;
  31. use App\Repository\user\ProfilRepository;
  32. use App\Entity\user\Controleur;
  33. use App\Entity\user\Action;
  34. use App\Entity\user\Module;
  35.  
  36. use PDO;
  37. /**
  38.  * LoginManager
  39.  * 
  40.  * Service de gestion des connexions et des droits des utilisateurs.
  41.  * Permet de connecter un utilisateur, de créer une session et aussi de la supprimer
  42.  * L'attribution de droit, la déconnexion automatique suite à un long moment d'innactivité et historisation de toute les
  43.  * actions effectuées par le conntecté dans un fichier txt et/ou dans la table Connexion
  44.  * 
  45.  */
  46. class LoginManager {
  48.     /*
  49.      *
  50.      * @var \Doctrine\ORM\EntityManager  $em : gestionnaire d'entité
  51.      * 
  52.      */
  53.     private $em;
  55.     /*
  56.      *
  57.      * @var Symfony\Component\HttpFoundation\Session\Session  $session : Une instance de la la session de Symfony
  58.      */
  59.     private $session;
  61.     /*
  62.      *
  63.      * @var Services\param\ParametreManager  $parametreManager
  64.      * Une instance du service ParametreManager permetant la gestion des paramètres de l'application
  65.      */
  66.     private $parametreManager;
  68.     /*
  69.      * 
  70.      * @var facture\AdmindBundle\Services\DateManager  $dateManager
  71.      * Une instance du service DateManager permetant diverses traitements sur les dates,
  72.      * date de PHP et la classe \DateTime de Symfony
  73.      */
  74.     private $dateManager;
  76.     /*
  77.      * 
  78.      * @var string  $paramBundle
  79.      * Nom du Bundle
  80.      */
  81.     private $paramBundle = 'adminParamBundle:';
  83.     /*
  84.      * 
  85.      * @var string  $userBundle
  86.      * Nom du Bundle
  87.      */
  88.     //private $userBundle = 'App\Entity\user\';
  90.     /*
  91.      * Nom de la session
  92.      */
  93.     CONST SESSION_DATA_NAME = 'adsds6HhDbdhhd899b6f2ea76';
  95.    
  96.     /*
  97.      * le constructeur qui initialise les attributs
  98.      * 
  99.      * @param \Doctrine\ORM\EntityManager $em
  100.      * @param \Symfony\Component\HttpFoundation\Session\Session $s
  101.      * @param \Services\param\ParametreManager $p
  102.      * @param \Services\param\DateManager $d
  103.      */
  104.     public function __construct(EntityManagerInterface $em, SessionInterface $s, ParametreManagerInterface $p, DateManagerInterface $d) {
  105.         $this->em = $em;
  106.         $this->session = $s;
  107.         $this->parametreManager = $p;
  108.         $this->dateManager = $d;
  109.          
  110.         //si la session n'a pas demarré alors on la demarre
  111.         if ((!isset($_SESSION)) && (!$this->session->isStarted() )) {
  112.             
  113.             $this->session->start();
  114.         }
  115.     }
  117.     /*
  118.      * 
  119.      * 
  120.      * @param type $idConnexion
  121.      * @return array
  122.      */
  123.     
  124.     /*
  125.      * 
  126.      *Retourne les détails d'une connexion, L'emsemble des actions effectuées par le connecté
  127.      * 
  128.      * @author armand.tevi@gmail.com
  129.      * @copyright  2015
  130.      * @version 1
  131.      * @access   public
  132.      * @param int $idConnexion
  133.      * @param int $isUser (0 ou 1)
  134.      * @return string
  135.      */
  136.     public function getDetailsConnexion($idConnexion = 0, $isUser = 1, $connexionRepository, $utilisateurRepository) {
  137.         $connexion = $connexionRepository->find($idConnexion);
  138.         if ($connexion == NULL) {
  139.             return NULL;
  140.         }
  142.         $queryTabIdActions = $connexion->getTabIdActions();
  143.         $queryTabDates = $connexion->getTabDateActions();
  144.         $taille = count($queryTabDates);
  146.         /*
  147.          * On récupère la date et les id des différentes actions exécutées par le connecté
  148.          */
  149.         $tabIdActions = array();
  150.         $tabDates = array();
  151.         for ($i = ($taille - 1); $i >= 0; $i--) {
  152.             $tabDates[] = $queryTabDates[$i];
  153.             $tabIdActions[] = $queryTabIdActions[$i];
  154.         }
  157.         /*
  158.          * On récupère les objets actions
  159.          */
  160.         $rep = array();
  161.         foreach ($tabIdActions as $key => $idAction) {
  162.             $action = $utilisateurRepository->find($idAction);
  163.             if ($action != NULL) {
  164.                 $dateAction = NULL;
  165.                 if (array_key_exists($key, $tabDates)) {
  166.                     $dateAction = $tabDates[$key];
  167.                 }
  168.                 $rep[] = array('action' => $action, 'date' => $dateAction);
  169.             }
  170.         }
  172.         /*
  173.          * On trouve celui qui s'était connecté
  174.          */
  175.         $user = ($isUser == 1) ? $connexion->getUtilisateur() : $connexion->getAbonne();
  177.         return array('user' => $user, 'details' => $rep, 'connexion' => $connexion);
  178.     }
  180.     /*
  181.      * Retourne l'historique de connexion d'un user
  182.      * 
  183.      * @param type $idUser
  184.      * @param type $isUser
  185.      * @param type $nbParPage
  186.      * @param type $pageActuelle
  187.      * @return array|Paginator
  188.      */
  189.     public function getHistoriqueConnexion($idUser, $isUser = TRUE, $nbParPage = 20, $pageActuelle = 1,$connexionRepository, $utilisateurRepository) {
  190.         $nomTable = ($isUser) ? 'Utilisateur' : 'Abonne';
  191.         $user = $utilisateurRepository->find($idUser);//$this->em->getRepository($this->userBundle . $nomTable)->find($idUser);
  192.         $nbTotal = $this->getNbTotalHistoriqueConnexion($idUser, $isUser,$connexionRepository, $utilisateurRepository);
  193.         $rep = array('data' => array(), 'nbParPage' => $nbParPage, 'pageActuelle' => $pageActuelle, 'nbTotal' => $nbTotal, 'nbTotalPage' => 1, 'user' => NULL);
  194.         if ($user != NULL) {
  195.             $queryBulder1 = $connexionRepository->createQueryBuilder('c');
  197.             if ($isUser) {
  198.                 $queryBulder1 = $queryBulder1->leftJoin('c.utilisateur', 'a')
  199.                         ->addSelect('a')
  200.                         ->where('a.id = :user');
  201.             } else {
  202.                 $queryBulder1 = $queryBulder1->leftJoin('c.abonne', 'a')
  203.                         ->addSelect('a')
  204.                         ->where('a.id = :user');
  205.             }
  206.             $queryBulder1->setParameter('user', $idUser)
  207.                     ->orderBy('c.dateLastAction', 'DESC');
  209.             $pageActuelleInt = (int) $pageActuelle;
  210.             $nbParPageInt = (int) $nbParPage;
  211.             if ($pageActuelleInt < 1) {
  212.                 $pageActuelleInt = 1;
  213.             }
  214.             if ($nbParPageInt < 1) {
  215.                 $nbParPageInt = 20;
  216.             }
  217.             $nbTotalPage = intval($nbTotal / $nbParPage);
  218.             if ($nbTotalPage < 1) {
  219.                 $nbTotalPage = 1;
  220.             }
  221.             if ($pageActuelleInt > $nbTotalPage) {
  222.                 $pageActuelleInt = $nbTotalPage;
  223.             }
  225.             $query = $queryBulder1->getQuery();
  226.             $query->setFirstResult(($pageActuelleInt - 1) * $nbParPageInt);
  227.             $query->setMaxResults($nbParPageInt);
  228.             $rep['nbParPage'] = $nbParPage;
  229.             $rep['pageActuelle'] = $pageActuelle;
  230.             $rep['nbTotal'] = $nbTotal;
  231.             $rep['nbTotalPage'] = $nbTotalPage;
  232.             $rep['user'] = $user;
  233.             $rep['data'] = new Paginator($query);
  234.         }
  236.         return $rep;
  237.     }
  239.     private function getNbTotalHistoriqueConnexion($idUser, $isUser = FALSE,$connexionRepository, $utilisateurRepository) {
  240.         $nbTotal = 0;
  241.         $nomTable = ($isUser) ? 'Utilisateur' : 'Abonne';
  242.         $user = $utilisateurRepository->find($idUser);//$this->em->getRepository($this->userBundle . $nomTable)->find($idUser);
  243.         if ($user != NULL) {
  244.             $queryBulder1 = $connexionRepository->createQueryBuilder('c');
  246.             if ($isUser) {
  247.                 $queryBulder1 = $queryBulder1->leftJoin('c.utilisateur', 'a')
  248.                         ->addSelect('a')
  249.                         ->where('a.id = :user');
  250.             } else {
  251.                 $queryBulder1 = $queryBulder1->leftJoin('c.abonne', 'a')
  252.                         ->addSelect('a')
  253.                         ->where('a.id = :user');
  254.             }
  255.             $queryBulder1->setParameter('user', $idUser);
  256.             $rep = $queryBulder1->getQuery()->getResult();
  257.             $nbTotal = count($rep);
  258.         }
  259.         return $nbTotal;
  260.     }
  262.     /*
  263.      * retourne le contenu d'une cellule d'un tableau avec sa clée
  264.      * 
  265.      * @param string $cle
  266.      * @param array $array
  267.      * 
  268.      * @return type
  269.      */
  270.     private function getValueInArray($cle, $array) {
  271.         $rep = null;
  272.         if (is_array($array)) {
  273.             if (array_key_exists($cle, $array)) {
  274.                 $rep = $array[$cle];
  275.             }
  276.         }
  278.         return $rep;
  279.     }
  281.     /*
  282.      * retourne une info contenue dans la session avec sa clée
  283.      * 
  284.      * @param string $cle
  285.      * 
  286.      * @return type
  287.      */
  288.     public function getSessionData($cle) {
  289.         
  290.         $rep = null;
  291.         if (!empty($cle)) {
  292.             $rep = $this->getValueInArray($cle, $_SESSION);
  293.         }
  295.         return $rep;
  296.     }
  298.     /*
  299.      *  ajoute des infos à la session
  300.      */
  301.     public function setSessionData($cle = LoginManager::SESSION_DATA_NAME, $data = array()) {
  302.         $_SESSION[$cle] = $data;
  303.         $this->session->set($cle, $data );
  304.     }
  306.     /*
  307.      * Déconnexion du connecté
  308.      * 
  309.      * @param string $cle 
  310.      */
  311.     public function logout($cle = LoginManager::SESSION_DATA_NAME, ParamRepository $paramRepository, ConnexionRepository $connexionRepository, ActionRepository $actionRepository, UtilisateurRepository $userRepository) {
  312.         if ($this->isConnecte('', $paramRepository,  $connexionRepository,  $actionRepository ) ){ // une connexion existe
  313.             // récupération des infos du connecté
  314.             $data = $this->getSessionData($cle);
  315.             if ($data != NULL) {
  316.                 // récupération de l'objet Connexion
  317.                 $con = $userRepository->find($data['idConnexion']);
  318.                 if ($con != NULL) {
  319.                     // mis à jour de la date de la derniere action
  320.                     $dateAcutelle = new \DateTime();
  321.                     //$dateConnexion = $con->getDateConnexion();
  322.                    // $dureeConnexion = $this->dateManager->convertDureeConnexionToString($dateConnexion, $dateAcutelle);
  323.                     //$con->setDateLastAction($dateAcutelle);
  324.                     //$con->setDateDeconnexion($dateAcutelle);
  325.                     //$con->setDureeConnexion($dureeConnexion);
  326.                 }
  328.                 // mis à jour de l'état connecté
  329.                 $u = $userRepository->find($data['id']);
  330.                 if ($u != NULL) {
  331.                     $u->setEtatConnecte(FALSE);
  332.                 }
  333.                 // enregistrement des informations
  334.                 $this->em->flush();
  335.             }
  336.         }
  338.         // suppression des variables de session
  339.         unset($_SESSION[$cle]);
  340.         $_SESSION[$cle] = NULL;
  341.     }
  343.     /*
  344.      * suppression des infos du connecté
  345.      */
  346.     public function deleteSessionData($cle = LoginManager::SESSION_DATA_NAME) {
  347.         unset($_SESSION[$cle]);
  348.         $_SESSION[$cle] = array();
  349.     }
  351.     /*
  352.      * Vérifie si l'utilisateur est connecté.
  353.      * Retourne un tableu contenant 4 entrées decrites ci-dessous
  354.      * 
  355.      * 1- isConnecte  : boolean - Indique si une session existe, donc si l'utilisateur est connecté ou pas
  356.      * 2- isInnactif : boolean - Indique si l'utilisateur courant a accusé un long moment d'innactivité. Si TRUE il sera déconnecté automatiquement
  357.      * 3- isUser : boolean - Indique si le connecté est un User (Utilisateur)
  358.      * 4- isAbonne : boolean - Indique si le connecté est un abonne 
  359.      * 
  360.      * @param string $nomDAction : Le nom de l'action où est invoqué le méthode isConnecte. Il permet, au cas où une session existe de créer une historique
  361.      * des divers actions éffectuées par le connecté. Ces informations (historiques) sont enregistrées dans la table Connexion
  362.      * 
  363.      * @return array
  364.      */
  365.     public function isConnecte($nomDAction, ParamRepository $paramRepository, ConnexionRepository $connexionRepository, ActionRepository $actionRepository) {
  366.         // initialisation de réponse
  367.         $rep = array('isConnecte' => FALSE, 'isInnactif' => FALSE, 'isUser' => FALSE, 'isAbonne' => FALSE);
  368.         $nomAction = trim($nomDAction);
  369.         $sessionData = $this->getSessionData(LoginManager::SESSION_DATA_NAME);
  370.         
  371.         if (($sessionData != NULL) && ($sessionData['id'] > 0 )) {
  372.             $rep['isConnecte'] = TRUE;
  373.             $rep['isUser'] = $sessionData['isUser'];
  374.             $rep['isAbonne'] = $sessionData['isAbonne'];
  375.             // on vérifie si le connecté n'est pas innactif
  376.             $rep['isInnactif'] = $this->isInactivite($nomAction, $paramRepository, $connexionRepository, $actionRepository);
  377.         }
  379.         return $rep;
  380.     }
  382.     /*
  383.      * Vérifie si le conntecte est un  abonne et non un utilisateur 
  384.      * @return type
  385.      */
  386.     private function isAbonne() {
  387.         return ($this->getTableConnecte() == App\Types\user\TypeTable::ABONNE);
  388.     }
  390.     /*
  391.      * Vérifie si le conntecte est un utilisateur et non un abonne
  392.      * @return type
  393.      */
  394.     private function isUtilisateur() {
  395.         return ($this->getTableConnecte() == App\Types\user\TypeTable::UTILISATEUR);
  396.     }
  398.     /*
  399.      * Retourne le nom de la table connecté
  400.      * @return type
  401.      */
  402.     public function getTableConnecte() {
  403.         $table = null;
  404.         $sessionDate = $this->getSessionData(LoginManager::SESSION_DATA_NAME);
  405.         if ($sessionDate != NULL) {
  406.             $table = $sessionDate['nomTableConnecte'];
  407.         }
  408.         return $table;
  409.     }
  411.     /*
  412.      * Vérifie si le connecté a dépassé la durée max d'innactivité
  413.      * 
  414.      * @param string $nomAction
  415.      * 
  416.      * @return boolean
  417.      */
  418.     public function isInactivite($nomAction = '', ParamRepository $paramRepository, ConnexionRepository $connexionRepository, ActionRepository $actionRepository) {
  419.         $rep = FALSE;
  420.         $sessionData = $this->getSessionData(LoginManager::SESSION_DATA_NAME);
  422.         $configurationAutoLogOut = $this->parametreManager->getValeurParametre(TypeParametre::TIME_OUT_BOOL,1,$paramRepository);
  424.         $connexion = $connexionRepository->find($sessionData['idConnexion']);
  426.         $action = $actionRepository->findOneBy(array('nom' => $nomAction));
  428.         if (($configurationAutoLogOut != NULL) && ($configurationAutoLogOut == TRUE) && ($connexion != NULL)) { // la déconnexion automatique est activée
  429.             if (($sessionData != NULL) && (isset($sessionData['id'])) && ( $sessionData['id'] > 0)) { // effectivement connecte
  430.                 // récuperation de la Connexion en cours
  431.                 $dateActuelle = new \DateTime();
  432. //                $now = $dateActuelle->createFromFormat('Y-m-d H:i:s', time());
  433.                 // calcul des minutes d'innactivité
  434.                 $minutes = $this->dateManager->getMinutesEcoulees($connexion->getDateLastAction(), $dateActuelle);
  435.                 // récupération de la duréé maximale d'innactivité
  437.                 $maxMinute = $this->parametreManager->getValeurParametre(TypeParametre::DUREE_TIME_OUT_INT,1,$paramRepository);
  439.                 if (($maxMinute != NULL) && ( $minutes >= $maxMinute)) {
  440.                     $rep = TRUE; // le connecté a accusé un long tps d'innactivité
  441.                 }
  442.             }
  443.         }
  444.         
  445.         if (($action != NULL) && ($connexion != NULL)) {
  446.             // mis a jr des infos de navigation
  448.             $tabIdActions = $connexion->getTabIdActions();
  449.             $tabIdActions[] = $action->getId();
  450.             
  451.             $connexion->setTabIdActions($tabIdActions);
  453.             $tabDateActions = $connexion->getTabDateActions();
  454.             $tabDateActions[] = date('d-m-Y H:i:s');
  455.             $connexion->setTabDateActions($tabDateActions);
  457.             $connexion->setDateLastAction(new \DateTime());
  458.             $this->em->flush();
  459.         }
  461.         /*
  462.          * Admin page accueil
  463.          */
  464.         if (($action == NULL) && ($nomAction == 'homeAction') && ($connexion != NULL)) {
  465.             $tabIdActions = $connexion->getTabIdActions();
  466.             
  467.             $tabIdActions[] = 0;
  468.             $connexion->setTabIdActions($tabIdActions);
  470.             $tabDateActions = $connexion->getTabDateActions();
  471.             $tabDateActions[] = date('d-m-Y H:i:s');
  472.             $connexion->setTabDateActions($tabDateActions);
  474.             $connexion->setDateLastAction(new \DateTime());
  475.             $this->em->flush();
  476.         }
  478.         /*
  479.          * Abonne page accueil
  480.          */
  481.         if (($action == NULL) && ($nomAction == 'siteHomeAction') && ($connexion != NULL)) {
  482.             $tabIdActions = $connexion->getTabIdActions();
  483.             $tabIdActions[] = 0;
  484.             $connexion->setTabIdActions($tabIdActions);
  486.             $tabDateActions = $connexion->getTabDateActions();
  487.             $tabDateActions[] = date('d-m-Y H:i:s');
  488.             $connexion->setTabDateActions($tabDateActions);
  490.             $connexion->setDateLastAction(new \DateTime());
  491.             $this->em->flush();
  492.         }
  495.         return $rep;
  496.     }
  498.     /*
  499.      * retourne les infos de session du connecte
  500.      * 
  501.      * @return array
  502.      */
  503.     public function getInfosCurrentConnecte() {
  504.         return $this->getSessionData(LoginManager::SESSION_DATA_NAME);
  505.     }
  507.     /*
  508.      * retourne l'id du connecté courant
  509.      * 
  510.      * @return int : Retourne 0 aucune session n'existe
  511.      */
  512.     public function getCurrentId() {
  513.         $sessionData = $this->getSessionData(LoginManager::SESSION_DATA_NAME);
  515.         return ($sessionData == NULL) ? 0 : $sessionData['id'];
  516.     }
  518.     /*
  519.      * Retourne le locale actuel
  520.      * @return type
  521.      */
  522.     public function getLocale() {
  523.         $locale = 'fr';
  524.         $sessionLocale = $this->getSessionData('locale');
  525.         if ($sessionLocale == NULL) {
  526.             $sessionLocale = array('locale' => $locale);
  527.             $this->setSessionData('locale', $sessionLocale);
  528.         } else {
  529.             $locale = $sessionLocale['locale'];
  530.         }
  531.         return $locale;
  532.     }
  534.     /*
  535.      * Met à jour le locale de la session 
  536.      * @param type $locale
  537.      */
  538.     public function setLocale($locale = 'fr') {
  539.         $sessionData = $this->getSessionData(LoginManager::SESSION_DATA_NAME);
  540.         if ($sessionData != NULL) {
  541.             $sessionData['locale'] = $locale;
  542.             $this->setSessionData(LoginManager::SESSION_DATA_NAME, $sessionData);
  543.         }
  544.         $sessionLocale = $this->getSessionData('locale');
  545.         if ($sessionLocale != NULL) {
  546.             $sessionLocale['locale'] = $locale;
  547.             $this->setSessionData('locale', $sessionData);
  548.         } else {
  549.             $sessionLocale = array('locale' => $locale);
  550.             $this->setSessionData('locale', $sessionLocale);
  551.         }
  552.     }
  554.     /*
  555.      * retourne le connecté courant (Il sagit d'un objet Utilisateur ou Personne). 
  556.      * 
  557.      * @return type
  558.      */
  559.     public function getCurrentConnecte() {
  560.         $rep = NULL;
  561.         $id = $this->getCurrentId();
  562.         if ($id > 0) {
  563.             $rep = $this->em->getRepository($this->userBundle . 'Utilisateur')->find($id);
  564.         }
  566.         return $rep;
  567.     }
  569.     /*
  570.      * Lors de la connexion, déconnecte tout ceux qui ont fait plus de 5h d'innactivité
  571.      * Il sagit des utilisateurs qui ont kité l'application sans se deconnecté. De ce fait leur étatConnecte vaut 1
  572.      * alors k leurs infos de session sont perdues. 
  573.      */
  574.     public function autoLogOutAfterTimeOutAll(UtilisateurRepository $reposiUtil, $connexionRepository) {
  575.         // déconnexion dans la table User
  576.         $users = $reposiUtil->findByEtatConnecte(TRUE);
  578.         foreach ($users as $p) {
  579.             $this->setEtatConnecteToFalse($p,$connexionRepository );
  580.         }
  581.     }
  583.     /*
  584.      * change l'étatConnecte des entité en FALSE
  585.      * pour utilisateurs ayant kité l'application sans se deconnecté. De ce fait leur étatConnecte vaut 1
  586.      * alors k leurs infos de session sont serdues.
  587.      * 
  588.      * @param type $user : une instance d'un d'utilisateur (User / Ressource)
  589.      * @param boolean $isUser : 
  590.      */
  591.     private function setEtatConnecteToFalse($user,$connexionRepository) {
  592.         if ($user != NULL) {
  593.             // récupération de la connexion expirée
  594.             $connexion = $connexionRepository->getNotLogoutConnexion($user->getId());
  596.             if ($connexion != NULL) { // connexion trouvée
  597.                 // calcul du nombre d'heure ecoulee juska present depuis la date de la derniere action
  598.                 $heuresEcoulees = $this->dateManager->getNombreHeuresEcollees($connexion->getDateLastAction(), new \DateTime());
  600.                 if ($heuresEcoulees >= 2) {  // nb d'heure supérieur à 5
  601.                     $connexion->setDateDeconnexion($connexion->getDateLastAction());
  602.                     // changement de l'étatConnecte de l'utilisateur
  603.                     $user->setEtatConnecte(FALSE);
  604.                     $this->em->flush();
  605.                 }
  606.             }
  607.         }
  608.     }
  610.     /*
  611.      * gestion des droits d'acces à une action
  612.      * 
  613.      * @param string $nomDuModule : code du module contenant l'action
  614.      * @param string $descModule : description du module contenant l'action
  615.      * @param string $descControl : description u controlleur contenant l'action
  616.      * 
  617.      * 
  618.      * @param string $nomDAction : nom de l'action
  619.      * @param string $descAction : description de l'action
  620.      * @param array $tabCodeProfil : tableau contenant les codes des Profils User à qui sont destinés l'action
  621.      * 
  622.      * @return boolean
  623.      */
  624.     public function getOrSetActions($nomDuModule, $descModule, $nomDuControleur, $descControl, $nomDAction, $descAction, $idProfil = 0, ModuleRepository $moduleRepository,ControleurRepository $controleurRepository,ActionRepository $actionRepository,ProfilRepository $profilRepository) {
  625.         // initialisation de la réponse
  626.         $rep = FALSE;
  627.         /* Contrôles liés aux paramètres */
  628.         $nomModule = trim($nomDuModule);
  629.         $nomControleur = trim($nomDuControleur);
  630.         $nomAction = trim($nomDAction);
  631.         /* fin Contrôles liés aux paramètres */
  633.        
  635.         // recuperation du module
  636.         $module = $moduleRepository->findOneByNom($nomModule);
  637.         if ($module == NULL) { //enregistrment du module au cas ou il est innexistant
  638.             $module = new Module($nomModule, $descModule);
  639.             $this->em->persist($module);
  640.         }
  641.         //var_dump(count($module));exit;
  642.         // récupération du contrôleur
  643.         $controleur = $controleurRepository->findOneByNom($nomControleur);
  644.         if ($controleur == NULL) { //enregistrment du controleur au cas ou il est innexistant
  645.             $controleur = new Controleur($nomControleur, $descControl);
  646.             $this->em->persist($controleur);
  647.         }
  648.         // enregistrement des informations dans la base de données
  649.         $this->em->flush();
  651.         
  652.         // récupération de l'action par rapport au module et au controleur
  653. //        $action = $this->em->getRepository($this->adminUserBundle . 'Action')->findOneByCode($codeAction);
  654.         $action = $actionRepository->findOneBy(array('nom' => $nomAction, 'module' => $module, 'controleur' => $controleur));
  656.         //var_dump($nomAction);exit;
  658.         if ($action == NULL) { //enregistrment de l'action au cas ou elle est innexistante
  659.             $action = new Action($nomAction, $descAction);
  660.             $action->setControleur($controleur);
  661.             $action->setModule($module);
  662.             $action->setNom($nomAction);
  663.             $action->setDescription($descAction);
  664.             $this->em->persist($action);
  665.             $this->em->flush();
  666.             $module->addAction($action);
  667.             $controleur->addAction($action);
  669.             $this->em->flush();
  670.             
  671.         }
  673.         if ($idProfil == NULL) {
  674.             $idProfil = 0;
  675.         }
  677.         // on vérifie si l'utilisateur a le droit 
  678.         $profil =  $profilRepository->find($idProfil);
  679.         
  680.         if ($profil != NULL) {
  681.             $rep = FALSE;
  682.             $tabActionOfProfil = $profil->getTabIdActions();
  683.             $idActionEncours = $action->getId();
  684.            
  685.             if (in_array($idActionEncours, $tabActionOfProfil)) {
  686.                 $rep = TRUE;
  687.             }
  688.         }
  689.         return $rep;
  690.     }
  692.     /*
  693.      * Mise à jour des droits d'un profil d'utilisateur. Retourne TRUE si l'action a réussie et FALSE si non
  694.      * 
  695.      * @param int $idProfil : identifiant du profil concerné.
  696.      * @param array $tabIdActionToAllow : tableau contenant les id (de type STRING car provenant du client ) des actions à autoriser au profil concerné
  697.      * des actions à autoriser au profil concerné
  698.      * @param string $nomTable : nom de l'entité représentant  le profil
  699.      * 
  700.      * @return boolean
  701.      */
  702.     public function updateDroitOfProfil($idProfil, $tabIdActionToAllow, $nomTable = 'Profil', $profilRepository) {
  703.         // iniatlisation de la réponse
  704.         $rep = FALSE;
  705.         // inialisation du tableau devant contenir les id (de type int) des actions à autoriser au profil concerné
  706.         $tabIdDroit = array();
  708.         // récupération du profil
  709.         $profil = $profilRepository->find($idProfil);//$this->em->getRepository($this->userBundle . $nomTable)->find($idProfil);
  711.         // la variable $tabIdActionToAllow est un tableau et possède au moins une entrée
  712.         if (is_array($tabIdActionToAllow) && count($tabIdActionToAllow) > 0) {
  713.             //Parcours du tableau $tabIdActionToAllow et conversion de chacune de ses entrée en une valeur de type int 
  714.             foreach ($tabIdActionToAllow as $id) {
  715.                 $id = (int) $id;
  716.                 if ($id > 0) {
  717.                     $tabIdDroit[] = (int) $id;
  718.                 }
  719.             }
  721.             // mis à jour des droits
  722.             if ($profil != NULL) {
  723.                 $profil->setTabIdActions($tabIdDroit);
  724.                 $this->em->flush();
  726.                 // la réponse passe à TRUE
  727.                 $rep = TRUE;
  728.                 /*
  729.                  * On met à jour les droits  du connecté au cas les modifications on touchées son profil
  730.                  */
  731.                 $sessionData = $this->getSessionData(LoginManager::SESSION_DATA_NAME);
  732.                 if (($sessionData != NULL) && ( $profil->getId() == $sessionData['idProfil'])) {
  733.                     $sessionData['tabIdActions'] = $tabIdDroit;
  734.                     $this->setSessionData(LoginManager::SESSION_DATA_NAME, $sessionData);
  735.                 }
  736.             }
  737.         }
  741.         return $rep;
  742.     }
  744.     /*
  745.      * Retourne la longueur des numéros de téléphones
  746.      * 
  747.      * @return int
  748.      */
  749.     public function getLengthTel(ParamRepository $paramRepository) {
  750.         $taille = $this->parametreManager->getValeurParametre(TypeParametre::LONGUEUR_NUM_TEL_INT,1,$paramRepository);
  751.         if ($taille == NULL) {
  752.             $taille = 8;
  753.         }
  755.         return $taille;
  756.     }
  757.     
  758.     /*
  759.      * Retourne le nombre maximal de tentatives de connexion
  760.      * 
  761.      * @return int
  762.      */
  763.     public function getMaxAttempt(ParamRepository $paramRepository) {
  764.         $maxAttempt = $this->parametreManager->getValeurParametre(TypeParametre::NB_ATTEMPT_INT,1, $paramRepository);
  765.         if ($maxAttempt == NULL) {
  766.             $maxAttempt = 3;
  767.         }
  769.         return $maxAttempt;
  770.     }
  772.     /*
  773.      * Retourne tous les profils abonné
  774.      * 
  775.      * @return array
  776.      */
  777.     public function getAllProfilAbonne() {
  778.         $criteria = array('etat' => TypeEtat::ACTIF, 'typeProfil' => TypeProfil::PROFIL_ABONNE);
  779.         $profilsAbonne = $this->em->getRepository($this->userBundle . 'Profil')->findBy($criteria);
  781.         return $profilsAbonne;
  782.     }
  784.     /*
  785.      * Ajoute les parametres par defaut
  786.      */
  787.     public function addDefaultParametre() {
  788.         $this->addDefaultUser();
  789.         $this->addDefaultConfig();
  790.     }
  792.     public function addDefaultConfig() {
  793.         $this->parametreManager->setParametre(TypeParametre::DUREE_TIME_OUT_INT, 15, TypeDonnees::INT, "Durée max d'inactivité", "Durée d'inactivité après laquelle l'utilisateur est déconnecté automatiquement");
  795.         $this->parametreManager->setParametre(TypeParametre::KEY_SMS_STR, '@ETR_ACE@', TypeDonnees::VARCHAR, "Clé SMS", "La clé de validation des SMS reçus. Il s’agit de clé de KANNEL ");
  797.         $this->parametreManager->setParametre(TypeParametre::LONGUEUR_CODE_BASE_INT, 5, TypeDonnees::INT, "Longueur code base", "Longueur des codes de base attribués automatiquement aux abonnés à leur création");
  799.         $this->parametreManager->setParametre(TypeParametre::LONGUEUR_CODE_SMS_CONFIRMATION_ORDRE_VIREMENT_INT, 10, TypeDonnees::INT, "Longueur code confirmation", "Longueur des codes de confirmation des ordres de virement effectués et acquittés par la banque");
  801.         $this->parametreManager->setParametre(TypeParametre::LONGUEUR_CODE_SMS_END_ORDRE_VIREMENT_INT, 10, TypeDonnees::INT, "Longueur code sms", "Longueur du code SMS envoyé à un abonné pour finaliser un ordre de virement ");
  803.         $this->parametreManager->setParametre(TypeParametre::LONGUEUR_COMPTE_INT, 14, TypeDonnees::INT, "Longueur compte", "Longueur des comptes bancaires ");
  805.         $this->parametreManager->setParametre(TypeParametre::LONGUEUR_MIN_PASSWORD_INT, 5, TypeDonnees::INT, "Longueur min password", "Longueur minimale des mots de passe  ");
  807.         $this->parametreManager->setParametre(TypeParametre::LONGUEUR_NUM_TEL_INT, 8, TypeDonnees::INT, "Longueur tel", "Longueur des numéros de téléphone sans l'indicatif téléphonique");
  809.         $this->parametreManager->setParametre(TypeParametre::NB_ATTEMPT_INT, 3, TypeDonnees::INT, "Max attempt", "Nombre maximal de tentatives de connexions échouées ");
  811.         $this->parametreManager->setParametre(TypeParametre::NB_MAX_MESSAGERIE_BOARD_INT, 10, TypeDonnees::INT, "Nombre de messages tableau de bord", "Nombre maximal de messages récents à afficher sur le tableau de bord");
  813.         $this->parametreManager->setParametre(TypeParametre::TIME_OUT_BOOL, 1, TypeDonnees::BOOLEAN, 'Déconnexion automatique', 'Active/désactive la déconnexion automatique');
  815.         $this->parametreManager->setParametre(TypeParametre::TIME_URL_INIT_PASSWORD_EXPIRE_INT, 2, TypeDonnees::INT, "Durée de vie des urls de réinitialisation de mot de passe", "Nombre maximal d'heures après lesquelles une route de réinitialisation de mot de passe expire ");
  816.         
  817.         $this->parametreManager->setParametre(TypeParametre::CHOIX_DESTINAIRE_MSG_PAR_ABONNE_BOOL, 1, TypeDonnees::INT, "Choix des destinaires d'un msg par les abonnes", "Indique si les abonné peuvent choisir le destinaire d'un message ou pas ");
  818.     }
  820.     private function addDefaultUser() {
  821.         $em = $this->em;
  822.         
  823.         $em->transactional(
  824.             function($em){
  826.                 $res =  $em->getRepository($this->userBundle . 'Profil')->findOneBy(array('nom'=>'MAINTENANCE'));
  827.                 
  828.                 if (!($res instanceof Profil)){
  829.                     $maintenance = new Profil();
  830.                     $maintenance->setCode('MAINTE');
  831.                     $maintenance->setDescription('Profil mainteance');
  832.                     $maintenance->setNom('MAINTENANCE');
  833.                     $maintenance->setTypeProfil(TypeProfil::PROFIL_UTILISATEUR);
  834.                     $em->persist($maintenance);
  835.                 }     
  836.                 //$this->em->flush();
  837.                 $res =  $em->getRepository($this->userBundle . 'Utilisateur')->findOneBy(array('email'=>'user@stock.com'));
  838.                 
  839.                 if (!($res instanceof Utilisateur)){
  840.                     $user = new Utilisateur();
  841.                     $user->setAdresse('Adresse user');
  842.                     $user->setAttempt(0);
  843.                     $user->setEmail('user@stock.com');
  844.                     $user->setNom('stockprouser');
  845.                     $passWord = md5('stockpro');
  846.                     $user->setPassword($passWord);
  847.                     $user->setCPassword($passWord);
  848.                     $user->setPrenoms('Gautier');
  849.                     $user->setProfil($maintenance);
  850.                     $user->setSexe(TypeSexe::MASCULIN);
  851.                     $user->setTel1('99220453');
  852.                     $user->setTel2('');
  853.                     $user->setUsername('stockpro');
  854.                     $em->persist($user);
  855.                 }
  857.                 $res =  $em->getRepository($this->userBundle . 'Profil')->findOneBy(array('nom'=>'ABONNE'));
  858.                 //var_dump($res);
  859.                 if (!($res instanceof Abonne)){
  860.                     $abonne = new Profil();
  861.                     $abonne->setCode('ABONNE');
  862.                     $abonne->setDescription('Profil Abonné');
  863.                     $abonne->setNom('ABONNE');
  864.                     $abonne->setTypeProfil(TypeProfil::PROFIL_ABONNE);
  865.                     $this->em->persist($abonne);
  866.                 }
  868.                 $this->em->flush();
  869.             });
  870.     }
  871.     
  872.     public function getDataTableauDeBord($idUser, $isAbonne, $typeTb) {
  873.         
  874.         /*if ($typeTb == 3) {
  875.             try {        
  876.                 $sqlrech = " SELECT cle,valeur::integer "
  877.                 //." json_build_object('name',replace(replace(replace(replace(cle,' ',''),chr(10),''),'>',''),'<',''),'y',valeur ) as ligne "
  878.                           ." FROM     statistik "
  879.             ." WHERE     type_stat =0  ";
  880.             
  881.             ($isAbonne != 0)? $sqlrech .= " and id_user = :id_quest " : $sqlrech = $sqlrech;
  882.             
  883.             $sqlrech .=" and idfile = (select max(idfile) from fichier where 1 = 1  and type_file = 0 ";
  884.             
  885.             ($isAbonne != 0)? $sqlrech .= " and id_user = :id_quest " : $sqlrech = $sqlrech;
  886.             $sqlrech .=" )";
  887.                 $stmt = $this->em->getConnection()->prepare($sqlrech);
  888.                 ($isAbonne != 0)? $stmt->bindValue(':id_quest', $idUser, PDO::PARAM_INT) : $p = 1;
  889.                 $stmt->execute();
  890.                 $res = $stmt->fetchAll(PDO::FETCH_ASSOC);
  891.                 $stmt =  null;
  892.             } catch (\Symfony\Component\Form\Exception\Exception $e) {
  893.                 $stmt = null;
  894.                 var_dump($e->getMessage()) ;                
  895.             } 
  896.         }elseif ($typeTb == 4) {
  897.             try {        
  898.                 $sqlrech =  'with don as( '
  899.                .'    SELECT EXTRACT(YEAR FROM CURRENT_DATE) as an, EXTRACT(MONTH FROM CURRENT_DATE) as mois '
  900.                .'    union '
  901.                .'    SELECT EXTRACT(YEAR FROM CURRENT_DATE - INTERVAL \'1 month\') as an, EXTRACT(MONTH FROM CURRENT_DATE - INTERVAL \'1 month\') as mois '
  902.                .' ) '
  903.             .' SELECT      don.an , don.mois, count(*) as nbre '
  904.             .' FROM      connexion m INNER JOIN don on EXTRACT(MONTH FROM date_connexion) = don.mois AND EXTRACT(MONTH FROM date_connexion) = don.mois '
  905.             .' WHERE    (tab_id_actions <> \'\') and (regexp_replace(tab_id_actions,\'[,0 ]{1,200}\',\'\', \'g\')<>\'[]\') and abonne_id = :id_quest '
  906.             .' GROUP BY  don.an, don.mois;';
  907.                 $stmt = $this->em->getConnection()->prepare($sqlrech);
  908.                 $stmt->bindValue(':id_quest', $idUser, PDO::PARAM_INT);
  909.                 $stmt->execute();
  910.                 $res = $stmt->fetchAll(PDO::FETCH_ASSOC);
  911.                 $stmt =  null;
  912.             } catch (\Symfony\Component\Form\Exception\Exception $e) {
  913.                 $stmt = null;
  914.                 var_dump($e->getMessage()) ;                
  915.             } 
  916.         }elseif ( in_array($typeTb,array(5,7,6))) {
  917.             
  918.             if ($typeTb == 5) $etatfile = 1;
  919.                 
  920.             if ($typeTb == 6) $etatfile = 2;
  921.                     
  922.            try {        
  923.                 $sqlrech =  'with don as( '
  924.             .'    SELECT EXTRACT(YEAR FROM CURRENT_DATE) as an, EXTRACT(MONTH FROM CURRENT_DATE) as mois '
  925.             .'    union '
  926.             .'    SELECT EXTRACT(YEAR FROM CURRENT_DATE - INTERVAL \'1 month\') as an, EXTRACT(MONTH FROM CURRENT_DATE - INTERVAL \'1 month\') as mois '
  927.             .') '
  928.             .' SELECT   don.an,don.mois,count(*) as nbre'
  929.             .' FROM     fichier m INNER JOIN don on EXTRACT(MONTH FROM add_date ) = don.mois AND EXTRACT(MONTH FROM add_date ) = don.mois '
  930.             .' WHERE    1 = 1 ';
  931.                         ($typeTb != 7)? $sqlrech .=' AND m.etat_file = :etat_file ' :$sqlrech .=' ';
  932.                         $sqlrech .=' AND userid = :id_quest and type_file = 0 '
  933.             .' GROUP BY  don.an , don.mois  '
  934.             .' ORDER BY don.an DESC, don.mois DESC ';    ;
  935.                 $stmt = $this->em->getConnection()->prepare($sqlrech);
  936.                 $stmt->bindValue(':id_quest', $idUser, PDO::PARAM_INT);
  937.                 ($typeTb != 7)?
  938.                 $stmt->bindValue(':etat_file', $etatfile, PDO::PARAM_INT) : 1;
  939.                 $stmt->execute();
  940.                 $res = $stmt->fetchAll(PDO::FETCH_ASSOC);
  941.                 $stmt =  null;
  942.             } catch (\Symfony\Component\Form\Exception\Exception $e) {
  943.                 $stmt = null;
  944.                 var_dump($e->getMessage()) ;                
  945.             } 
  946.         }else {
  947.             try {        
  948.                 $sqlrech = ' SELECT tableau_de_bord( :id_quest , :is_abonne , :type_tb);';
  949.                 $stmt = $this->em->getConnection()->prepare($sqlrech);
  950.                 $stmt->bindValue(':id_quest', $idUser, PDO::PARAM_INT);
  951.                 $stmt->bindValue(':is_abonne', $isAbonne, PDO::PARAM_INT);
  952.                 $stmt->bindValue(':type_tb', $typeTb, PDO::PARAM_INT);
  953.                 $stmt->execute();
  954.                 $res = $stmt->fetchAll(PDO::FETCH_ASSOC);
  955.             } catch (\Symfony\Component\Form\Exception\Exception $e) {
  956.                 $stmt = null;
  957.                 var_dump($e->getMessage()) ;
  958.             } 
  959.         }*/
  960.         
  961.         return $res=null;
  962.     }  
  963.     
  964.     public function getUpdateFile($file) {
  965.     
  966.         /*try {        
  967.             $sqlrech = ' SELECT update_file(:file);';
  968.             $stmt = $this->em->getConnection()->prepare($sqlrech);
  969.             $stmt->bindValue(':file', $file, PDO::PARAM_STR);
  970.             $stmt->execute();
  971.             $res = $stmt->fetchAll(PDO::FETCH_ASSOC);
  972.         } catch (\Symfony\Component\Form\Exception\Exception $e) {
  973.             $stmt = null;
  974.             var_dump($e->getMessage()) ;
  975.         } */
  976.         
  977.         return $res=null;
  978.     }      
  980.     public function getListFiles($idUser,$idFile = 0) {
  981.     
  982.         /*try {        
  983.             $sqlrech = ' SELECT * from list_files_view where userid =:user ';
  984.                         ($idFile!=0)? $sqlrech .= ' and idfile =:file' : $res = null;
  985.             $stmt = $this->em->getConnection()->prepare($sqlrech);
  986.             $stmt->bindValue(':user', $idUser, PDO::PARAM_INT);
  987.                         ($idFile!=0)? $stmt->bindValue(':file', $idFile, PDO::PARAM_INT) : $res = null;
  988.             $stmt->execute();
  989.             $res = $stmt->fetchAll(PDO::FETCH_ASSOC);
  990.         } catch (\Symfony\Component\Form\Exception\Exception $e) {
  991.             $stmt = null;
  992.             var_dump($e->getMessage()) ;
  993.         } */
  994.         //var_dump($res);
  995.         return $res=null;
  996.     }      
  997.     
  998.     public function getData($i_table,$idFile) {
  999.         /*$sqlrech = ''; $res = null;
  1000.         try {        
  1001.             
  1002.             if ($i_table == 6){
  1003.                 $sqlrech =      ' SELECT *  '
  1004.                             .' FROM mds6 m6  '
  1005.                             .' WHERE m6.id_file = :file '
  1006.                             .' LIMIT 25 OFFSET 0; ';
  1007.             }elseif ($i_table == 0){
  1008.                 $sqlrech =      " SELECT upper('mds1') as lib, count(*) as nbre  "
  1009.                             ." FROM mds1 m1  "
  1010.                             ." WHERE m1.id_file = :file "
  1011.                             ." UNION ALL "                            
  1012.                             ." SELECT upper('mds3') as lib, count(*) as nbre  "
  1013.                             ." FROM mds3 m3  "
  1014.                             ." WHERE m3.id_file = :file "
  1015.                             ." UNION ALL "                            
  1016.                             ." SELECT upper('mds4') as lib, count(*) as nbre  "
  1017.                             ." FROM mds4 m4 "
  1018.                             ." WHERE m4.id_file = :file "                            
  1019.                             ." UNION ALL "                            
  1020.                             ." SELECT upper('mds5') as lib, count(*) as nbre  "
  1021.                             ." FROM mds5 m5  "
  1022.                             ." WHERE m5.id_file = :file "
  1023.                             ." UNION ALL "                            
  1024.                             ." SELECT upper('mds6') as lib, count(*) as nbre  "
  1025.                             ." FROM mds6 m6  "
  1026.                             ." WHERE m6.id_file = :file "
  1027.                             ." UNION ALL "
  1028.                             ." SELECT upper('mds7') as lib, count(*) as nbre  "
  1029.                             ." FROM mds7 m7  "
  1030.                             ." WHERE m7.id_file = :file "
  1031.                             ." UNION ALL "                            
  1032.                             ." SELECT upper('z') as lib, count(*) as nbre  "
  1033.                             ." FROM z  "
  1034.                             ." WHERE id_file = :file ";
  1035.             }elseif ($i_table == 7){
  1036.                 $sqlrech =      " SELECT *  "
  1037.                             ." FROM mds7 m7  "
  1038.                             ." WHERE m7.id_file = :file ";
  1039.             }elseif($i_table>0 && $i_table<6){
  1040.                 $sqlrech =      ' SELECT *  '
  1041.                             .' FROM mds1 m1  '
  1042.                             .' INNER join mds3 m3 on m1.id_file = m3.id_file '
  1043.                             .' INNER join mds4 m4 on m1.id_file = m4.id_file '
  1044.                             .' INNER join mds5 m5 on m1.id_file = m5.id_file '
  1045.                             .' WHERE m5.id_file = :file '                            
  1046.                             .' LIMIT 60 OFFSET 0; ';
  1047.             }
  1048.             
  1049.             if ( trim($sqlrech)  != ''){
  1050.                 $stmt = $this->em->getConnection()->prepare($sqlrech);
  1051.                 $stmt->bindValue(':file', $idFile, PDO::PARAM_INT);
  1052.                 $stmt->execute();
  1053.                 $res = $stmt->fetchAll(PDO::FETCH_ASSOC);
  1054.             }
  1055.             
  1056.         } catch (\Symfony\Component\Form\Exception\Exception $e) {
  1057.             $stmt = null;
  1058.             var_dump($e->getMessage()) ;
  1059.         } */
  1060.         
  1061.         return $res=null;
  1062.     } 
  1064.     public function getStatusFiles($path_inbox,$path_guce,$process_id) {
  1065.     
  1066.         /*try {        
  1067.                 $sqlrech = ' SELECT check_file(:path_inbox,:path_guce,:process_id)';
  1068.                 $stmt = $this->em->getConnection()->prepare($sqlrech);
  1069.                 $stmt->bindValue(':path_inbox', $path_inbox, PDO::PARAM_STR);
  1070.                 $stmt->bindValue(':path_guce', $path_guce, PDO::PARAM_STR); 
  1071.                 $stmt->bindValue(':process_id', $process_id, PDO::PARAM_INT); 
  1072.                 $stmt->execute();
  1073.                 $res = $stmt->fetchAll(PDO::FETCH_ASSOC);
  1074.         } catch (\Symfony\Component\Form\Exception\Exception $e) {
  1075.                 $stmt = null;
  1076.                 var_dump($e->getMessage()) ;
  1077.         } */
  1078.         //var_dump($res);
  1079.         return $res=null;
  1080.     }      
  1081.     public function getProcessFiles($process_id) {
  1082.     
  1083.         /*try {        
  1084.                 $sqlrech = ' SELECT *  from  fichier where type_charge = :type_charge';
  1085.                 $stmt = $this->em->getConnection()->prepare($sqlrech);
  1086.                 $stmt->bindValue(':type_charge', $process_id, PDO::PARAM_INT);
  1087.                 $stmt->execute();
  1088.                 $res = $stmt->fetchAll(PDO::FETCH_ASSOC);
  1089.         } catch (\Symfony\Component\Form\Exception\Exception $e) {
  1090.                 $stmt = null;
  1091.                 var_dump($e->getMessage()) ;
  1092.         } */
  1093.         return $res=null;
  1094.     }
  1095.     
  1096. }