src/Services/user/LoginManager.php line 189

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