changes

2026-03-23 10:50:31 +05:00
parent b1c4f7b054
commit 1256adba98
89 changed files with 3587 additions and 10419 deletions
@@ -0,0 +1,151 @@
+<?php
+
+namespace App\Containers\Dashboard\Tasks;
+
+use Illuminate\Http\UploadedFile;
+use Illuminate\Support\Facades\Log;
+use Intervention\Image\Facades\Image;
+
+class CompressImageTask
+{
+    /**
+     * Максимальное качество сжатия WebP (0-100)
+     */
+    private const WEBP_QUALITY = 82;
+
+    /**
+     * Максимальное качество для JPEG (0-100)
+     */
+    private const JPEG_QUALITY = 85;
+
+    /**
+     * Максимальная ширина изображения (px)
+     */
+    private const MAX_WIDTH = 1920;
+
+    /**
+     * Максимальная высота изображения (px)
+     */
+    private const MAX_HEIGHT = 1920;
+
+    /**
+     * Порог размера файла для сжатия (в байтах) - 1MB
+     */
+    private const SIZE_THRESHOLD = 1048576;
+
+    /**
+     * Сжимает изображение и конвертирует в WebP
+     *
+     * @param UploadedFile $file Исходный файл изображения
+     * @return array ['path' => путь к файлу, 'size' => размер в байтах, 'original_size' => исходный размер]
+     */
+    public function run(UploadedFile $file): array
+    {
+        $extension = strtolower($file->getClientOriginalExtension());
+
+        Log::info('[CompressImageTask] Начало обработки изображения', [
+            'file' => $file->getClientOriginalName(),
+            'extension' => $extension,
+            'size' => $this->formatFileSize($file->getSize()),
+            'size_bytes' => $file->getSize(),
+        ]);
+
+        // Если файл уже меньше порога и это WebP - пропускаем сжатие
+        if ($file->getSize() <= self::SIZE_THRESHOLD && $extension === 'webp') {
+            Log::info('[CompressImageTask] Файл уже оптимизирован, пропускаем', [
+                'file' => $file->getClientOriginalName(),
+            ]);
+
+            return [
+                'file' => $file,
+                'size' => $file->getSize(),
+                'original_size' => $file->getSize(),
+                'compressed' => false,
+            ];
+        }
+
+        // Создаём изображение через Intervention
+        $img = Image::make($file->getRealPath());
+
+        // Получаем исходные размеры
+        $originalWidth = $img->width();
+        $originalHeight = $img->height();
+
+        Log::info('[CompressImageTask] Исходные размеры', [
+            'width' => $originalWidth,
+            'height' => $originalHeight,
+        ]);
+
+        // Ресайзим если больше максимальных размеров
+        if ($originalWidth > self::MAX_WIDTH || $originalHeight > self::MAX_HEIGHT) {
+            $img->resize(self::MAX_WIDTH, self::MAX_HEIGHT, function ($constraint) {
+                $constraint->aspectRatio();
+                $constraint->upsize();
+            });
+
+            Log::info('[CompressImageTask] Изображение ресайзнуто', [
+                'new_width' => $img->width(),
+                'new_height' => $img->height(),
+            ]);
+        }
+
+        // Конвертируем в WebP и сжимаем
+        $webpData = $img->encode('webp', self::WEBP_QUALITY)->getEncoded();
+
+        // Сохраняем во временный файл
+        $tempFileName = pathinfo($file->getClientOriginalName(), PATHINFO_FILENAME) . '.webp';
+        $tempPath = sys_get_temp_dir() . '/' . uniqid('img_compress_') . '.webp';
+        file_put_contents($tempPath, $webpData);
+
+        $newSize = filesize($tempPath);
+
+        Log::info('[CompressImageTask] Сжатие завершено', [
+            'original_size' => $this->formatFileSize($file->getSize()),
+            'compressed_size' => $this->formatFileSize($newSize),
+            'compression_ratio' => round((1 - $newSize / $file->getSize()) * 100, 2) . '%',
+            'temp_path' => $tempPath,
+        ]);
+
+        // Создаём новый UploadedFile из сжатого
+        $compressedFile = new UploadedFile(
+            $tempPath,
+            $tempFileName,
+            'image/webp',
+            $newSize,
+            true
+        );
+
+        return [
+            'file' => $compressedFile,
+            'size' => $newSize,
+            'original_size' => $file->getSize(),
+            'compressed' => true,
+            'compression_ratio' => round((1 - $newSize / $file->getSize()) * 100, 2),
+        ];
+    }
+
+    /**
+     * Проверяет, является ли файл изображением
+     */
+    public function isImage(UploadedFile $file): bool
+    {
+        $extension = strtolower($file->getClientOriginalExtension());
+        $imageExtensions = ['jpg', 'jpeg', 'png', 'webp', 'gif', 'bmp', 'tiff', 'svg'];
+
+        return in_array($extension, $imageExtensions);
+    }
+
+    /**
+     * Форматирует размер файла
+     */
+    private function formatFileSize(int $bytes): string
+    {
+        $units = ['б', 'КиБ', 'МиБ', 'ГиБ'];
+        $bytes = max($bytes, 0);
+        $pow = floor(($bytes ? log($bytes) : 0) / log(1024));
+        $pow = min($pow, count($units) - 1);
+        $bytes /= (1 << (10 * $pow));
+
+        return round($bytes, 2) . ' ' . $units[$pow];
+    }
+}
@@ -0,0 +1,106 @@
+<?php
+
+namespace App\Containers\Dashboard\Tasks;
+
+use App\Containers\Dashboard\Exceptions\EmailFetchException;
+use Webklex\PHPIMAP\Client;
+use Webklex\PHPIMAP\ClientManager;
+use Webklex\PHPIMAP\Folder;
+use Illuminate\Support\Facades\Log;
+
+/**
+ * Подключение к IMAP-серверу
+ */
+class ConnectToImapTask
+{
+    /**
+     * Подключиться к IMAP-серверу
+     *
+     * @param string|null $accountName Имя аккаунта из config/imap.php
+     * @return Client IMAP клиент
+     * @throws EmailFetchException
+     */
+    public function run(?string $accountName = null): Client
+    {
+        $accountName = $accountName ?? config('email-news.imap_account', 'email_news');
+        
+        // Получаем конфиг для webklex/php-imap
+        $imapConfig = config('imap');
+
+        Log::info('[ConnectToImapTask] Попытка подключения к IMAP', [
+            'account' => $accountName,
+            'host' => $imapConfig['accounts'][$accountName]['host'] ?? 'unknown',
+        ]);
+
+        try {
+            // Создаём ClientManager с явным конфигом
+            $clientManager = new ClientManager($imapConfig);
+            $client = $clientManager->account($accountName);
+            $client->connect();
+
+            Log::info('[ConnectToImapTask] Успешное подключение к IMAP', [
+                'account' => $accountName,
+            ]);
+
+            return $client;
+        } catch (\Exception $e) {
+            Log::error('[ConnectToImapTask] Ошибка подключения к IMAP', [
+                'account' => $accountName,
+                'error' => $e->getMessage(),
+            ]);
+
+            throw EmailFetchException::connectionFailed($e->getMessage());
+        }
+    }
+
+    /**
+     * Получить папку
+     *
+     * @param Client $client IMAP клиент
+     * @param string $folderName Имя папки
+     * @return Folder
+     * @throws EmailFetchException
+     */
+    public function getFolder(Client $client, string $folderName): Folder
+    {
+        Log::info('[ConnectToImapTask] Получение папки', [
+            'folder' => $folderName,
+        ]);
+
+        try {
+            // Пробуем получить папку напрямую
+            $folder = $client->getFolder($folderName);
+            
+            // Если не получилось, ищем в списке папок
+            if (!$folder) {
+                $folders = $client->getFolders();
+                foreach ($folders as $f) {
+                    if ($f->name === $folderName || $f->path === $folderName) {
+                        $folder = $f;
+                        break;
+                    }
+                }
+            }
+
+            if (!$folder) {
+                throw EmailFetchException::folderNotFound($folderName);
+            }
+
+            Log::info('[ConnectToImapTask] Папка получена успешно', [
+                'folder' => $folderName,
+                'fullName' => $folder->full_name ?? $folder->name ?? $folderName,
+            ]);
+
+            return $folder;
+        } catch (EmailFetchException $e) {
+            throw $e;
+        } catch (\Exception $e) {
+            Log::error('[ConnectToImapTask] Ошибка получения папки', [
+                'folder' => $folderName,
+                'error' => $e->getMessage(),
+            ]);
+
+            throw EmailFetchException::folderNotFound($folderName);
+        }
+    }
+}
@@ -0,0 +1,151 @@
+<?php
+
+namespace App\Containers\Dashboard\Tasks;
+
+use App\Containers\Dashboard\Data\EmailAttachmentData;
+use App\Containers\Dashboard\Exceptions\EmailFetchException;
+use Illuminate\Support\Facades\Log;
+use Illuminate\Support\Facades\Storage;
+use Webklex\PHPIMAP\Attachment;
+
+/**
+ * Загрузка и сохранение вложений из письма
+ */
+class DownloadAttachmentsTask
+{
+    /**
+     * Скачать и сохранить вложения
+     *
+     * @param object $message IMAP сообщение
+     * @param string|null $disk Диск для сохранения
+     * @return array<EmailAttachmentData>
+     * @throws EmailFetchException
+     */
+    public function run(object $message, ?string $disk = null): array
+    {
+        $disk = $disk ?? config('email-news.attachments_folder', 'email_attachments');
+
+        Log::info('[DownloadAttachmentsTask] Начало загрузки вложений', [
+            'message_id' => $message->getMessageId(),
+            'disk' => $disk,
+        ]);
+
+        $attachments = $message->getAttachments();
+
+        if (empty($attachments)) {
+            Log::warning('[DownloadAttachmentsTask] Вложения не найдены');
+            throw EmailFetchException::noAttachmentsFound();
+        }
+
+        Log::info('[DownloadAttachmentsTask] Найдено вложений', [
+            'count' => count($attachments),
+        ]);
+
+        $savedAttachments = [];
+        $maxSize = config('email-news.max_attachment_size', 41943040); // 40MB по умолчанию
+
+        /** @var Attachment $attachment */
+        foreach ($attachments as $attachment) {
+            try {
+                // Проверяем размер
+                if ($maxSize > 0 && $attachment->getSize() > $maxSize) {
+                    Log::warning('[DownloadAttachmentsTask] Вложение превышает максимальный размер', [
+                        'filename' => $attachment->getName(),
+                        'size' => $attachment->getSize(),
+                        'max_size' => $maxSize,
+                    ]);
+                    continue;
+                }
+
+                // Сохраняем вложение
+                $savedPath = $this->saveAttachment($attachment, $disk);
+
+                if ($savedPath) {
+                    $savedAttachments[] = EmailAttachmentData::fromFile(
+                        path: $savedPath,
+                        originalFilename: $attachment->getName(),
+                        mimeType: $attachment->getContentType(),
+                        size: $attachment->getSize(),
+                        contentId: $attachment->getContentId(),
+                    );
+
+                    Log::info('[DownloadAttachmentsTask] Вложение сохранено', [
+                        'filename' => $attachment->getName(),
+                        'path' => $savedPath,
+                        'size' => $attachment->getSize(),
+                    ]);
+                }
+            } catch (\Exception $e) {
+                Log::error('[DownloadAttachmentsTask] Ошибка сохранения вложения', [
+                    'filename' => $attachment->getName(),
+                    'error' => $e->getMessage(),
+                ]);
+                // Продолжаем обработку остальных вложений
+            }
+        }
+
+        if (empty($savedAttachments)) {
+            Log::error('[DownloadAttachmentsTask] Не удалось сохранить ни одно вложение');
+            throw EmailFetchException::noAttachmentsFound();
+        }
+
+        Log::info('[DownloadAttachmentsTask] Загрузка вложений завершена', [
+            'saved_count' => count($savedAttachments),
+        ]);
+
+        return $savedAttachments;
+    }
+
+    /**
+     * Сохранить вложение на диск
+     *
+     * @param Attachment $attachment Вложение
+     * @param string $disk Диск для сохранения
+     * @return string|null Путь к сохранённому файлу
+     */
+    private function saveAttachment(Attachment $attachment, string $disk): ?string
+    {
+        $filename = $this->generateUniqueFilename($attachment->getName());
+        $savePath = storage_path('app/' . $disk);
+
+        // Создаём директорию, если не существует
+        if (!is_dir($savePath)) {
+            mkdir($savePath, 0755, true);
+        }
+
+        // Сохраняем вложение (метод save принимает только путь и имя файла)
+        try {
+            $savedPath = $attachment->save($savePath, $filename);
+
+            if ($savedPath) {
+                // Возвращаем относительный путь для сохранения в БД
+                return $disk . '/' . $filename;
+            }
+        } catch (\Exception $e) {
+            Log::error('[DownloadAttachmentsTask:saveAttachment] Ошибка сохранения', [
+                'filename' => $attachment->getName(),
+                'error' => $e->getMessage(),
+            ]);
+        }
+
+        return null;
+    }
+
+    /**
+     * Сгенерировать уникальное имя файла
+     *
+     * @param string $originalName Оригинальное имя файла
+     * @return string
+     */
+    private function generateUniqueFilename(string $originalName): string
+    {
+        $extension = strtolower(pathinfo($originalName, PATHINFO_EXTENSION));
+        $basename = pathinfo($originalName, PATHINFO_FILENAME);
+
+        // Очищаем имя от специальных символов
+        $basename = preg_replace('/[^a-zA-Z0-9_\-\p{L}]/u', '_', $basename);
+
+        // Добавляем timestamp для уникальности
+        return $basename . '_' . time() . '_' . bin2hex(random_bytes(4)) . '.' . $extension;
+    }
+}
@@ -0,0 +1,60 @@
+<?php
+
+namespace App\Containers\Dashboard\Tasks;
+
+use Webklex\PHPIMAP\Folder;
+use Illuminate\Support\Facades\Log;
+
+/**
+ * Получение непрочитанных писем из папки
+ */
+class FetchUnreadEmailsTask
+{
+    /**
+     * Получить непрочитанные письма
+     *
+     * @param Folder $folder IMAP папка
+     * @return array Массив писем
+     */
+    public function run(Folder $folder): array
+    {
+        Log::info('[FetchUnreadEmailsTask] Получение непрочитанных писем', [
+            'folder' => $folder->full_name ?? $folder->name ?? 'unknown',
+        ]);
+
+        try {
+            // Получаем все непрочитанные сообщения
+            $messages = $folder->messages()->unseen()->get();
+
+            $emails = [];
+            foreach ($messages as $message) {
+                $from = $message->getFrom()[0] ?? null;
+                $subject = $message->getSubject();
+                $date = $message->getDate();
+
+                $emails[] = [
+                    'message' => $message,
+                    'message_id' => $message->getMessageId(),
+                    'from_email' => $from?->mail ?? null,
+                    'from_name' => $from?->name ?? null,
+                    'subject' => $subject,
+                    'date' => $date,
+                    'has_attachments' => $message->hasAttachments(),
+                ];
+            }
+
+            Log::info('[FetchUnreadEmailsTask] Получены письма', [
+                'count' => count($emails),
+                'folder' => $folder->full_name ?? $folder->name ?? 'unknown',
+            ]);
+
+            return $emails;
+        } catch (\Exception $e) {
+            Log::error('[FetchUnreadEmailsTask] Ошибка получения писем', [
+                'error' => $e->getMessage(),
+            ]);
+
+            return [];
+        }
+    }
+}
@@ -0,0 +1,95 @@
+<?php
+
+namespace App\Containers\Dashboard\Tasks;
+
+use Illuminate\Support\Facades\Log;
+
+/**
+ * Фильтрация писем по отправителю
+ */
+class FilterBySenderTask
+{
+    /**
+     * Отфильтровать письма по разрешённым отправителям
+     *
+     * @param array $emails Массив писем
+     * @param array|null $allowedSenders Whitelist email-адресов
+     * @return array Отфильтрованные письма
+     */
+    public function run(array $emails, ?array $allowedSenders = null): array
+    {
+        // Если whitelist не передан, берём из конфига
+        $allowedSenders = $allowedSenders ?? config('email-news.allowed_senders', []);
+        
+        // Фильтруем пустые значения
+        $allowedSenders = array_filter($allowedSenders, fn($email) => !empty($email));
+
+        // Если список пуст, используем editor_email
+        if (empty($allowedSenders)) {
+            $editorEmail = config('email-news.editor_email');
+            if ($editorEmail) {
+                $allowedSenders = [$editorEmail];
+            }
+        }
+
+        Log::info('[FilterBySenderTask] Фильтрация писем', [
+            'total_emails' => count($emails),
+            'allowed_senders' => $allowedSenders,
+        ]);
+
+        if (empty($allowedSenders)) {
+            Log::warning('[FilterBySenderTask] Не указан разрешённый отправитель, пропускаем все письма');
+            return [];
+        }
+
+        $filtered = [];
+        $skippedCount = 0;
+
+        foreach ($emails as $email) {
+            $fromEmail = $email['from_email'];
+
+            // Проверяем, есть ли отправитель в whitelist
+            if (!in_array($fromEmail, $allowedSenders, true)) {
+                $skippedCount++;
+                
+                // Логируем только если включено логирование
+                if (config('email-news.log_skipped_emails', true)) {
+                    Log::debug('[FilterBySenderTask] Пропущено письмо от неразрешённого отправителя', [
+                        'from' => $fromEmail,
+                        'subject' => $email['subject'],
+                        'date' => $email['date'],
+                    ]);
+                }
+                continue;
+            }
+
+            $filtered[] = $email;
+        }
+
+        Log::info('[FilterBySenderTask] Фильтрация завершена', [
+            'total' => count($emails),
+            'filtered' => count($filtered),
+            'skipped' => $skippedCount,
+        ]);
+
+        return $filtered;
+    }
+
+    /**
+     * Проверить конкретный email на разрешение
+     *
+     * @param string $email Email для проверки
+     * @return bool
+     */
+    public function isAllowed(string $email): bool
+    {
+        $allowedSenders = config('email-news.allowed_senders', []);
+        $allowedSenders = array_filter($allowedSenders, fn($e) => !empty($e));
+
+        if (empty($allowedSenders)) {
+            $allowedSenders = [config('email-news.editor_email')];
+        }
+
+        return in_array($email, $allowedSenders, true);
+    }
+}
@@ -0,0 +1,74 @@
+<?php
+
+namespace App\Containers\Dashboard\Tasks;
+
+use Illuminate\Support\Facades\Log;
+
+/**
+ * Пометка письма как прочитанного
+ */
+class MarkEmailAsReadTask
+{
+    /**
+     * Пометить письмо как прочитанное
+     *
+     * @param object $message IMAP сообщение
+     * @return bool
+     */
+    public function run(object $message): bool
+    {
+        Log::info('[MarkEmailAsReadTask] Пометка письма как прочитанного', [
+            'message_id' => $message->getMessageId(),
+            'subject' => $message->getSubject(),
+        ]);
+
+        try {
+            $message->setFlag('Seen');
+
+            Log::info('[MarkEmailAsReadTask] Письмо помечено как прочитанное');
+
+            return true;
+        } catch (\Exception $e) {
+            Log::error('[MarkEmailAsReadTask] Ошибка пометки письма', [
+                'error' => $e->getMessage(),
+            ]);
+
+            return false;
+        }
+    }
+
+    /**
+     * Пометить письмо как прочитанное и переместить в другую папку
+     *
+     * @param object $message IMAP сообщение
+     * @param string $targetFolder Целевая папка
+     * @return bool
+     */
+    public function markAndMove(object $message, string $targetFolder): bool
+    {
+        Log::info('[MarkEmailAsReadTask] Пометка и перемещение письма', [
+            'message_id' => $message->getMessageId(),
+            'target_folder' => $targetFolder,
+        ]);
+
+        try {
+            // Помечаем как прочитанное
+            $message->setFlag('Seen');
+
+            // Перемещаем в другую папку
+            $message->moveToFolder($targetFolder);
+
+            Log::info('[MarkEmailAsReadTask] Письмо обработано и перемещено', [
+                'target_folder' => $targetFolder,
+            ]);
+
+            return true;
+        } catch (\Exception $e) {
+            Log::error('[MarkEmailAsReadTask] Ошибка обработки письма', [
+                'error' => $e->getMessage(),
+            ]);
+
+            return false;
+        }
+    }
+}