329 lines
14 KiB
PHP
329 lines
14 KiB
PHP
<?php
|
|
|
|
declare(strict_types=1);
|
|
|
|
namespace App\Services\Uploads;
|
|
|
|
use App\DTOs\Uploads\UploadSessionData;
|
|
use App\DTOs\Uploads\UploadInitResult;
|
|
use App\DTOs\Uploads\UploadValidatedFile;
|
|
use App\DTOs\Uploads\UploadScanResult;
|
|
use App\Models\Artwork;
|
|
use App\Repositories\Uploads\ArtworkFileRepository;
|
|
use App\Repositories\Uploads\UploadSessionRepository;
|
|
use Illuminate\Http\UploadedFile;
|
|
use Illuminate\Support\Facades\File;
|
|
use Illuminate\Support\Facades\DB;
|
|
use Illuminate\Support\Str;
|
|
|
|
final class UploadPipelineService
|
|
{
|
|
public function __construct(
|
|
private readonly UploadStorageService $storage,
|
|
private readonly UploadSessionRepository $sessions,
|
|
private readonly UploadValidationService $validator,
|
|
private readonly UploadArchiveValidationService $archiveValidator,
|
|
private readonly UploadHashService $hasher,
|
|
private readonly UploadScanService $scanner,
|
|
private readonly UploadAuditService $audit,
|
|
private readonly UploadDerivativesService $derivatives,
|
|
private readonly ArtworkFileRepository $artworkFiles,
|
|
private readonly UploadTokenService $tokens
|
|
) {
|
|
}
|
|
|
|
public function initSession(int $userId, string $ip): UploadInitResult
|
|
{
|
|
$dir = $this->storage->ensureSection('tmp');
|
|
$filename = Str::uuid()->toString() . '.upload';
|
|
$tempPath = $dir . DIRECTORY_SEPARATOR . $filename;
|
|
|
|
File::put($tempPath, '');
|
|
|
|
$sessionId = (string) Str::uuid();
|
|
$session = $this->sessions->create($sessionId, $userId, $tempPath, UploadSessionStatus::INIT, $ip);
|
|
$token = $this->tokens->generate($sessionId, $userId);
|
|
|
|
$this->audit->log($userId, 'upload_init', $ip, [
|
|
'session_id' => $sessionId,
|
|
]);
|
|
|
|
return new UploadInitResult($session->id, $token, $session->status);
|
|
}
|
|
|
|
public function receiveToTmp(UploadedFile $file, int $userId, string $ip): UploadSessionData
|
|
{
|
|
$stored = $this->storage->storeUploadedFile($file, 'tmp');
|
|
$sessionId = (string) Str::uuid();
|
|
$session = $this->sessions->create($sessionId, $userId, $stored->path, UploadSessionStatus::TMP, $ip);
|
|
$this->sessions->updateProgress($sessionId, 10);
|
|
|
|
$this->audit->log($userId, 'upload_received', $ip, [
|
|
'session_id' => $sessionId,
|
|
'size' => $stored->size,
|
|
]);
|
|
|
|
return $session;
|
|
}
|
|
|
|
public function validateAndHash(string $sessionId): UploadValidatedFile
|
|
{
|
|
$session = $this->sessions->getOrFail($sessionId);
|
|
$validation = $this->validator->validate($session->tempPath);
|
|
|
|
if (! $validation->ok) {
|
|
$this->quarantine($session, $validation->reason);
|
|
return new UploadValidatedFile($validation, null);
|
|
}
|
|
|
|
$hash = $this->hasher->hashFile($session->tempPath);
|
|
$this->sessions->updateStatus($sessionId, UploadSessionStatus::VALIDATED);
|
|
$this->sessions->updateProgress($sessionId, 30);
|
|
$this->audit->log($session->userId, 'upload_validated', $session->ip, [
|
|
'session_id' => $sessionId,
|
|
'hash' => $hash,
|
|
]);
|
|
|
|
return new UploadValidatedFile($validation, $hash);
|
|
}
|
|
|
|
public function validateAndHashArchive(string $sessionId): UploadValidatedFile
|
|
{
|
|
$session = $this->sessions->getOrFail($sessionId);
|
|
$validation = $this->archiveValidator->validate($session->tempPath);
|
|
|
|
if (! $validation->ok) {
|
|
$this->quarantine($session, $validation->reason);
|
|
return new UploadValidatedFile($validation, null);
|
|
}
|
|
|
|
$hash = $this->hasher->hashFile($session->tempPath);
|
|
$this->sessions->updateStatus($sessionId, UploadSessionStatus::VALIDATED);
|
|
$this->sessions->updateProgress($sessionId, 30);
|
|
$this->audit->log($session->userId, 'upload_archive_validated', $session->ip, [
|
|
'session_id' => $sessionId,
|
|
'hash' => $hash,
|
|
]);
|
|
|
|
return new UploadValidatedFile($validation, $hash);
|
|
}
|
|
|
|
public function scan(string $sessionId): UploadScanResult
|
|
{
|
|
$session = $this->sessions->getOrFail($sessionId);
|
|
$result = $this->scanner->scan($session->tempPath);
|
|
|
|
if (! $result->ok) {
|
|
$this->quarantine($session, $result->reason);
|
|
return $result;
|
|
}
|
|
|
|
$this->sessions->updateStatus($sessionId, UploadSessionStatus::SCANNED);
|
|
$this->sessions->updateProgress($sessionId, 50);
|
|
$this->audit->log($session->userId, 'upload_scanned', $session->ip, [
|
|
'session_id' => $sessionId,
|
|
]);
|
|
|
|
return $result;
|
|
}
|
|
|
|
public function processAndPublish(
|
|
string $sessionId,
|
|
string $hash,
|
|
int $artworkId,
|
|
?string $originalFileName = null,
|
|
?string $archiveSessionId = null,
|
|
?string $archiveHash = null,
|
|
?string $archiveOriginalFileName = null,
|
|
array $additionalScreenshotSessions = []
|
|
): array
|
|
{
|
|
$session = $this->sessions->getOrFail($sessionId);
|
|
|
|
$archiveSession = null;
|
|
if (is_string($archiveSessionId) && trim($archiveSessionId) !== '') {
|
|
$archiveSession = $this->sessions->getOrFail($archiveSessionId);
|
|
}
|
|
|
|
$resolvedAdditionalScreenshots = collect($additionalScreenshotSessions)
|
|
->filter(fn ($payload) => is_array($payload) && is_string($payload['session_id'] ?? null) && is_string($payload['hash'] ?? null))
|
|
->values()
|
|
->map(function (array $payload): array {
|
|
return [
|
|
'session' => $this->sessions->getOrFail((string) $payload['session_id']),
|
|
'hash' => trim((string) $payload['hash']),
|
|
'file_name' => is_string($payload['file_name'] ?? null) ? $payload['file_name'] : null,
|
|
];
|
|
});
|
|
|
|
$localCleanup = [];
|
|
$objectCleanup = [];
|
|
|
|
try {
|
|
$imageOriginal = $this->derivatives->storeOriginal($session->tempPath, $hash, $originalFileName);
|
|
$localCleanup[] = $imageOriginal['local_path'];
|
|
$objectCleanup[] = $imageOriginal['object_path'];
|
|
|
|
$archiveOriginal = null;
|
|
if ($archiveSession && is_string($archiveHash) && trim($archiveHash) !== '') {
|
|
$archiveOriginal = $this->derivatives->storeOriginal($archiveSession->tempPath, trim($archiveHash), $archiveOriginalFileName);
|
|
$localCleanup[] = $archiveOriginal['local_path'];
|
|
$objectCleanup[] = $archiveOriginal['object_path'];
|
|
}
|
|
|
|
$additionalScreenshotOriginals = [];
|
|
foreach ($resolvedAdditionalScreenshots as $index => $payload) {
|
|
$storedScreenshot = $this->derivatives->storeOriginal(
|
|
$payload['session']->tempPath,
|
|
$payload['hash'],
|
|
$payload['file_name']
|
|
);
|
|
$storedScreenshot['variant'] = $this->screenshotVariantName($index + 1);
|
|
$additionalScreenshotOriginals[] = $storedScreenshot;
|
|
$localCleanup[] = $storedScreenshot['local_path'];
|
|
$objectCleanup[] = $storedScreenshot['object_path'];
|
|
}
|
|
|
|
$publicAssets = $this->derivatives->generatePublicDerivatives($session->tempPath, $hash);
|
|
foreach ($publicAssets as $asset) {
|
|
$objectCleanup[] = $asset['path'];
|
|
}
|
|
|
|
$dimensions = @getimagesize($session->tempPath);
|
|
$width = is_array($dimensions) && isset($dimensions[0]) ? (int) $dimensions[0] : 1;
|
|
$height = is_array($dimensions) && isset($dimensions[1]) ? (int) $dimensions[1] : 1;
|
|
|
|
$primaryOriginal = $archiveOriginal ?? $imageOriginal;
|
|
$downloadFileName = $this->resolveDownloadFileName($primaryOriginal['filename'], $primaryOriginal['ext'], $archiveOriginal ? $archiveOriginalFileName : $originalFileName);
|
|
|
|
DB::transaction(function () use ($artworkId, $imageOriginal, $archiveOriginal, $additionalScreenshotOriginals, $publicAssets, $primaryOriginal, $downloadFileName, $hash, $width, $height) {
|
|
$this->artworkFiles->upsert($artworkId, 'orig', $primaryOriginal['object_path'], $primaryOriginal['mime'], $primaryOriginal['size']);
|
|
$this->artworkFiles->upsert($artworkId, 'orig_image', $imageOriginal['object_path'], $imageOriginal['mime'], $imageOriginal['size']);
|
|
|
|
if ($archiveOriginal) {
|
|
$this->artworkFiles->upsert($artworkId, 'orig_archive', $archiveOriginal['object_path'], $archiveOriginal['mime'], $archiveOriginal['size']);
|
|
} else {
|
|
$this->artworkFiles->deleteVariant($artworkId, 'orig_archive');
|
|
}
|
|
|
|
$this->artworkFiles->deleteScreenshotVariants($artworkId);
|
|
foreach ($additionalScreenshotOriginals as $screenshot) {
|
|
$this->artworkFiles->upsert($artworkId, $screenshot['variant'], $screenshot['object_path'], $screenshot['mime'], $screenshot['size']);
|
|
}
|
|
|
|
foreach ($publicAssets as $variant => $asset) {
|
|
$this->artworkFiles->upsert($artworkId, (string) $variant, $asset['path'], $asset['mime'], $asset['size']);
|
|
}
|
|
|
|
Artwork::query()->whereKey($artworkId)->update([
|
|
'file_name' => $downloadFileName,
|
|
'file_path' => $primaryOriginal['object_path'],
|
|
'file_size' => $primaryOriginal['size'],
|
|
'mime_type' => $primaryOriginal['mime'],
|
|
'hash' => $hash,
|
|
'file_ext' => $primaryOriginal['ext'],
|
|
'thumb_ext' => 'webp',
|
|
'width' => max(1, $width),
|
|
'height' => max(1, $height),
|
|
]);
|
|
});
|
|
|
|
$this->storage->deleteLocalFile($session->tempPath);
|
|
if ($archiveSession) {
|
|
$this->storage->deleteLocalFile($archiveSession->tempPath);
|
|
}
|
|
foreach ($resolvedAdditionalScreenshots as $payload) {
|
|
$this->storage->deleteLocalFile($payload['session']->tempPath);
|
|
}
|
|
|
|
$this->sessions->updateStatus($sessionId, UploadSessionStatus::PROCESSED);
|
|
$this->sessions->updateProgress($sessionId, 100);
|
|
if ($archiveSession) {
|
|
$this->sessions->updateStatus($archiveSession->id, UploadSessionStatus::PROCESSED);
|
|
$this->sessions->updateProgress($archiveSession->id, 100);
|
|
}
|
|
foreach ($resolvedAdditionalScreenshots as $payload) {
|
|
$this->sessions->updateStatus($payload['session']->id, UploadSessionStatus::PROCESSED);
|
|
$this->sessions->updateProgress($payload['session']->id, 100);
|
|
}
|
|
$this->audit->log($session->userId, 'upload_processed', $session->ip, [
|
|
'session_id' => $sessionId,
|
|
'hash' => $hash,
|
|
'artwork_id' => $artworkId,
|
|
'archive_session_id' => $archiveSession?->id,
|
|
'additional_screenshot_session_ids' => $resolvedAdditionalScreenshots->map(fn (array $payload): string => $payload['session']->id)->values()->all(),
|
|
]);
|
|
|
|
return [
|
|
'orig' => $primaryOriginal['object_path'],
|
|
'orig_image' => $imageOriginal['object_path'],
|
|
'orig_archive' => $archiveOriginal['object_path'] ?? null,
|
|
'screenshots' => array_map(static fn (array $screenshot): array => [
|
|
'variant' => $screenshot['variant'],
|
|
'path' => $screenshot['object_path'],
|
|
], $additionalScreenshotOriginals),
|
|
'public' => array_map(static fn (array $asset): string => $asset['path'], $publicAssets),
|
|
];
|
|
} catch (\Throwable $e) {
|
|
foreach ($localCleanup as $path) {
|
|
$this->storage->deleteLocalFile($path);
|
|
}
|
|
|
|
foreach ($objectCleanup as $path) {
|
|
$this->storage->deleteObject($path);
|
|
}
|
|
|
|
throw $e;
|
|
}
|
|
}
|
|
|
|
public function originalHashExists(string $hash): bool
|
|
{
|
|
return Artwork::query()
|
|
->where('hash', $hash)
|
|
->where('artwork_status', 'published')
|
|
->whereNotNull('published_at')
|
|
->exists();
|
|
}
|
|
|
|
private function quarantine(UploadSessionData $session, string $reason): void
|
|
{
|
|
$newPath = $this->storage->moveToSection($session->tempPath, 'quarantine');
|
|
$this->sessions->updateTempPath($session->id, $newPath);
|
|
$this->sessions->updateStatus($session->id, UploadSessionStatus::QUARANTINED);
|
|
$this->sessions->updateFailureReason($session->id, $reason);
|
|
$this->sessions->updateProgress($session->id, 0);
|
|
$this->audit->log($session->userId, 'upload_quarantined', $session->ip, [
|
|
'session_id' => $session->id,
|
|
'reason' => $reason,
|
|
]);
|
|
}
|
|
|
|
private function resolveDownloadFileName(string $storedFilename, string $ext, ?string $preferredFileName): string
|
|
{
|
|
$downloadFileName = $storedFilename;
|
|
|
|
if (is_string($preferredFileName) && trim($preferredFileName) !== '') {
|
|
$candidate = basename(str_replace('\\', '/', $preferredFileName));
|
|
$candidate = preg_replace('/[\x00-\x1F\x7F]/', '', (string) $candidate) ?? '';
|
|
$candidate = trim((string) $candidate);
|
|
|
|
if ($candidate !== '') {
|
|
$candidateExt = strtolower((string) pathinfo($candidate, PATHINFO_EXTENSION));
|
|
if ($candidateExt === '' && $ext !== '') {
|
|
$candidate .= '.' . $ext;
|
|
}
|
|
|
|
$downloadFileName = $candidate;
|
|
}
|
|
}
|
|
|
|
return $downloadFileName;
|
|
}
|
|
|
|
private function screenshotVariantName(int $position): string
|
|
{
|
|
return sprintf('shot%02d', max(1, min(99, $position)));
|
|
}
|
|
}
|