23844646769

Committed 01 Apr 2026 10:42AM UTC coverage: 31.674% (+31.1%) from 0.549%

Build # 23844646769

Build Type

push

github

Committed by

web-flow

Commit Message

feat: media files import

Coverage Stats

431 of 801 new or added lines in 30 files covered. (53.81%)

4 existing lines in 4 files now uncovered.

439 of 1386 relevant lines covered (31.67%)

0.74 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/app/Jobs/ProcessChatImport.php

<?php

declare(strict_types=1);

namespace App\Jobs;

use App\Services\Import\Archives\DTO\ArchiveExtractionResult;
use App\Services\Import\Archives\Exceptions\ArchiveExtractionFailedException;
use App\Services\Import\Factories\ImportArchiveExtractorFactory;
use App\Services\Import\Strategies\ImportOnlyMediaFilesStrategyInterface;
use App\Services\Import\Strategies\ImportStrategyInterface;
use App\Services\ImportService;
use App\Services\Media\MediaFileStorageService;
use App\Services\Parsers\ParserRegistry;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Database\QueryException;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\Storage;

class ProcessChatImport implements ShouldQueue
{
    use Dispatchable;
    use InteractsWithQueue;
    use Queueable;
    use SerializesModels;

    /**
     * @param int                     $userId
     * @param string                  $messengerType
     * @param string                  $exportFileStoredPath Storage-relative path (archive or single export file)
     * @param ImportStrategyInterface $strategy
     */
    public function __construct(
        public int                     $userId,
        public string                  $messengerType,
        public string                  $exportFileStoredPath,
        public ImportStrategyInterface $strategy
    ) {
    }

    /**
     * @param ImportArchiveExtractorFactory $archiveExtractorsFactory
     * @param ParserRegistry                $parserRegistry
     * @param MediaFileStorageService       $mediaFileStorageService
     *
     * @return void
     */
    public function handle(
        ImportArchiveExtractorFactory $archiveExtractorsFactory,
        ParserRegistry                $parserRegistry,
        MediaFileStorageService       $mediaFileStorageService
    ): void {
        $source             = null;
        $extractedDir       = null;
        $shouldDeleteSource = true;

        try {
            $archiveExtractor = $archiveExtractorsFactory->makeForPath($this->exportFileStoredPath);
            if ($archiveExtractor !== null) {
                $source = $archiveExtractor->extract($this->exportFileStoredPath, $this->messengerType);

                $extractedDir = $source->getExtractedDir();

                /**
                 * If export file (e.g. result.json) is not presented - we cannot perform import
                 */
                if ($source->getExportFileAbsolutePath() === null) {
                    /**
                     * Though, if import mode is 'To selected conversation' - we can try to import media to already
                     * existing conversation
                     */
                    $this->runMediaOnlyFallback(
                        archiveExtractorsFactory: $archiveExtractorsFactory,
                        parserRegistry: $parserRegistry,
                        mediaFileStorageService: $mediaFileStorageService
                    );

                    return;
                }
            }
            $extractedExportFile = $source ?? new ArchiveExtractionResult(
                Storage::path($this->exportFileStoredPath),
                null,
                null
            );

            /**
             * @var ImportService $service
             */
            $service = app(ImportService::class);

            /**
             * Импорт читает файл экспорта из $extractedExportFile и при наличии медиа копирует их из распакованной
             * папки в постоянное хранилище (Storage).
             * К моменту выхода из import() файлы уже лежат в conversations/{id}/media/.
             */
            $service->import(
                userId: $this->userId,
                messengerType: $this->messengerType,
                strategy: $this->strategy,
                extractedExportFile: $extractedExportFile
            );
        } catch (ArchiveExtractionFailedException $e) {
            Log::warning('Archive extraction failed', [
                'user_id'          => $this->userId,
                'messenger_type'   => $this->messengerType,
                'export_file_path' => $this->exportFileStoredPath,
                'reason'           => $e->getMessage(),
            ]);
        } catch (QueryException $e) {
            Log::error('Import failed due to database query error', [
                'user_id'          => $this->userId,
                'messenger_type'   => $this->messengerType,
                'export_file_path' => $this->exportFileStoredPath,
                'strategy'         => $this->strategy->getName(),
                'error'            => $e->getMessage(),
            ]);

            $shouldDeleteSource = false;
            throw $e;
        } finally {
            /**
             * Delete temporary archive/export file
             */
            if ($shouldDeleteSource && Storage::exists($this->exportFileStoredPath)) {
                Storage::delete($this->exportFileStoredPath);
            }

            /**
             * Delete extraction directory
             */
            if (isset($extractedDir) && Storage::exists($extractedDir)) {
                Storage::deleteDirectory($extractedDir);
            }
        }
    }

