src/Controller/Buzz/RedirectNewsController.php line 171

Open in your IDE?
  1. <?php
  3. /**
  4.  * @author Mehrez Labidi
  5.  */
  6. declare(strict_types=1);
  8. namespace App\Controller\Buzz;
  10. use App\Services\{
  11.     RobotProvider,
  12.     Mailer
  13. };
  14. use App\Services\Buzz\BuzzNewsletter;
  15. use App\Services\Annonces\ConsultationsAnnonce;
  16. use Doctrine\ORM\EntityManagerInterface;
  17. use App\Entity\{
  18.     Utilisateur,
  19.     BuzzLiensNewsletter,
  20.     BuzzActualites,
  21.     ServicesPrestataire,
  22.     UtilisateursNewsletter,
  23.     StatistiquesNewsletterClics,
  24.     StatistiquesNewsletterClicsDuJour,
  25.     StatistiquesNewsletterOuvertures,
  26.     StatistiquesClicsOuvragesEfl,
  27.     BuzzNewslettersQuotidiennes,
  28.     StatistiquesNbConsultationsActualitesBuzz,
  29.     InteractionUtilisateur
  30. };
  31. use App\Controller\EntityUsingController;
  32. use App\Helper\Utils;
  33. use Symfony\Component\HttpFoundation\{
  34.     Cookie,
  35.     Request,
  36.     Response,
  37.     RedirectResponse
  38. };
  39.     
  40. class RedirectNewsController extends EntityUsingController {
  42.     /**
  43.      * Constructeur de la classe
  44.      * Initialise le gestionnaire d'entités
  45.      * @param EntityManagerInterface $em
  46.      */
  47.     public function __construct(EntityManagerInterface $em, Mailer $mailer, ConsultationsAnnonce $consultations_annonce) {
  48.         $this->em = $em;
  49.         $this->mailer = $mailer;
  50.         $this->consultations_annonce = $consultations_annonce;
  51.     }
  53.     /**
  54.      * Redirige vers un article Buzz
  55.      * Traite le code encodé, met à jour les statistiques
  56.      * Gère les interactions utilisateur et les cookies
  57.      * @return mixed
  58.      */
  59.     public function redirectArticleNewsBuzz($code) {
  60.         $trio = base64_decode($code);
  61.         $t = explode(',', $trio);
  62.         if (count($t) < 3) {
  63.             throw new \InvalidArgumentException('Paramètres insuffisants');
  64.         }
  65.         $idLien = (int) $t [0];
  66.         $idUtilisateur = (int) $t [1];
  67.         $dateNewsletter = $t [2];
  69.         $objetLien = $this->getLienParIdLien($idLien);
  70.         $id_pays = NULL;
  71.         if (isset($t[3])) {
  72.             if (strpos($t[3], '32') !== false) {
  73.                 $id_pays = '32';
  74.             }
  75.             if (strpos($t[3], '1') !== false) {
  76.                 $id_pays = '01';
  77.             }
  78.             if (strpos($t[3], '01') !== false) {
  79.                 $id_pays = '01';
  80.             }
  81.             if (strpos($t[3], '33') !== false) {
  82.                 $id_pays = '33';
  83.             }
  84.             if (strpos($t[3], '41') !== false) {
  85.                 $id_pays = '41';
  86.             }
  87.         }
  89.         $lien = ($objetLien) ? $objetLien->_get('lien'):NULL;
  90.         $email = $this->getEmailUtilisateurParIdUtilisateur($idUtilisateur);
  91.         $utilisateur = $this->em->getRepository(Utilisateur::class)->findOneBy(['email_utilisateur' => $email]);
  92.         if (!empty($utilisateur)) {
  93.             $idUtilisateur = $utilisateur->_get("id_utilisateur");
  94.             $interactionUtilisateur = $this->em->getRepository(InteractionUtilisateur::class)->findOneBy(array('id_utilisateur' => $idUtilisateur));
  95.             if (!$interactionUtilisateur) {
  96.                 $interactionUtilisateur = new InteractionUtilisateur();
  97.                 $interactionUtilisateur->_set("id_utilisateur", $idUtilisateur);
  98.             }
  99.             $interactionUtilisateur->_set("date_time_interaction", date("YmdHis"));
  100.             $interactionUtilisateur->_set("type_interaction", "newsletters");
  101.             $interactionUtilisateur->_set("plateform_interaction", "FUSACQ");
  102.             $this->em->persist($interactionUtilisateur);
  103.             $this->em->flush();
  104.         }
  106.         //  setcookie("id_utilisateur_ip_detecte", $idUtilisateur, time() + 60 * 60 * 24 * 365, '/');
  107.         // Créer le cookie
  108.         $cookie = Cookie::create('id_utilisateur_ip_detecte')
  109.                 ->withValue((string) $idUtilisateur)
  110.                 ->withExpires(new \DateTime('+1 year'))
  111.                 ->withPath('/')
  112.                 ->withSecure(false)  // true si HTTPS
  113.                 ->withHttpOnly(true) // Protection XSS
  114.                 ->withSameSite(Cookie::SAMESITE_LAX); // Protection CSRF
  116.         if (!empty($objetLien)) {
  117.             if ($lien != "&&&" && $lien != "") {
  118.                 $this->modifyStatistiqueClic($email, $dateNewsletter, $lien, 1,$idLien, $id_pays);
  119.             }
  120.             if (strpos($lien, 'newsletter-le-buzz-') !== false) {
  121.                 $lien = $lien . '?email=' . $email;
  122.             }
  124.             $response = $this->redirect($lien);
  125.             $response->headers->setCookie($cookie);
  126.             return $response;
  127.         } else {
  128.             //
  129.         }
  130.     }
  132.     /**
  133.      * Gère l'ouverture d'une newsletter Buzz
  134.      * Décode les paramètres, vérifie les statistiques
  135.      * Crée une nouvelle entrée si nécessaire
  136.      * @return void
  137.      */
  138.     public function ouvertureNewsBuzz($code) {
  139.         $codeDecode = base64_decode($code);
  140.         if ($codeDecode === false) {
  141.             return new Response('', Response::HTTP_BAD_REQUEST);
  142.         }
  144.         $codeEnChaine = $this->chaineFormatUriToArray($codeDecode);
  145.         $email = $codeEnChaine ["email"];
  146.         $typeNewsletter = BuzzNewsletter::TYPE_NEWS_BUZZ_QUOTI_NOM_COMPLET;
  147.         $dateNewsletter = $codeEnChaine ["date"];
  148.         $id_pays = NULL;
  149.         if (isset($codeEnChaine ["id_pays"])) {
  150.             $id_pays = $codeEnChaine ["id_pays"];
  151.         }
  152.         if (empty($email) || empty($dateNewsletter)) {
  153.             return new Response('', Response::HTTP_BAD_REQUEST);
  154.         }
  155.         $statistique = $this->getStatistiqueParEmailDate($email, $dateNewsletter);
  156.         if (count($statistique) >= 1) {
  157.             //
  158.         } else {
  159.             $this->createStatistiqueParEmailDate($email, $dateNewsletter, $id_pays);
  160.         }
  161.         // Retourner une réponse vide ou une redirection
  162.         return new Response('', Response::HTTP_NO_CONTENT);
  163.     }
  165.     /**
  166.      * Gère les clics sur les actualités
  167.      * Vérifie si c'est un robot, incrémente les statistiques
  168.      * Envoie des notifications à certains seuils
  169.      * @return void
  170.      */
  171.     public function cliquerLienActualite($idActualite) {
  172.         // fonction appeleé en render_esi dans twig 
  174.         if (!empty($idActualite)) {
  175.             $actualite = $this->em->getRepository(BuzzActualites::class)->find($idActualite);
  177.             if (!$actualite) {
  178.                 return new Response('', Response::HTTP_NOT_FOUND);
  179.             }
  181.             $isBot = false;
  182.             $isFusacqBot = false;
  183.             $isBot = $this->isRobotConnu();
  184.             $isFusacqBot = $this->testSiConnexionFromLocauxFusacq();
  185.             //  echo "isbot : " . $isBot . '|| isFusacq : ' . $isFusacqBot;
  186.             if ($isBot == false && $isFusacqBot == false && $actualite != NULL) {
  187.                 //      echo "non robot";
  188.                 $result = $this->em->getRepository(StatistiquesNbConsultationsActualitesBuzz::class)->findOneBy(array("id_actualite" => $idActualite));
  189.                 if (!empty($result)) {
  190.                     $statistiqueConsultationActu = $result;
  191.                     $nbConsultations = $statistiqueConsultationActu->_get("nb_affichages");
  192.                     $this->updateStatistiqueNbConsultationActualiteBuzz($idActualite, 1);
  193.                     $nbConsultations = (int) $nbConsultations + 1;
  194.                     if ($actualite->_get("provenance_flux_actualite") == "blog") {
  195.                         if ($nbConsultations == 100 || $nbConsultations == 500 || ($nbConsultations % 1000 == 0 && $nbConsultations <= 10000)) {
  196.                             $nbProchainConsultations = $nbConsultations + 1;
  197.                             if ($nbConsultations == 100) {
  198.                                 $nbProchainConsultations = 500;
  199.                             }
  200.                             if ($nbConsultations == 500) {
  201.                                 $nbProchainConsultations = 1000;
  202.                             }
  203.                             if ($nbConsultations % 1000 == 0) {
  204.                                 $nbProchainConsultations = (int) $nbConsultations + 1000;
  205.                             }
  207.                             $titre = $actualite->_get('titre_actualite');
  208.                             $lien = '/buzz/' . Utils::slugify($titre) . "-a" . $actualite->_get('id_actualite') . "";
  209.                             $idSocietePrestataire = $actualite->_get("id_societe_prestataire");
  210.                             $deposant = $this->em->getRepository(Utilisateur::class)->findOneBy(array("id_societe_prestataire" => $idSocietePrestataire));
  211.                             if (!empty($deposant)) {
  212.                                 $emailDestinataire = $deposant->getEmail();
  213.                                 $arrayMail = array(
  214.                                     'nbConsultations' => $nbConsultations,
  215.                                     'lien' => $lien,
  216.                                     'titre' => $titre,
  217.                                     'nbProchainConsultations' => $nbProchainConsultations,
  218.                                     'emailDestinataire' => $emailDestinataire,
  219.                                 );
  221. //                                $this->mailer->sendmail(
  222. //                                        Mailer::$senderAdress['contact'], // $from
  223. //                                        $emailDestinataire, // $to
  224. //                                        NULL, // $ccTo
  225. //                                        Mailer::$receiverAdress['mail_damien'], // $cciTo
  226. //                                        $nbConsultations . ' consultations pour votre blog "' . $titre . '"', // $subject
  227. //                                        NULL, // $replyTo
  228. //                                        NULL, // $contenu
  229. //                                        'mails/templates/notifications_consultation_blog.html.twig', // $template
  230. //                                        $arrayMail, // $varTemplate
  231. //                                        NULL // $attachement
  232. //                                );
  233.                             }
  234.                         }
  235.                     }
  236.                 } else {
  237.                     $this->insertStatistiqueNbConsultationActualiteBuzz($idActualite);
  238.                 }
  239.             } else {
  240.                 // echo "robot";
  241.             }
  242.         }
  244.         // Retourner une réponse vide ou une redirection
  245.         return new Response('', Response::HTTP_NO_CONTENT);
  246.     }
  248.     /**
  249.      * Redirige vers les ouvrages sélectionnés
  250.      * Gère les clics publicitaires EFL
  251.      * Met à jour les statistiques par provenance
  252.      * @return mixed
  253.      */
  254.     public function redirectionOuvragesSelectionnes(Request $request) { //  /enregistrement.html
  255.         $action = $request->query->get('action') ?? NULL;
  256.         $from = $request->query->get('from') ?? NULL;
  257.         $idServicePrestataire = $request->query->get('id_service_prestataire') ?? NULL;
  259.         if ($action == 'clic_pub_efl' && $from == 'from_menu_droit_buzz' && !empty($idServicePrestataire)) {
  260.             $siteRedirect = $this->getSiteParIdServicePrestataire($idServicePrestataire);
  261.             $isBot = false;
  262.             $isFusacqBot = false;
  263.             $isBot = $this->isRobotConnu();
  264.             $isFusacqBot = $this->testSiConnexionFromLocauxFusacq();
  265.             if ($isBot == false && $isFusacqBot == false) {
  266.                 if (!empty($this->getStatistiqueEFL($idServicePrestataire))) {
  267.                     $this->updateStatistiqueEFL($idServicePrestataire,  1, 'from_menu_droit_buzz');
  268.                 } else {
  269.                     $this->insererStatistiqueEFL($idServicePrestataire,  1, 'from_menu_droit_buzz');
  270.                 }
  271.             } else {
  272.                 //
  273.             }
  274.             $siteRedirect = "https://" . $siteRedirect;
  275.             return $this->redirect($siteRedirect);
  276.         } else if ($action == 'clic_pub_efl' && $from == 'from_ouvrages' && !empty($idServicePrestataire)) {
  277.             $siteRedirect = $this->getSiteParIdServicePrestataire($idServicePrestataire);
  278.             $isBot = false;
  279.             $isFusacqBot = false;
  280.             $isBot = $this->isRobotConnu();
  281.             $isFusacqBot = $this->testSiConnexionFromLocauxFusacq();
  282.             if ($isBot == false && $isFusacqBot == false) {
  283.                 if (!empty($this->getStatistiqueEFL($idServicePrestataire))) {
  284.                     $this->updateStatistiqueEFL($idServicePrestataire,  1, "from_ouvrages");
  285.                 } else {
  286.                     $this->insererStatistiqueEFL($idServicePrestataire,  1, "from_ouvrages");
  287.                 }
  288.             } else {
  289.                 //  
  290.             }
  291.             $siteRedirect = "https://" . $siteRedirect;
  292.             return $this->redirect($siteRedirect);
  293.         }
  294.     }
  296.     /**
  297.      * Affiche la newsletter quotidienne
  298.      * Récupère le contenu HTML, personnalise l'email
  299.      * Gère les images et liens de désinscription
  300.      * @return mixed
  301.      */
  302.     public function redirectionNewsletterQuotidienne(Request $request, ?int $idNewsletter = null) {
  303.         $em = $this->em;
  304.         $email = $request->query->get('email', '');
  306.         if (!empty($idNewsletter)) {
  307.             $newsletter = $this->getNewsletterQuotidienneParId($idNewsletter);
  308.         } else {
  309.             $idNewsletter = $this->getIdDerniereNewsletterQuotidienne();
  310.         }
  312.         $textHtml = $newsletter[0]->_get('contenu_html');
  313.         if ($idNewsletter <= 1728) {
  314.             $textHtml = str_replace("https://www.fusacq.com/buzz/images/logo_bleu.png", "https://content.fusacq.com/static/dev-fusacq/buzz/images/logo_bleu.png", $textHtml);
  315.         }
  316.         if (!empty($email)) {
  317.             $textHtml = str_replace('<!--###email_desinscription###-->', $email, $textHtml);
  318.         }
  320.         echo $textHtml;
  321.         return $this->response;
  322.     }
  324.     /**
  325.      * Récupère une newsletter quotidienne
  326.      * Recherche par identifiant unique
  327.      * Retourne l'objet newsletter correspondant
  328.      * @param int $idNewsletter
  329.      * @return mixed
  330.      */
  331.     private function getNewsletterQuotidienneParId($idNewsletter) {
  332.         return $this->em->getRepository(BuzzNewslettersQuotidiennes::class)->findOneBy(['idNewsletter' => $idNewsletter]);
  333.     }
  335.     /**
  336.      * Obtient l'ID dernière newsletter
  337.      * Recherche la plus récente envoyée
  338.      * Retourne l'identifiant unique
  339.      * @param EntityManagerInterface $em
  340.      * @return int
  341.      */
  342.     private function getIdDerniereNewsletterQuotidienne() {
  343.         $queryBuilder = $this->em->createQueryBuilder();
  344.         $query = $queryBuilder
  345.                 ->select(array("buzzNewslettersQuotidiennes.id_newsletter"))
  346.                 ->from(BuzzNewslettersQuotidiennes::class, 'buzzNewslettersQuotidiennes')
  347.                 ->where('buzzNewslettersQuotidiennes.mode = :modeEnvoyee')
  348.                 ->setParameter('modeEnvoyee', 'envoyee')
  349.                 ->orderBy('buzzNewslettersQuotidiennes.date_envoi', 'desc');
  350.         $resultat = $query
  351.                 ->setMaxResults(1)
  352.                 ->getQuery()
  353.                 ->getResult(\Doctrine\ORM\Query::HYDRATE_ARRAY);
  354.         return $resultat[0]['id_newsletter'];
  355.     }
  357.     /**
  358.      * Récupère statistiques EFL
  359.      * Pour un prestataire et mois donnés
  360.      * Retourne les données existantes
  361.      * @param int $idServicePrestataire
  362.      * @return mixed
  363.      */
  364.     private function getStatistiqueEFL($idServicePrestataire) {
  365.         $stats = $this->em->getRepository(StatistiquesClicsOuvragesEfl::class)->findOneBy(['id_service_prestataire' => $idServicePrestataire, 'date_mois' => date('Ym')]);
  366.         return $stats;
  367.     }
  369.   
  370.     private function insererStatistiqueEFL($idServicePrestataire,  $nb, $colFrom ) {
  371.         $stat = new StatistiquesClicsOuvragesEfl();
  372.         $stat->_set("id_service_prestataire", intval($idServicePrestataire));
  373.         $stat->_set("date_mois", date("Ym"));
  374.         if ($colFrom == 'from_ouvrages') {
  375.             $stat->_set("from_ouvrages", $nb);
  376.         } else {
  377.             $stat->_set("from_ouvrages", 0);
  378.         }
  379.         if ($colFrom == 'from_annuaire_experts') {
  380.             $stat->_set("from_annuaire_experts", $nb);
  381.         } else {
  382.             $stat->_set("from_annuaire_experts", 0);
  383.         }
  384.         if ($colFrom == 'from_autres') {
  385.             $stat->_set("from_autres", $nb);
  386.         } else {
  387.             $stat->_set("from_autres", 0);
  388.         }
  389.         if ($colFrom == 'from_menu_droit_buzz') {
  390.             $stat->_set("from_menu_droit_buzz", $nb);
  391.         } else {
  392.             $stat->_set("from_menu_droit_buzz", 0);
  393.         }
  395.         $this->em->persist($stat);
  396.         $this->em->flush();
  397.     }
  399.    
  400.     private function updateStatistiqueEFL($idServicePrestataire, $nb, $colFrom) { //  ($idServicePrestataire,   1, "from_ouvrages")
  401.         $stat = $this->em->getRepository(StatistiquesClicsOuvragesEfl::class)->findOneBy(['id_service_prestataire' => $idServicePrestataire, 'date_mois' => date('Ym')]);
  402.         if (!$stat) {
  403.             throw new \RuntimeException(
  404.                             sprintf('Aucune statistique trouvée pour le prestataire ID: %d au mois %s', $idServicePrestataire, date('Ym'))
  405.                     );
  406.         }
  408.         if ($colFrom == 'from_ouvrages') {
  409.             $n = (int) $stat->_get('from_ouvrages');
  410.             $n = $n + $nb;
  411.             $stat->_set("from_ouvrages", $n);
  412.         } else if ($colFrom == 'from_annuaire_experts') {
  413.             $n = (int) $stat->_get('from_annuaire_experts');
  414.             $n = $n + $nb;
  415.             $stat->_set("from_annuaire_experts", $n);
  416.         } else if ($colFrom == 'from_autres') {
  417.             $n = (int) $stat->_get('from_autres');
  418.             $n = $n + $nb;
  419.             $stat->_set("from_autres", $n);
  420.         } else if ($colFrom == 'from_menu_droit_buzz') {
  421.             $n = (int) $stat->_get('from_menu_droit_buzz');
  422.             $n = $n + $nb;
  423.             $stat->_set("from_menu_droit_buzz", $n);
  424.         }
  426.         $this->em->persist($stat);
  427.         $this->em->flush();
  428.     }
  430.     /**
  431.      * Récupère site web prestataire
  432.      * Recherche par ID service
  433.      * Retourne l'URL du site
  434.      * @param int $idServicePrestataire
  435.      * @return string
  436.      */
  437.     private function getSiteParIdServicePrestataire($idServicePrestataire) {
  438.         $queryBuilder = $this->em->createQueryBuilder();
  439.         $query = $queryBuilder
  440.                 ->select(array("servicesPrestataire.url_site_web"))
  441.                 ->from(ServicesPrestataire::class, 'servicesPrestataire')
  442.                 ->where('servicesPrestataire.id_service_prestataire = :idService')
  443.                 ->setParameter('idService', $idServicePrestataire);
  444.         $resultat = $query
  445.                 ->setMaxResults(1000)
  446.                 ->getQuery()
  447.                 ->getResult(\Doctrine\ORM\Query::HYDRATE_ARRAY);
  448.         return $resultat[0]['url_site_web'];
  449.     }
  451.     /**
  452.      * Vérifie connexion locaux FUSACQ
  453.      * Examine les headers HTTP
  454.      * Compare avec IP configurée
  455.      * @return bool
  456.      */
  457.     private function testSiConnexionFromLocauxFusacq() {
  458.         $headers = apache_request_headers();
  459.         if (array_key_exists('X-Forwarded-For', $headers)) {
  460.             $hostname = $headers ['X-Forwarded-For'];
  461.         } else {
  462.             $hostname = $_SERVER ["REMOTE_ADDR"];
  463.         }
  464. //        $config = $this->getServiceLocator()->get('Config');
  465. //        if ($hostname == $config["adresse_IP_locaux_fusacq"]) {
  466. //            return true;
  467. //        } else {
  468. //            echo "###";
  469.         return false;
  470. //        }
  471.     }
  473.     /**
  474.      * Obtient IP du visiteur
  475.      * Vérifie les proxies X-Forwarded-For
  476.      * Retourne l'adresse IP réelle
  477.      * @return string
  478.      */
  479.     private function getIPVisiteur() {
  480.         $headers = apache_request_headers();
  481.         if (array_key_exists('X-Forwarded-For', $headers)) {
  482.             $hostname = $headers['X-Forwarded-For'];
  483.         } else {
  484.             $hostname = $_SERVER["REMOTE_ADDR"];
  485.         }
  486.         return $hostname;
  487.     }
  489.     /**
  490.      * Détecte si robot connu
  491.      * Utilise le fournisseur RobotProvider
  492.      * Vérifie l'IP contre une liste
  493.      * @return bool
  494.      */
  495.     private function isRobotConnu(): bool {
  496.         $ip = $this->getIPVisiteur();
  497.         $robotProvider = new RobotProvider();
  498.         return $robotProvider->donneNomRobot($ip) !== NULL;
  499.     }
  501.     /**
  502.      * Récupère statistiques consultation
  503.      * Pour une actualité spécifique
  504.      * Retourne l'objet statistique
  505.      * @param int $idActualite
  506.      * @return mixed
  507.      */
  508.     private function getStatistiqueNbConsultationActualiteBuzz(int $idActualite) {
  509.         return $this->em->getRepository(StatistiquesNbConsultationsActualitesBuzz::class)->findOneBy(['id_actualite' => $idActualite]);
  510.     }
  512.     /**
  513.      * Insère statistique consultation
  514.      * Pour une nouvelle actualité
  515.      * Initialise le compteur à 1
  516.      * @param int $idActualite
  517.      * @return void
  518.      */
  519.     private function insertStatistiqueNbConsultationActualiteBuzz($idActualite) {
  520.         $stat = new StatistiquesNbConsultationsActualitesBuzz();
  521.         $stat->_set("id_actualite", (int) $idActualite);
  522.         $stat->_set("nb_affichages", 1);
  523.         $this->em->persist($stat);
  524.         $this->em->flush();
  525.     }
  527.     /**
  528.      * Met à jour statistique consultation
  529.      * Incrémente le nombre d'affichages
  530.      * Persiste les modifications
  531.      * @param int $idActualite
  532.      * @param int $nb
  533.      * @return void
  534.      */
  535.     private function updateStatistiqueNbConsultationActualiteBuzz($idActualite, $nb): void {
  536.         /*$stat = $this->em->getRepository(StatistiquesNbConsultationsActualitesBuzz::class)->findOneBy(['id_actualite' => $idActualite]);
  537.         if ($stat) {
  538.             $stat->_set("nb_affichages", $stat->_get('nb_affichages') + $nb);
  539.             $this->em->persist($stat);
  540.             $this->em->flush();
  541.         }*/
  542.         
  543.         // On incrémente de 1 le nb de consultation
  544.         $this->consultations_annonce->incrementeConsultation('actualite', $idActualite);
  545.     }
  547.     /**
  548.      * Crée statistique de clic
  549.      * Gère anciennes/nouvelles tables
  550.      * Associe pays et newsletter
  551.      * @param string $email
  552.      * @param string $dateNewsletter
  553.      * @param string $lien
  554.      * @param string|NULL $idPays
  555.      * @return void
  556.      */
  557.     private function createStatistiqueClic($email, $dateNewsletter, $lien, $idPays = NULL): void {
  558.         if ($dateNewsletter <= BuzzNewsletter::DATE_COMMENCE_NOUVELLE_TABLE_BUZZ_STATS) {
  559.             $stat = new StatistiquesNewsletterClics();
  560.             $stat->_set('date_newsletter', $dateNewsletter);
  561.             $stat->_set('email', $email);
  562.             $stat->_set('type_newsletter', BuzzNewsletter::TYPE_NEWS_BUZZ_QUOTI);
  563.             $stat->_set('lien', $lien);
  564.             $stat->_set('nb_clics', 1);
  565.             $stat->_set('id_pays', $idPays);
  566.             $this->em->persist($stat);
  567.             $this->em->flush();
  568.         } else {
  569.             $buzzLien = $this->em->getRepository(BuzzLiensNewsletter::class)->findOneBy(['lien' => $lien, 'date_newsletter' => $dateNewsletter, 'type_lien' => NULL]);
  570.             if (!$buzzLien) {
  571.                 throw new \RuntimeException(
  572.                                 sprintf('Aucun lien trouvé pour: %s à la date %s', $lien, $dateNewsletter->format('Y-m-d'))
  573.                         );
  574.             }
  575.             $stat = new StatistiquesNewsletterClicsDuJour();
  576.             $stat->_set('date_newsletter', $dateNewsletter);
  577.             $stat->_set('email', $email);
  578.             $stat->_set('type_newsletter', BuzzNewsletter::TYPE_NEWS_BUZZ_QUOTI);
  579.             $stat->_set('lien', $lien);
  580.             $stat->_set('nb_clics', 1);
  581.             $stat->_set('id_pays', $idPays);
  582.             $this->em->persist($stat);
  583.             $this->em->flush();
  584.         }
  585.     }
  587.     /**
  588.      * Modifie statistique de clic
  589.      * Incrémente ou crée nouvelle
  590.      * Gère transition entre tables
  591.      * @param string $email
  592.      * @param string $dateNewsletter
  593.      * @param string $lien
  594.      * @param int $n
  595.      * @param string|NULL $idPays
  596.      * @return void
  597.      */
  598.     private function modifyStatistiqueClic($email, $dateNewsletter, $lien, $n, $id_lien,$idPays = NULL): void {
  599.         //ancien abondonne depuis 2017
  600.         if ($dateNewsletter <= BuzzNewsletter::DATE_COMMENCE_NOUVELLE_TABLE_BUZZ_STATS) {
  601.             $stat = $this->em->getRepository(StatistiquesNewsletterClics::class)->findOneBy(['date_newsletter' => $dateNewsletter, 'email' => $email, 'lien' => $lien, 'type_newsletter' => BuzzNewsletter::TYPE_NEWS_BUZZ_QUOTI]);
  603.             if ($stat) {
  604.                 $stat->_set('nb_clics', $stat->_get('nb_clics') + $n);
  605.                 $stat->_set('id_pays', $idPays);
  606.             } else {
  607.                 $stat = new StatistiquesNewsletterClics();
  608.                 $stat->_set('date_newsletter', $dateNewsletter);
  609.                 $stat->_set('email', $email);
  610.                 $stat->_set('type_newsletter', BuzzNewsletter::TYPE_NEWS_BUZZ_QUOTI);
  611.                 $stat->_set('lien', $lien);
  612.                 $stat->_set('nb_clics', 1);
  613.                 $stat->_set('id_pays', $idPays);
  614.                 $this->em->persist($stat);
  615.             }
  616.         } else {
  617.             //On a une tache planifiee pour mettre à jour depuis StatistiquesNewsletterClicsDuJour ver StatistiquesNewsletterClicsNew
  618.             $buzzLien = $this->em->getRepository(BuzzLiensNewsletter::class)->findOneBy(['lien' => $lien, 'date_newsletter' => $dateNewsletter, 'type_lien' => NULL]);
  619.             if (!$buzzLien) {
  620.                 throw new \RuntimeException(
  621.                                 sprintf('Aucun lien trouvé pour: %s à la date %s', $lien, $dateNewsletter->format('Y-m-d'))
  622.                         );
  623.             }
  624.             $stat = $this->em->getRepository(StatistiquesNewsletterClicsDuJour::class)
  625.                     ->findOneBy([
  626.                         'date_newsletter' => $dateNewsletter,
  627.                         'email' => $email,
  628.                         'id_lien' => $buzzLien->getIdLien(),
  629.                         'type_newsletter' => BuzzNewsletter::TYPE_NEWS_BUZZ_QUOTI
  630.             ]);
  631.             if ($stat) {
  632.                 $stat->_set('nb_clics', $stat->_get('nb_clics') + $n);
  633.                 $stat->_set('id_pays', $idPays);
  634.             } else {
  635.                 $stat = new StatistiquesNewsletterClicsDuJour();
  636.                 $stat->_set('date_newsletter', $dateNewsletter);
  637.                 $stat->_set('email', $email);
  638.                 $stat->_set('type_newsletter', BuzzNewsletter::TYPE_NEWS_BUZZ_QUOTI);
  639.                 $stat->_set('id_lien', $id_lien);
  640.                 $stat->_set('nb_clics', 1);
  641.                 $stat->_set('id_pays', $idPays);
  642.                 ;
  643.                 $this->em->persist($stat);
  644.             }
  645.         }
  647.         $this->em->flush();
  648.     }
  650.     /**
  651.      * Vérifie existence statistique
  652.      * Recherche dans tables appropriées
  653.      * Retourne vrai si existante
  654.      * @param string $email
  655.      * @param string $dateNewsletter
  656.      * @param string $lien
  657.      * @return bool
  658.      */
  659.     private function testSiStatistiqueClicCreee($email, $dateNewsletter, $lien): bool {
  660.         if ($dateNewsletter <= BuzzNewsletter::DATE_COMMENCE_NOUVELLE_TABLE_BUZZ_STATS) {
  661.             $result = $this->em->getRepository(StatistiquesNewsletterClics::class)
  662.                     ->findBy(['date_newsletter' => $dateNewsletter, 'email' => $email, 'lien' => $lien, 'type_newsletter' => BuzzNewsletter::TYPE_NEWS_BUZZ_QUOTI]);
  663.         } else {
  664.             // Récupération de l'ID du lien
  665.             $buzzLien = $this->em->getRepository(BuzzLiensNewsletter::class)
  666.                     ->findOneBy([
  667.                         'lien' => $lien,
  668.                         'date_newsletter' => $dateNewsletter,
  669.                         'type_lien' => NULL
  670.             ]);
  672.             if (!$buzzLien) {
  673.                 return false;
  674.             }
  675.             $idLien = $buzzLien->getIdLien();
  676.             $result = $this->em->getRepository(StatistiquesNewsletterClicsDuJour::class)
  677.                     ->findBy(['date_newsletter' => $dateNewsletter, 'email' => $email, 'id_lien' => $idLien, 'type_newsletter' => BuzzNewsletter::TYPE_NEWS_BUZZ_QUOTI]);
  678.         }
  680.         return count($result) >= 1;
  681.     }
  683.     /**
  684.      * Récupère lien par ID
  685.      * Recherche dans la base
  686.      * Retourne l'objet lien
  687.      * @param int $idLien
  688.      * @return mixed
  689.      */
  690.     private function getLienParIdLien(int $idLien) {
  691.         return $this->em->getRepository(BuzzLiensNewsletter::class)->findOneBy(['id_lien' => $idLien]);
  692.     }
  694.     /**
  695.      * Obtient email utilisateur
  696.      * Par ID utilisateur
  697.      * Retourne l'adresse email
  698.      * @param int $idUtilisateur
  699.      * @return string|NULL
  700.      */
  701.     private function getEmailUtilisateurParIdUtilisateur($idUtilisateur) {
  702.         $utilisateur = $this->em->getRepository(UtilisateursNewsletter::class)->findOneBy(['id_utilisateur' => $idUtilisateur]);
  703.         return $utilisateur ? $utilisateur->getEmail() : NULL;
  704.     }
  706.     /**
  707.      * Convertit chaîne URI
  708.      * En tableau associatif
  709.      * Gère les paramètres URL
  710.      * @param string $chaine
  711.      * @return array
  712.      */
  713.     function chaineFormatUriToArray(string $chaine): array {
  714.         if ($chaine === "") {
  715.             return [];
  716.         }
  717.         $infos = [];
  718.         $tab_donnees = explode("&", $chaine);
  719.         foreach ($tab_donnees as $donnee) {
  720.             $temp = explode("=", $donnee, 2);
  721.             $infos[$temp[0]] = $temp[1] ?? NULL;
  722.         }
  723.         return $infos;
  724.     }
  726.     /**
  727.      * Récupère statistique ouverture
  728.      * Par email et date newsletter
  729.      * Retourne les résultats
  730.      * @param string $email
  731.      * @param string $dateNewsletter
  732.      * @return array
  733.      */
  734.     private function getStatistiqueParEmailDate($email, $dateNewsletter) {
  735.         return $this->em->getRepository(StatistiquesNewsletterOuvertures::class)
  736.                         ->createQueryBuilder('s')
  737.                         ->where('s.date_newsletter = :dateNewsletter')
  738.                         ->andWhere('s.email = :email')
  739.                         ->andWhere('s.type_newsletter = :typeNewsletter')
  740.                         ->setParameter('dateNewsletter', $dateNewsletter)
  741.                         ->setParameter('email', $email)
  742.                         ->setParameter('typeNewsletter', BuzzNewsletter::TYPE_NEWS_BUZZ_QUOTI)
  743.                         ->getQuery()
  744.                         ->getResult();
  745.     }
  747.     /**
  748.      * Crée statistique ouverture
  749.      * Initialise le compteur
  750.      * Associe pays optionnel
  751.      * @param string $email
  752.      * @param string $dateNewsletter
  753.      * @param string|NULL $id_pays
  754.      * @return void
  755.      */
  756.     private function createStatistiqueParEmailDate($email, $dateNewsletter, $id_pays = NULL) {
  757.         $stat = new StatistiquesNewsletterOuvertures();
  758.         if ($stat) {
  759.             $stat->_set("date_newsletter", $dateNewsletter);
  760.             $stat->_set("email", $email);
  761.             $stat->_set("type_newsletter", BuzzNewsletter::TYPE_NEWS_BUZZ_QUOTI);
  762.             $stat->_set("nb_ouvertures", 1);
  763.             $stat->_set("id_pays", $id_pays);
  764.             $this->em->persist($stat);
  765.             $this->em->flush();
  766.         }
  767.     }
  768. }