Proyectos de Subversion LeadersLinked - Services

<?php
declare(strict_types = 1);
namespace LeadersLinked\Command;

use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;
use Laminas\Db\Adapter\AdapterInterface;
use Laminas\Log\LoggerInterface;
use LeadersLinked\Mapper\EmailMapper;
use PHPMailer\PHPMailer\PHPMailer;
use LeadersLinked\Model\Email;
use Laminas\Mvc\I18n\Translator;
use LeadersLinked\Cache\CacheInterface;
use Laminas\Db\Adapter\Exception\InvalidQueryException; // Importar para manejar excepciones de BD

class ProcessQueueEmailCommand extends Command
{
    /**
     *
     * @var \Laminas\Db\Adapter\AdapterInterface
     */
    private $adapter;

    /**
     *
     * @var \LeadersLinked\Cache\CacheInterface
     */
    private $cache;

    /**
     *
     * @var \Laminas\Log\LoggerInterface
     */
    private $logger;

    /**
     *
     * @var array
     */
    private $config;

    /**
     *
     * @var \Laminas\Mvc\I18n\Translator
     */
    private $translator;

    /**
     *
     * @param \Laminas\Db\Adapter\AdapterInterface $adapter
     * @param \LeadersLinked\Cache\CacheInterface $cache
     * @param \Laminas\Log\LoggerInterface $logger
     * @param array $config
     * @param \Laminas\Mvc\I18n\Translator $translator
     */
    public function __construct($adapter, $cache, $logger, $config, $translator)
    {
        $this->adapter = $adapter;
        $this->cache = $cache;
        $this->logger = $logger;
        $this->config = $config;
        $this->translator = $translator;

        parent::__construct();
    }

