src/Controller/MaillingController.php line 363

Open in your IDE?
  1. <?php
  2. /**
  3.  * Created by PhpStorm.
  4.  * User: anthony
  5.  * Date: 25/05/18
  6.  * Time: 10:45
  7.  */
  9. namespace App\Controller;
  12. use App\Entity\Actualite;
  13. use App\Entity\Auth\AuthUser;
  14. use App\Entity\Client;
  15. use App\Entity\ClientRoleUser;
  16. use App\Entity\Coupure;
  17. use App\Entity\Email\AdresseMailVerif;
  18. use App\Entity\Email\EmailRetour;
  19. use App\Entity\Mailling;
  20. use App\Entity\PieceJointeMailling;
  21. use App\Entity\ThemeDescriptif;
  22. use App\Ovh\OvhSend;
  23. use App\Service\Coupure\GenerateCoupureInterface;
  24. use App\Service\MaillingEnCour\MaillingEnCour;
  25. use Doctrine\ORM\EntityManagerInterface;
  26. use Sensio\Bundle\FrameworkExtraBundle\Configuration\Route;
  27. use Spipu\Html2Pdf\Html2Pdf;
  28. use Symfony\Bundle\FrameworkBundle\Controller\Controller;
  29. use Symfony\Component\HttpFoundation\JsonResponse;
  30. use Symfony\Component\HttpFoundation\Request;
  31. use Symfony\Component\HttpFoundation\Response;
  32. use Symfony\Component\HttpKernel\KernelInterface;
  33. use Symfony\Component\Serializer\Mapping\Factory\ClassMetadataFactory;
  34. use Symfony\Component\Serializer\Mapping\Loader\AnnotationLoader;
  35. use Symfony\Component\Serializer\Normalizer\DateTimeNormalizer;
  36. use Symfony\Component\Serializer\Normalizer\PropertyNormalizer;
  37. use Symfony\Component\Serializer\Serializer;
  38. use Symfony\Component\Serializer\Encoder\XmlEncoder;
  39. use Symfony\Component\Serializer\Encoder\JsonEncoder;
  40. use Doctrine\Common\Annotations\AnnotationReader;
  41. use PDO;
  43. class MaillingController extends Controller
  44. {
  48.     /**
  49.      * @Route("api/maillings/maillings/getErreur/{idMailling}", methods={"GET"}, name="get.erreur.mailling.en.cours")
  50.      */
  51.     public function getErreurMaillingEnCourAction($idMailling, EntityManagerInterface $em, MaillingEnCour $maillingEnCour){
  52.         $maillingEnCoursErreur = $maillingEnCour->getMaillingErreur($idMailling);
  53.         $encoders = array(new XmlEncoder(), new JsonEncoder());
  54.         $classMetadataFactory = new ClassMetadataFactory(new AnnotationLoader(new AnnotationReader()));
  55.         $normalizer = new PropertyNormalizer($classMetadataFactory);
  56.         $dateTimeNormalizer = new DateTimeNormalizer('d-m-y H:i');
  57.         $serializer = new Serializer([$normalizer,$dateTimeNormalizer], $encoders);
  58.         $jsonContent = $serializer->normalize($maillingEnCoursErreur, null, array('groups' => array('email_retour')));
  59.         $response = new JsonResponse($jsonContent);
  60.         $response->headers->set('Content-Type', 'application/json');
  61.         return $response;
  62.     }
  64.     /**
  65.      * @Route("/maillings/content/{id}",methods={"GET"},name="get.mailling.content")
  66.      */
  67.     public function getMaillingContentAction($id, Request $request, KernelInterface $kernel)
  68.     {
  69.         $em = $this->get('doctrine.orm.entity_manager');
  70.         $mailling = $em->getRepository('App\Entity\Mailling')
  71.             ->find($request->get('id'));
  72.         $path = $kernel->getRootDir() . '/../public/maillings/' . $mailling->getAncienId() . '.html';
  73.         $read = file_get_contents($path);
  74.         return new JsonResponse(utf8_encode($read));
  75.     }
  77.     /**
  78.      * @Route("/maillings/getNbEnvoyer/{id}",methods={"GET"},name="get.mailling.nb.envoyer")
  79.      */
  80.     public function getMaillingNbEnvoyer($id)
  81.     {
  82.         $em = $this->get('doctrine.orm.entity_manager');
  83.         $mailling = $em->getRepository('App\Entity\Mailling')
  84.             ->findOneBy(['ancienId' => $id]);
  85.         return new JsonResponse($mailling->getNbMailEnvoye());
  86.     }
  88.     /**
  89.      * @Route("/maillings/checkDelete",methods={"GET"},name="mail.check")
  90.      */
  91.     public function getCheckMailAction()
  92.     {
  93.         $em = $this->get('doctrine.orm.entity_manager');
  94.         $maillings = $em->getRepository("App\Entity\Mailling")
  95.             ->findBy(['envoyer' => 0 , 'enCour' => 0 ]);
  96.         $checkIfMaillingExist = $this->get('check.mailling.exist');
  97.         $anomalieGestion = $this->get('gestion.anomalie');
  98.         foreach ($maillings as $mailling){
  99.             if($checkIfMaillingExist->checKMailling($mailling) < 1){
  100.                 $suivitOuvertures = $em->getRepository('App:SuivitOuvertureMailling')
  101.                     ->findBy(['mailling' => $mailling]);
  102.                 if(count($suivitOuvertures) < 1){
  103.                     $em->remove($mailling);
  104.                 }
  105.                 else{
  106.                     $anomalieGestion->addAnomalieDeleteWithSuivit($mailling);
  107.                 }
  108.             }
  109.         }
  110.         $em->flush();
  111.         return new Response('ok');
  112.     }
  116.     /**
  117.      * @Route("/maillings/send/test/{idMailling}/{idAuthUser}",methods={"GET"},name="send.mailling.test")
  118.      */
  119.     public function getSendMailTestAction($idMailling, $idAuthUser, MaillingEnCour $maillingEnCour, KernelInterface $kernel)
  120.     {
  121.         $em = $this->get('doctrine.orm.entity_manager');
  122.         $mailling = $em->getRepository("App\Entity\Mailling")
  123.             ->find($idMailling);
  124.         $authUser = $em->getRepository("App\Entity\Auth\AuthUser")
  125.             ->find($idAuthUser);
  126.         if($authUser){
  127.             if($mailling){
  128.                 /** @var Mailling $mailling
  129.                  *  @var AuthUser $authUser
  130.                  */
  131.                 if (strpos($mailling->getEnvoyePar()->getAdresseEnvoi(), '@escalconsulting.com') !== false) {
  132.                     $maillingEnCour->addTestSend($mailling,$authUser);
  133.                     return new JsonResponse('mail test lancé en envoi');
  134.                 } else {
  135.                     return new JsonResponse('l\'utilisateur ne possède pas d\'addresse d\'envoi');
  136.                 }
  137.             } else {
  138.                 return new JsonResponse('le mailling n\'existe pas');
  139.             }
  140.         } else {
  141.             return new JsonResponse('l\'utilisateur n\'existe pas');
  142.         }
  143.     }
  147.     /**
  148.      * @Route("/maillings/send/veille/{id}", methods={"GET"}, name="mailling.veille.send")
  149.      */
  150.     public function sendVeilleAction(MaillingEnCour $maillingEnCour, EntityManagerInterface $em, $id){
  151.         $veille = $em->getRepository('App:Veille')->find($id);
  152.         if($veille){
  153.             $match_date = $veille->getDate();
  154.             $date = new \DateTime();
  155.             $interval = $date->diff($match_date);
  156.             if($interval->days == 0) {
  157.                 if(!$veille->getValider()){
  158.                     $veille->setValider(true);
  159.                     $em->persist($veille);
  160.                     $em->flush();
  161.                     $maillingEnCour->addVeilleSend($veille);
  162.                     return new JsonResponse('veille lancer en envoi');
  163.                 }
  164.             }
  165.         }
  166.        return new JsonResponse('veille déja envoyé');
  167.     }
  170.     /**
  171.      * @Route("/maillings/send/date/{idMailling}",methods={"GET"},name="send.mail.date")
  172.      */
  173.     public function getSendMaillingDateAction($idMailling , MaillingEnCour $maillingEnCour, Request $request)
  174.     {
  175.         ini_set('memory_limit',-1);
  176.         set_time_limit(0);
  177.         $dateEnvoie = $request->query->get('date');
  178.         $dateEnvoie = new \DateTime($dateEnvoie);
  179.         $em = $this->get('doctrine.orm.entity_manager');
  180.         $mailling = $em->getRepository("App\Entity\Mailling")
  181.             ->find($idMailling);
  182.         if($mailling){
  183.             if($mailling->getValiderEnvoi()){
  184.                 if(!$mailling->getEnCour()){
  185.                     if(!$mailling->getEnvoyer()){
  186.                         if (strpos($mailling->getEnvoyePar()->getAdresseEnvoi(), '@escalconsulting.com') !== false) {
  187.                             $mailling->setEnCour(true);
  188.                             $em->persist($mailling);
  189.                             $em->flush();
  191.                             if($maillingEnCour->addMaillingSend($mailling, $dateEnvoie, true) == false){
  192.                                 return new JsonResponse('le mailling est déja en cours d\'envoi');
  193.                             }
  194.                             return new JsonResponse('le mailling a été lancé en envoi');
  195.                         } else {
  196.                             return new JsonResponse('l\'utilisateur ne possède pas d\'addresse d\'envoi');
  197.                         }
  198.                     } else {
  199.                         return new JsonResponse('le mailling est déjà en envoyé');
  200.                     }
  201.                 } else {
  202.                     return new JsonResponse('le mailling est déjà en cours d\'envoi');
  203.                 }
  204.             } else {
  205.                 return new JsonResponse('le mailling doit être validé');
  206.             }
  207.         } else {
  208.             return new JsonResponse('le mailling n\'existe pas');
  209.         }
  211.     }
  214.     /**
  215.      * @Route("/maillings/send/{idMailling}",methods={"GET"},name="send.mail.reel")
  216.      */
  217.     public function getSendMaillingAction($idMailling , MaillingEnCour $maillingEnCour, OvhSend $ovhSend, ActualiteController $actualiteController)
  218.     {
  219.         ini_set('memory_limit',-1);
  220.         set_time_limit(0);
  221.         $em = $this->get('doctrine.orm.entity_manager');
  222.         $mailling = $em->getRepository("App\Entity\Mailling")
  223.             ->find($idMailling);
  224.         /** @var Mailling $mailling */
  225.         if($mailling){
  226.             if($mailling->getValiderEnvoi()){
  227.                 if(!$mailling->getEnCour()){
  228.                     if(!$mailling->getEnvoyer()){
  229.                         if (strpos($mailling->getEnvoyePar()->getAdresseEnvoi(), '@escalconsulting.com') !== false) {
  230.                             $mailling->setEnCour(true);
  231.                             $em->persist($mailling);
  232.                             $em->flush();
  233.                             if ($mailling->getTypeMail() == 'CP') {
  234.                                 $this->creerActualiteMailing($idMailling, $em, $ovhSend, $actualiteController);
  235.                             }
  236.                             if($maillingEnCour->addMaillingSend($mailling, new \DateTime('now')) == false){
  237.                                 return new JsonResponse('le mailling est déja en cours d\'envoi');
  238.                             }
  239.                             return new JsonResponse('le mailling a été lancé en envoi');
  240.                         } else {
  241.                             return new JsonResponse('l\'utilisateur ne possède pas d\'addresse d\'envoi');
  242.                         }
  243.                     } else {
  244.                         return new JsonResponse('le mailling est déjà en envoyé');
  245.                     }
  246.                 } else {
  247.                     return new JsonResponse('le mailling est déjà en cours d\'envoi');
  248.                 }
  249.             } else {
  250.                 return new JsonResponse('le mailling doit être validé');
  251.             }
  252.         } else {
  253.             return new JsonResponse('le mailling n\'existe pas');
  254.         }
  256.     }
  258.     /**
  259.      * @Route("/maillings/creer/actualite/suite/envoie/{idMailling}", methods={"GET"}, name="creer_actu_mailing")
  260.      */
  261.     public function creerActualiteMailing($idMailling, EntityManagerInterface $em, OvhSend $ovhSend, ActualiteController $actualiteController){
  262.         $mailling = $em->getRepository('App:Mailling')->find($idMailling);
  263.         $actualite = new Actualite();
  264.         $nomMailling = str_replace('&#039;', '\'', $mailling->getNom());
  265.         $actualite->setNom($nomMailling);
  266.         $actualite->setClient($mailling->getClient());
  267.         $actualite->setPitch($mailling->getResumer());
  268.         $actualite->setCreation(new \DateTime('now'));
  269.         $actualite->setAuteur($mailling->getEnvoyePar());
  270.         $em->persist($actualite);
  271.         $em->flush();
  272.         $actualite = $em->getRepository('App:Actualite')->findDerniereActu();
  273.         $theme = new ThemeDescriptif();
  274.         $theme->setLibelle($mailling->getResumerCour());
  275.         $theme->setActualite($actualite);
  276.         $em->persist($theme);
  277.         $em->flush();
  278.         $actualiteController->parutionImporterCopie($actualite->getId(), 0, $em);
  279.         try
  280.         {
  281.             $bdd = new PDO('mysql:host=185.126.230.125;dbname=escal_web;charset=utf8', 'escalprod', 'skl001');
  282.         }
  283.         catch (Exception $e)
  284.         {
  285.             die('Erreur : ' . $e->getMessage());
  286.         }
  287.         $query = 'SELECT MAX(`ID_actualite`) as actuId FROM `ecw_actualites`';
  288.         $reponse = $bdd->query($query);
  289.         while ($row = $reponse->fetch()) {
  290.             $actuAncienId = $row['actuId'];
  291.         }
  292.         $reponse->closeCursor();
  293.         $actualite->setAncienId($actuAncienId);
  294.         $em->flush();
  295.         $ovhSend->sendMailNouvelleActualite($actualite);
  296.         return new JsonResponse('ok');
  297.     }
  299.     /**
  300.      * @Route("/mailling/enCour/{idMailling}", methods={"GET"}, name="mailling.en.cour.status")
  301.      */
  302.     public function getMaillingInfoEnCourAction($idMailling, EntityManagerInterface $em, MaillingEnCour $maillingEnCour){
  303.         $mailling = $em->getRepository('App:Mailling')->find($idMailling);
  304.         $retour = [];
  305.         if($mailling){
  306.             $debutMailling = $maillingEnCour->getIfMaillingBegin($mailling);
  307.             if($debutMailling !== false){
  308.                 $nbMailling = $maillingEnCour->getNbMailMailling($mailling);
  309.                 $nbMaillingAttente = $maillingEnCour->getNbMailRestantAvantFin($mailling);
  310.                 if($nbMaillingAttente != false){
  311.                     $dateFurtureEnvoie = $maillingEnCour->getHeureEnvoieFuture($mailling);
  312.                     if( $dateFurtureEnvoie == false){
  313.                         $retour['nbMaillAttente'] = $nbMaillingAttente;
  314.                         $retour['nbMailToSend'] = $nbMailling[0];
  315.                         $retour['nbMailSend'] = $nbMailling[1];
  316.                     } else {
  317.                         $retour['message_erreur'] = 'le mailling commencera a être envoyé le ' . $dateFurtureEnvoie;
  318.                     }
  319.                 } else {
  320.                     if($mailling->getEnvoyer() == true){
  321.                         $retour['message_erreur'] = 'le mailling a fini d\'être envoyé';
  322.                     }
  323.                     $retour['message_erreur'] = 'Le mailling est en cours d\'envoi, l\'affichage du diagramme peut prendre plusieurs minutes. Merci de patienter.';
  324.                 }
  326.             } else {
  327.                 $retour['message_erreur'] = 'le mailling n\'est pas en envoi';
  328.             }
  329.         } else {
  330.             $retour['message_erreur'] = 'le mailling n\'existe pas';
  331.         }
  332.         return new JsonResponse($retour);
  333.     }
  335.     /**
  336.      * @Route("/maillings/deleteMailling/{idMailling}", methods={"DELETE"}, name="delete.mailling")
  337.      */
  338.     public function deleteMailling($idMailling, EntityManagerInterface $em){
  339.         $mailling = $em->getRepository('App:Mailling')->find($idMailling);
  340.         if($mailling->getEnCour() === false){
  341.             $maillingsEnCour = $em->getRepository('App:MaillingEnCour')->findBy(['mailling' => $mailling]);
  342.             foreach ($maillingsEnCour as $maillingEnCour){
  343.                 $em->remove($maillingEnCour);
  344.             }
  345.             $em->remove($mailling);
  346.             $em->flush();
  347.             $retour['message'] = 'le mailling a été supprimmer';
  348.         } else {
  349.             $retour['message'] = 'le mailling a déja été lancé en envoi';
  350.         }
  351.         return new JsonResponse($retour);
  352.     }
  354.     /**
  355.      * @Route("/maillings/prepareCoupure/{idClient}", methods={"GET"}, name="mailling.cree.coupure")
  356.      */
  357.     public function creeMaillingCoupure($idClient, EntityManagerInterface $em, GenerateCoupureInterface $generateCoupure){
  358.         $client = $em->getRepository('App:Client')->find($idClient);
  359.         if($client){
  360.             /** @var Client $client */
  361.             $mailling = $em->getRepository('App:Mailling')->findOneBy(['client' => $client, 'typeMail' => 'Coupure', 'envoyer' => false]);
  362.             /** @var Mailling $mailling */
  363.             if($mailling){
  364.                 foreach ($mailling->getPiecesJointes() as $piecesJointe){
  365.                     $mailling->removePiecesJointe($piecesJointe);
  366.                     $em->remove($piecesJointe);
  367.                 }
  368.                 $em->flush();
  369.             } else{
  370.                 $mailling = new Mailling();
  371.                 $mailling->setClient($client);
  372.                 $date = new \DateTime('now');
  373.                 $mailling->setNom('Retombées presse '. $client->getNom(). ' du '.date_format($date, 'd/m/Y'));
  374.                 $mailling->setObjet('Retombées presse '. $client->getNom(). ' du '.date_format($date, 'd/m/Y'));
  375.                 foreach ($client->getRolesUserClient() as $roleUserClient){
  376.                     /** @var ClientRoleUser $roleUserClient */
  377.                     if($roleUserClient->getRole() == 'Bo'){
  378.                         $mailling->setEnvoyePar($roleUserClient->getAuthUser());
  379.                         $mailling->setReplyTo($roleUserClient->getAuthUser());
  380.                     }
  381.                 }
  382.                 $mailling->setTypeMail('Coupure');
  383.             }
  384.             $coupuresClient = $em->getRepository('App:Coupure')->findBy(['client' => $client, 'envoyer' => false]);
  385.             foreach ($coupuresClient as $coupure){
  386.                 /** @var Coupure $coupure */
  387.                 $pieceJointeMailling = new PieceJointeMailling();
  388.                 $pieceJointeMailling->setUrl($coupure->getPiecesJointe());
  389.                 $pieceJointeMailling->setCoupure($coupure);
  390.                 $pieceJointeMailling->setMailling($mailling);
  391.                 $mailling->addPiecesJointe($pieceJointeMailling);
  392.             }
  393.             $mailling->setValiderEnvoi(0);
  394.             $mailling->setEnCour(0);
  395.             $mailling->setEnvoyer(0);
  396.             $mailling->setNbMail(0);
  397.             $mailling->setNbMailEnvoye(0);
  398.             $mailling->setDebutMailCoupure($generateCoupure->generateDebutMail($mailling));
  399.             $mailling->setFinMailCoupure($generateCoupure->generateFinMail($mailling));
  400.             $mailling->sethyperlien(1);
  401.             $em->persist($mailling);
  402.             $em->flush();
  403.         } else {
  404.             $retour['message_erreur'] = 'le client n\'existe pas';
  405.         }
  406.         return new JsonResponse(['idMailling' => $mailling->getId()]);
  407.     }
  409.     /**
  410.      * @Route("/maillings/information/{idMailling}", methods={"GET"}, name="nb.mail.envoyer")
  411.      */
  412.     public function getNombreMailEnvoyer($idMailling, EntityManagerInterface $em){
  413.         $mailling = $em->getRepository('App:Mailling')->findBy(['ancienId' => $idMailling]);
  414.         if(!isset($mailling[0])){
  415.             return new JsonResponse(0);
  416.         }
  417.         $mailling = $mailling[0];
  418.         return new JsonResponse($mailling->getNbMailEnvoye());
  419.     }
  421.     /**
  422.      * @Route("/maillings/refreshNbMail/{idMailling}", methods={"GET"}, name="nb.mail.envoyer.refresh")
  423.      */
  424.     public function getRefreshNombreMail(OvhSend $ovhSend, $idMailling, EntityManagerInterface $em){
  425.         $mailling = $em->getRepository('App:Mailling')->find($idMailling);
  426.         /** @var Mailling $mailling */
  427.         $contactsSend = $ovhSend->getContactSend($mailling);
  428.         $nbMail = 0;
  429.         foreach ($contactsSend as $contactSend) {
  430.             $userInfo = explode('#', $contactSend);
  431.             $userMail = trim($userInfo[0]);
  432.             $blackList = $em->getRepository('App:BlackList')
  433.                 ->findOneBy(['email'=> $userMail]);
  434.             if(!$blackList) {
  435.                 $nbMail = $nbMail + 1;
  436.             }
  437.         }
  438.         if($mailling->getNbMail() != $nbMail){
  439.            $mailling->setNbMail($nbMail);
  440.         }
  441.         $em->persist($mailling);
  442.         $em->flush();
  444.         return new JsonResponse($mailling->getNbMail());
  445.     }
  448.     /**
  449.      * @Route("/mailing/contactsenvoireel/{idMailling}", methods={"GET"}, name="mailing.contact.Envoi.reel")
  450.      */
  451.     public function getContactsEnvoiReel($idMailling, EntityManagerInterface $em) {
  452.         $mailing = $em->getRepository('App:Mailling')->findOneBy(["ancienId" => $idMailling]);
  453.         $mailingsEnCours = $em->getRepository('App:MaillingEnCour')->findBy(["mailling" => $mailing->getId()]);
  454.         $contactsIDIntranet = [];
  455.         foreach ($mailingsEnCours as $mailingEncours) {
  456.             if(!is_null($mailingEncours->getUserId()))
  457.                 $contactsIDIntranet[] = $mailingEncours->getUserId();
  458.         }
  459.         return new JsonResponse($contactsIDIntranet);
  460.     }
  462.     /**
  463.      * @Route("/mailing/get/contacts/safe/{idMailling}", methods={"GET"}, name="mailing_contact_safe_envoi")
  464.      */
  465.     public function getContactsSafeEnvoi($idMailling, EntityManagerInterface $em, OvhSend $ovhSend) {
  466.         $contactsSafe = '';
  467.         // liste contacts hors blacklist et email retour
  468.         $mailing = $em->getRepository('App:Mailling')->findOneBy(["ancienId" => $idMailling]);
  469.         $contactsSend = $ovhSend->getContactSend($mailing);
  470.         foreach ($contactsSend as $contactSend) {
  471.             $contactInfo = explode('#', $contactSend);
  472.             $contactMail = trim($contactInfo[0]);
  473.             $contactID = trim($contactInfo[1]);
  474.             $adresseEmailVerif = $em->getRepository('App:Email\AdresseMailVerif')->findOneBy(['email' => $contactMail]);
  475.             $emailsRetours = $em->getRepository('App:Email\EmailRetour')->findBy(['email' => $contactMail]);
  476.             // Prendre en compte la dernière raison
  477.             $emailRetour = end($emailsRetours);
  478.             $safeToSend = 0;
  479.             //Si l'adresse mail a deja ete verifie  : recuperer le statut de l'adresse mail verifiee
  480.             if ($adresseEmailVerif){
  481.                 // Gestion de cas des adresses mails de type "Accept All"
  482.                 if(!$emailRetour && $adresseEmailVerif->getSafeToSend()==1){
  483.                     $safeToSend = 1;
  484.                 }
  485.             }
  486.             $blackList = $em->getRepository('App:BlackList')->findOneBy(['email' => $contactMail]);
  487.             if (!$blackList || $blackList->getAutorise() == 1) {
  488.                 $dateDuJour = new \DateTime('now');
  489.                 //La dateAbsence correspond à la date de retour
  490.                 if($emailRetour && $emailRetour->getDateAbsence()>$dateDuJour) {
  491.                     $safeToSend = 0;
  492.                 }
  493.                 // Ne pas bloquer l'envoi à l'adresse mail classée 'autre' par les BO
  494.                 if($emailRetour && $emailRetour->getRaison() == 'autre') {
  495.                     $safeToSend = 1;
  496.                 }
  497.                 if($safeToSend == 1) {
  498.                     $contactsSafe = $contactsSafe . '"'.$contactMail.'", ';
  499.                 }
  500.             }
  501.         }
  502.         return new JsonResponse($contactsSafe);
  503.     }
  504. }