src/Service/LoggerHelper.php line 81

Open in your IDE?
  1. <?php
  3. namespace App\Service;
  5. use App\Entity\LoggerService;
  6. use Doctrine\ORM\EntityManagerInterface;
  7. use Psr\Log\LoggerInterface;
  8. use Symfony\Component\DependencyInjection\ContainerInterface;
  9. use Monolog\Logger;
  12. class LoggerHelper
  13. {
  14.     /**
  15.      * @var EntityManagerInterface
  16.      */
  17.     private $em;
  18.     /**
  19.      * @var LoggerInterface
  20.      */
  21.     private $logger;
  23.     /**
  24.      * @param EntityManagerInterface $em
  25.      * @param LoggerInterface $logger
  26.      * @param ContainerInterface $container
  27.      */
  28.     public function __construct(EntityManagerInterface $em, LoggerInterface $logger, ContainerInterface $container)
  29.     {
  30.         $this->em = $em;
  31.         $this->logger = $logger;
  32.     }
  34.     public function saveMessage(string $message, string $type, string $description,string $code = '500', string $url= '')
  35.     {
  36.         $ip = $this->getIpCliente();
  37.         $ip2 = $this->getIpCliente2();
  38.         $ip = (filter_var($ip, FILTER_VALIDATE_IP)) ? $ip : $ip2;
  40.         $loggerService = new LoggerService();
  41.         $loggerService->setMessage($message)
  42.             ->setEventAt(new \DateTime('now'))
  43.             ->setIpAccess($ip)
  44.             ->setTypeEvent($type)
  45.             ->setDescription($description)
  46.             ->setCode($code)
  47.             ->setUrl($url)
  48.         ;
  49.         $this->em->persist($loggerService);
  50.         $this->em->flush();
  52.     }
  54.     public function saveLog(string $message, array $context = [], string $code = null)
  55.     {
  56.         $ip = $this->getIpCliente();
  57.         $ip2 = $this->getIpCliente2();
  58.         $ip = (filter_var($ip, FILTER_VALIDATE_IP)) ? $ip : $ip2;
  60.         $context = array_values($context);
  62.         $texto = $context[1];
  63.         if(is_array($context[1])){
  64.             $texto = implode(", ",$context[1]);
  65.         }
  67.         $loggerService = new LoggerService();
  68.         $loggerService->setMessage($message)
  69.             ->setEventAt(new \DateTime('now'))
  70.             ->setIpAccess($ip)
  71.             ->setTypeEvent($context[0])
  72.             ->setDescription($texto)
  73.             ->setCode($code)
  74.         ;
  75.         $repo = $this->em->getRepository(LoggerService::class);
  76.         $this->em->persist($loggerService);
  77.         $this->em->flush();
  79.     }
  81.     public function getIpCliente(): string
  82.     {
  83.         if (isset($_SERVER['HTTP_X_FORWARDED_FOR'])) {
  84.             if ('' != $_SERVER['HTTP_X_FORWARDED_FOR']) {
  85.                 $client_ip = (!empty($_SERVER['REMOTE_ADDR'])) ?
  86.                     $_SERVER['REMOTE_ADDR'] :
  87.                     ((!empty($_ENV['REMOTE_ADDR'])) ?
  88.                         $_ENV['REMOTE_ADDR'] :
  89.                         'unknown');
  91.                 // Los proxy's van añadiendo al final de esta cabecera
  92.                 // las direcciones ip que van "ocultando". Para localizar la ip real
  93.                 // del usuario se comienza a mirar por el principio hasta encontrar
  94.                 // una dirección ip que no sea del rango privado. En caso de no
  95.                 // encontrarse ninguna se toma como valor el REMOTE_ADDR
  97.                 $entries = preg_split('/[, ]/', $_SERVER['HTTP_X_FORWARDED_FOR']);
  99.                 reset($entries);
  100.                 while (list(, $entry) = each($entries)) {
  101.                     $entry = trim($entry);
  102.                     if (preg_match("/^([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)/", $entry, $ip_list)) {
  103.                         // http://www.faqs.org/rfcs/rfc1918.html
  104.                         $private_ip = [
  105.                             '/^0\./',
  106.                             '/^127\.0\.0\.1/',
  107.                             '/^192\.168\..*/',
  108.                             '/^172\.((1[6-9])|(2[0-9])|(3[0-1]))\..*/',
  109.                             '/^10\..*/',
  110.                         ];
  112.                         $found_ip = preg_replace($private_ip, $client_ip, $ip_list[1]);
  114.                         if ($client_ip != $found_ip) {
  115.                             $client_ip = $found_ip;
  116.                             break;
  117.                         }
  118.                     }
  119.                 }
  120.             } else {
  121.                 $client_ip = (!empty($_SERVER['REMOTE_ADDR'])) ?
  122.                     $_SERVER['REMOTE_ADDR'] :
  123.                     ((!empty($_ENV['REMOTE_ADDR'])) ?
  124.                         $_ENV['REMOTE_ADDR'] :
  125.                         'unknown');
  126.             }
  127.         } else {
  128.             $client_ip = $this->requestStack->getCurrentRequest()->getClientIps();
  129.         }
  132.         return $client_ip[0];
  133.     }
  135.     public function getIpCliente2(): string
  136.     {
  137.         if (isset($_SERVER["HTTP_CF_CONNECTING_IP"])) {
  138.             $_SERVER['REMOTE_ADDR'] = $_SERVER["HTTP_CF_CONNECTING_IP"];
  139.             $_SERVER['HTTP_CLIENT_IP'] = $_SERVER["HTTP_CF_CONNECTING_IP"];
  140.         }
  141.         $client = @$_SERVER['HTTP_CLIENT_IP'];
  142.         $forward = @$_SERVER['HTTP_X_FORWARDED_FOR'];
  143.         $remote = $_SERVER['REMOTE_ADDR'];
  145.         if (filter_var($client, FILTER_VALIDATE_IP)) {
  146.             $ip = $client;
  147.         } elseif (filter_var($forward, FILTER_VALIDATE_IP)) {
  148.             $ip = $forward;
  149.         } else {
  150.             $ip = $remote;
  151.         }
  153.         return $ip;
  154.     }
  156.     /**
  157.      * @param $ip <p>ingresar <i> IP </i> a verificar</p>
  158.      * @return bool <p>retorna <i> booleano </i> según la validación por FILTER_VALIDATE_IP</p>
  159.      */
  160.     public function isIpValid(string $ip): bool
  161.     {
  162.         return (bool)filter_var($ip, FILTER_VALIDATE_IP);
  163.     }
  166. }