    protected function execute($input, $output)
    {
        $sandbox = $this->config['leaderslinked.runmode.sandbox'];
        if ($sandbox) {
            $batch_size = $this->config['leaderslinked.email.sandbox_batch_size'];
            $from_address = $this->config['leaderslinked.email.sandbox_from_address'];
            $from_name = $this->config['leaderslinked.email.sandbox_from_name'];
            $host = $this->config['leaderslinked.email.sandbox_host'];
            $port = $this->config['leaderslinked.email.sandbox_port'];
            $username = $this->config['leaderslinked.email.sandbox_username'];
            $password = $this->config['leaderslinked.email.sandbox_password'];
        } else {
            $batch_size = $this->config['leaderslinked.email.production_batch_size'];
            $from_address = $this->config['leaderslinked.email.production_from_address'];
            $from_name = $this->config['leaderslinked.email.production_from_name'];
            $host = $this->config['leaderslinked.email.production_host'];
            $port = $this->config['leaderslinked.email.production_port'];
            $username = $this->config['leaderslinked.email.production_username'];
            $password = $this->config['leaderslinked.email.production_password'];
        }

        $this->logger->info('Inicio del proceso de la cola de Email');
        $output->writeln('<info>Iniciando el procesamiento de la cola de emails...</info>');

        $emailCompleted = 0;
        $emailError = 0; // Para correos con errores que se descartan
        $emailRetried = 0; // Para correos que se reintentan

        $emailMapper = EmailMapper::getInstance($this->adapter);
        $emails = $emailMapper->fetchBatch($batch_size);

        if (!$emails) {
            $this->logger->info('No hay emails en la cola');
            $output->writeln('<comment>No hay emails en la cola para procesar.</comment>');
            return Command::SUCCESS;
        }

        foreach ($emails as $email) {
            // Iniciar transacción para cada email para asegurar atomicidad
            $this->adapter->getDriver()->getConnection()->beginTransaction();
            try {
                $content = json_decode($email->content, true);

                // Validación básica de los datos del email
                if (json_last_error() !== JSON_ERROR_NONE) {
                    throw new \RuntimeException('Error al decodificar el contenido JSON del email: ' . json_last_error_msg());
                }
                if (!isset($content['to_address'], $content['subject'], $content['message'])) {
                    throw new \RuntimeException('Contenido del email JSON incompleto: faltan datos esenciales.');
                }

                $to_address = $content['to_address'];
                $to_name = $content['to_name'] ?? ''; // Valor por defecto
                $cc = $content['cc'] ?? []; // Valor por defecto
                $bcc = $content['bcc'] ?? []; // Valor por defecto
                $subject = $content['subject'];
                $message = $content['message'];

                // Normalización de codificación
                $subject = $this->normalizeEncoding($subject);
                $message = $this->normalizeEncoding($message);

                $phpMailer = new PHPMailer(true); // true para habilitar excepciones
                $phpMailer->isSMTP();
                $phpMailer->SMTPDebug = 0; // 0 para no depurar, 2 para mensajes detallados en desarrollo
                $phpMailer->Host = $host;
                $phpMailer->SMTPAuth = true;
                $phpMailer->SMTPSecure = 'tls'; // o 'ssl' si el puerto es 465
                $phpMailer->Username = $username;
                $phpMailer->Password = $password;
                $phpMailer->Port = $port;
                $phpMailer->CharSet = 'UTF-8';

                $phpMailer->setFrom($from_address, $from_name);
                $phpMailer->addAddress($to_address, $to_name);

                foreach ($cc as $address => $name) {
                    $phpMailer->addCC($address, $name);
                }
                foreach ($bcc as $address => $name) {
                    $phpMailer->addBCC($address, $name);
                }

                $phpMailer->IsHTML(true);
                $phpMailer->Subject = $subject;
                $phpMailer->Body = $message;
                $phpMailer->AltBody = strip_tags($message); // Versión de texto plano

                $phpMailer->send();

                // Si el envío es exitoso
                $emailCompleted++;
                $email->status = Email::STATUS_COMPLETED;
                $email->tried = $email->tried + 1; // Aunque exitoso, es bueno registrar el intento
                $this->logger->info('Email enviado correctamente: ' . $email->id);
                $output->writeln("  <info>✔ Email #{$email->id} enviado a {$to_address}</info>");

                // Actualizar el estado del email en la BD y confirmar la transacción
                $emailMapper->update($email);
                $this->adapter->getDriver()->getConnection()->commit();

            } catch (\Exception $e) {
                $error_message = 'Error de PHPMailer al enviar email ' . $email->id . ': ' . $e->getMessage() . ' Debug: ' . $phpMailer->ErrorInfo;
                $this->logger->error($error_message);
                $output->writeln("  <error>✗ Error al enviar email #{$email->id}: {$e->getMessage()}</error>");
           
                $email->tried = $email->tried + 1;

                if ($email->tried >= $this->config['leaderslinked.email.max_retries']) { // Usar una configuración para el número máximo de reintentos
                    $emailError++;
                    $email->status = Email::STATUS_ERROR;
                    $this->logger->info('Email descartado después de ' . $email->tried . ' intentos fallidos: ' . $email->id);
                    $output->writeln("    <error>Email #{$email->id} descartado (máx. reintentos alcanzado).</error>");
                } else {
                    $emailRetried++;
                    $email->status = Email::STATUS_PENDING; // Mantener como pendiente para reintentar
                    $this->logger->warning('Email ' . $email->id . ' falló. Intentos: ' . $email->tried . '. Reintentando más tarde.');
                }
                // Actualizar el estado del email en la BD y revertir si algo sale mal con la actualización (raro en este punto)
                try {
                    $emailMapper->update($email);
                    $this->adapter->getDriver()->getConnection()->commit(); // Confirmar la transacción
                } catch (\Exception $dbE) {
                    $this->adapter->getDriver()->getConnection()->rollback();
                    $this->logger->critical('Error CRÍTICO al actualizar el estado del email #'.$email->id.' en la BD después de fallo de envío: ' . $dbE->getMessage());
                    $output->writeln("<error>    ERROR CRÍTICO: No se pudo actualizar el estado del email #{$email->id} en la BD.</error>");
                }

            } catch (\RuntimeException $e) {
                // Errores de lógica de negocio o validación (ej. JSON malformado)
                $error_message = 'Error de lógica/validación para email ' . $email->id . ': ' . $e->getMessage();
                $this->logger->error($error_message);
                $output->writeln("  <error>✗ Error de procesamiento interno para email #{$email->id}: {$e->getMessage()}</error>");

                $emailError++; // Generalmente estos errores son irrecuperables por reintentos
                $email->status = Email::STATUS_ERROR;
                $email->tried = $email->tried + 1; // Registrar el intento fallido

                try {
                    $emailMapper->update($email);
                    $this->adapter->getDriver()->getConnection()->commit(); // Confirmar la transacción
                } catch (\Exception $dbE) {
                    $this->adapter->getDriver()->getConnection()->rollback();
                    $this->logger->critical('Error CRÍTICO al actualizar el estado del email #'.$email->id.' en la BD después de error de procesamiento: ' . $dbE->getMessage());
                    $output->writeln("<error>    ERROR CRÍTICO: No se pudo actualizar el estado del email #{$email->id} en la BD.</error>");
                }
            }
             catch (\Exception $e) {
                // Cualquier otra excepción no capturada
                $error_message = 'Error desconocido al procesar email ' . $email->id . ': ' . $e->getMessage();
                $this->logger->critical($error_message);
                $output->writeln("  <error>✗ Error inesperado al procesar email #{$email->id}: {$e->getMessage()}</error>");

                $emailError++;
                $email->status = Email::STATUS_ERROR; // Marcar como error irrecuperable
                $email->tried = $email->tried + 1;

                try {
                    $emailMapper->update($email);
                    $this->adapter->getDriver()->getConnection()->commit(); // Confirmar la transacción
                } catch (\Exception $dbE) {
                    $this->adapter->getDriver()->getConnection()->rollback();
                    $this->logger->critical('Error CRÍTICO al actualizar el estado del email #'.$email->id.' en la BD después de error desconocido: ' . $dbE->getMessage());
                    $output->writeln("<error>    ERROR CRÍTICO: No se pudo actualizar el estado del email #{$email->id} en la BD.</error>");
                }
            }
        }

        $this->logger->info('Email con Errores descartados: ' . $emailError);
        $this->logger->info('Email pendientes para reintento: ' . $emailRetried);
        $this->logger->info('Email enviados correctamente: ' . $emailCompleted);
        $this->logger->info('Fin del proceso de la cola de Email');

        $output->writeln('');
        $output->writeln("<info>Resumen de la ejecución:</info>");
        $output->writeln("  - Correos enviados: <info>{$emailCompleted}</info>");
        $output->writeln("  - Correos con error y descartados: <error>{$emailError}</error>");
        $output->writeln("  - Correos a reintentar: <comment>{$emailRetried}</comment>");
        $output->writeln('<info>Proceso de la cola de emails finalizado.</info>');

        return Command::SUCCESS; // Usar constantes de Symfony para el código de salida
    }

    /**
     * Normaliza la codificación de una cadena a UTF-8.
     *
     * @param string $string
     * @return string
     */
    private function normalizeEncoding(string $string): string
    {
        $encoding = mb_detect_encoding($string, mb_detect_order(), true);
        if ($encoding && $encoding != 'UTF-8') {
            return mb_convert_encoding($string, 'UTF-8', $encoding);
        }
        return $string;
    }
}