    /**
     * Fallback for "Import to selected conversation" option when archive has additional media files that should be
     * merged into selected conversation
     *
     * @param ImportArchiveExtractorFactory $archiveExtractorsFactory
     * @param ParserRegistry                $parserRegistry
     * @param MediaFileStorageService       $mediaFileStorageService
     *
     * @return void
     */
    private function runMediaOnlyFallback(
        ImportArchiveExtractorFactory $archiveExtractorsFactory,
        ParserRegistry                $parserRegistry,
        MediaFileStorageService       $mediaFileStorageService
    ): void {
        /**
         * This fallback is only for "Import to selected conversation" scenario
         */
        if (!$this->strategy instanceof ImportOnlyMediaFilesStrategyInterface) {
            return;
        }

        $targetConversationId = $this->strategy->getImportMode()?->getTargetConversationId();
        if (!isset($targetConversationId)) {
            return;
        }

        $mediaUploadJob = new ProcessConversationMediaUpload(
            userId: $this->userId,
            conversationId: $targetConversationId,
            path: $this->exportFileStoredPath
        );

        $mediaUploadJob->handle(
            parserRegistry: $parserRegistry,
            mediaFileStorageService: $mediaFileStorageService,
            archiveExtractorsFactory: $archiveExtractorsFactory
        );
    }
}

1	<?php
2
3	declare(strict_types=1);
4
5	namespace App\Jobs;
6
7	use App\Services\Import\Archives\DTO\ArchiveExtractionResult;
8	use App\Services\Import\Archives\Exceptions\ArchiveExtractionFailedException;
9	use App\Services\Import\Factories\ImportArchiveExtractorFactory;
10	use App\Services\Import\Strategies\ImportOnlyMediaFilesStrategyInterface;
11	use App\Services\Import\Strategies\ImportStrategyInterface;
12	use App\Services\ImportService;
13	use App\Services\Media\MediaFileStorageService;
14	use App\Services\Parsers\ParserRegistry;
15	use Illuminate\Bus\Queueable;
16	use Illuminate\Contracts\Queue\ShouldQueue;
17	use Illuminate\Database\QueryException;
18	use Illuminate\Foundation\Bus\Dispatchable;
19	use Illuminate\Queue\InteractsWithQueue;
20	use Illuminate\Queue\SerializesModels;
21	use Illuminate\Support\Facades\Log;
22	use Illuminate\Support\Facades\Storage;
23
24	class ProcessChatImport implements ShouldQueue
25	{
26	use Dispatchable;
27	use InteractsWithQueue;
28	use Queueable;
29	use SerializesModels;
30
31	/**
32	* @param int $userId
33	* @param string $messengerType
34	* @param string $exportFileStoredPath Storage-relative path (archive or single export file)
35	* @param ImportStrategyInterface $strategy
36	*/
37	public function __construct(
38	public int $userId,
39	public string $messengerType,
40	public string $exportFileStoredPath,
41	public ImportStrategyInterface $strategy
42	) {
43	}	×
44
45	/**
46	* @param ImportArchiveExtractorFactory $archiveExtractorsFactory
47	* @param ParserRegistry $parserRegistry
48	* @param MediaFileStorageService $mediaFileStorageService
49	*
50	* @return void
51	*/
52	public function handle(
53	ImportArchiveExtractorFactory $archiveExtractorsFactory,
54	ParserRegistry $parserRegistry,
55	MediaFileStorageService $mediaFileStorageService
56	): void {
NEW 57	$source = null;	×
NEW 58	$extractedDir = null;	×
NEW 59	$shouldDeleteSource = true;	×
60
61	try {
NEW 62	$archiveExtractor = $archiveExtractorsFactory->makeForPath($this->exportFileStoredPath);	×
NEW 63	if ($archiveExtractor !== null) {	×
NEW 64	$source = $archiveExtractor->extract($this->exportFileStoredPath, $this->messengerType);	×
65
NEW 66	$extractedDir = $source->getExtractedDir();	×
67
68	/**
69	* If export file (e.g. result.json) is not presented - we cannot perform import
70	*/
NEW 71	if ($source->getExportFileAbsolutePath() === null) {	×
72	/**
73	* Though, if import mode is 'To selected conversation' - we can try to import media to already
74	* existing conversation
75	*/
NEW 76	$this->runMediaOnlyFallback(	×
NEW 77	archiveExtractorsFactory: $archiveExtractorsFactory,	×
NEW 78	parserRegistry: $parserRegistry,	×
NEW 79	mediaFileStorageService: $mediaFileStorageService	×
NEW 80	);	×
81
NEW 82	return;	×
83	}
84	}
NEW 85	$extractedExportFile = $source ?? new ArchiveExtractionResult(	×
NEW 86	Storage::path($this->exportFileStoredPath),	×
NEW 87	null,	×
NEW 88	null	×
NEW 89	);	×
90
91	/**
92	* @var ImportService $service
93	*/
94	$service = app(ImportService::class);	×
95
96	/**
97	* Импорт читает файл экспорта из $extractedExportFile и при наличии медиа копирует их из распакованной
98	* папки в постоянное хранилище (Storage).
99	* К моменту выхода из import() файлы уже лежат в conversations/{id}/media/.
100	*/
101	$service->import(	×
102	userId: $this->userId,	×
103	messengerType: $this->messengerType,	×
NEW 104	strategy: $this->strategy,	×
NEW 105	extractedExportFile: $extractedExportFile	×
UNCOV 106	);	×
NEW 107	} catch (ArchiveExtractionFailedException $e) {	×
NEW 108	Log::warning('Archive extraction failed', [	×
NEW 109	'user_id' => $this->userId,	×
NEW 110	'messenger_type' => $this->messengerType,	×
NEW 111	'export_file_path' => $this->exportFileStoredPath,	×
NEW 112	'reason' => $e->getMessage(),	×
NEW 113	]);	×
NEW 114	} catch (QueryException $e) {	×
NEW 115	Log::error('Import failed due to database query error', [	×
NEW 116	'user_id' => $this->userId,	×
NEW 117	'messenger_type' => $this->messengerType,	×
NEW 118	'export_file_path' => $this->exportFileStoredPath,	×
NEW 119	'strategy' => $this->strategy->getName(),	×
NEW 120	'error' => $e->getMessage(),	×
NEW 121	]);	×
122
NEW 123	$shouldDeleteSource = false;	×
NEW 124	throw $e;	×
125	} finally {
126	/**
127	* Delete temporary archive/export file
128	*/
NEW 129	if ($shouldDeleteSource && Storage::exists($this->exportFileStoredPath)) {	×
NEW 130	Storage::delete($this->exportFileStoredPath);	×
131	}
132
133	/**
134	* Delete extraction directory
135	*/
NEW 136	if (isset($extractedDir) && Storage::exists($extractedDir)) {	×
NEW 137	Storage::deleteDirectory($extractedDir);	×
138	}
139	}
140	}
141
142	/**
143	* Fallback for "Import to selected conversation" option when archive has additional media files that should be
144	* merged into selected conversation
145	*
146	* @param ImportArchiveExtractorFactory $archiveExtractorsFactory
147	* @param ParserRegistry $parserRegistry
148	* @param MediaFileStorageService $mediaFileStorageService
149	*
150	* @return void
151	*/
152	private function runMediaOnlyFallback(
153	ImportArchiveExtractorFactory $archiveExtractorsFactory,
154	ParserRegistry $parserRegistry,
155	MediaFileStorageService $mediaFileStorageService
156	): void {
157	/**
158	* This fallback is only for "Import to selected conversation" scenario
159	*/
NEW 160	if (!$this->strategy instanceof ImportOnlyMediaFilesStrategyInterface) {	×
NEW 161	return;	×
162	}
163
NEW 164	$targetConversationId = $this->strategy->getImportMode()?->getTargetConversationId();	×
NEW 165	if (!isset($targetConversationId)) {	×
NEW 166	return;	×
167	}
168
NEW 169	$mediaUploadJob = new ProcessConversationMediaUpload(	×
NEW 170	userId: $this->userId,	×
NEW 171	conversationId: $targetConversationId,	×
NEW 172	path: $this->exportFileStoredPath	×
NEW 173	);	×
174
NEW 175	$mediaUploadJob->handle(	×
NEW 176	parserRegistry: $parserRegistry,	×
NEW 177	mediaFileStorageService: $mediaFileStorageService,	×
NEW 178	archiveExtractorsFactory: $archiveExtractorsFactory	×
NEW 179	);	×
180	}
181	}

LeTraceurSnorkLibrary / MessSaga / 23844646769

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous