366 lines
12 KiB
PHP
366 lines
12 KiB
PHP
<?php
|
|
|
|
declare(strict_types=1);
|
|
|
|
namespace App\Services\Enhance;
|
|
|
|
use App\Models\Artwork;
|
|
use App\Models\EnhanceJob;
|
|
use App\Models\User;
|
|
use App\Services\ArtworkOriginalFileLocator;
|
|
use Illuminate\Http\UploadedFile;
|
|
use Illuminate\Support\Facades\Log;
|
|
use Illuminate\Support\Facades\Storage;
|
|
use Illuminate\Support\Str;
|
|
use Intervention\Image\Drivers\Gd\Driver as GdDriver;
|
|
use Intervention\Image\Drivers\Imagick\Driver as ImagickDriver;
|
|
use Intervention\Image\Encoders\WebpEncoder;
|
|
use Intervention\Image\ImageManager;
|
|
use RuntimeException;
|
|
|
|
final class EnhanceStorageService
|
|
{
|
|
private ?ImageManager $manager = null;
|
|
|
|
public function __construct(
|
|
private readonly ArtworkOriginalFileLocator $artworkOriginalFileLocator,
|
|
) {
|
|
try {
|
|
$this->manager = extension_loaded('gd')
|
|
? new ImageManager(new GdDriver())
|
|
: new ImageManager(new ImagickDriver());
|
|
} catch (\Throwable) {
|
|
$this->manager = null;
|
|
}
|
|
}
|
|
|
|
public function diskName(): string
|
|
{
|
|
return (string) config('enhance.disk', 'public');
|
|
}
|
|
|
|
public function fetchSourceBinary(EnhanceJob $job): string
|
|
{
|
|
$path = trim((string) $job->source_path);
|
|
|
|
if ($path === '') {
|
|
throw new RuntimeException('Enhance source image is missing.');
|
|
}
|
|
|
|
$contents = Storage::disk($job->source_disk ?: $this->diskName())->get($path);
|
|
|
|
if (! is_string($contents) || $contents === '') {
|
|
throw new RuntimeException('Unable to read enhance source image.');
|
|
}
|
|
|
|
return $contents;
|
|
}
|
|
|
|
public function fetchArtworkSource(Artwork $artwork): array
|
|
{
|
|
$objectPath = $this->artworkOriginalFileLocator->resolveObjectPath($artwork);
|
|
|
|
if ($objectPath === '') {
|
|
throw new RuntimeException('Artwork source file is unavailable for enhance.');
|
|
}
|
|
|
|
$disk = (string) config('uploads.object_storage.disk', 's3');
|
|
$contents = Storage::disk($disk)->get($objectPath);
|
|
|
|
if (! is_string($contents) || $contents === '') {
|
|
throw new RuntimeException('Unable to read the original artwork source.');
|
|
}
|
|
|
|
$extension = strtolower(ltrim((string) ($artwork->file_ext ?? pathinfo($objectPath, PATHINFO_EXTENSION)), '.'));
|
|
$mime = trim(strtolower((string) ($artwork->mime_type ?? '')));
|
|
|
|
if ($mime === '') {
|
|
$finfo = new \finfo(FILEINFO_MIME_TYPE);
|
|
$mime = strtolower((string) $finfo->buffer($contents));
|
|
}
|
|
|
|
return [
|
|
'disk' => $disk,
|
|
'path' => $objectPath,
|
|
'binary' => $contents,
|
|
'mime' => $mime,
|
|
'extension' => $extension !== '' ? $extension : $this->extensionFromMime($mime),
|
|
];
|
|
}
|
|
|
|
public function storeUploadedSource(User $user, UploadedFile $file): array
|
|
{
|
|
$path = (string) ($file->getRealPath() ?: $file->getPathname());
|
|
|
|
if ($path === '' || ! is_readable($path)) {
|
|
throw new RuntimeException('Unable to resolve uploaded source path.');
|
|
}
|
|
|
|
$binary = file_get_contents($path);
|
|
|
|
if (! is_string($binary) || $binary === '') {
|
|
throw new RuntimeException('Unable to read uploaded source image.');
|
|
}
|
|
|
|
$extension = strtolower(ltrim((string) ($file->getClientOriginalExtension() ?: $file->extension()), '.'));
|
|
|
|
return $this->storeSourceBinary($user, $binary, $extension !== '' ? $extension : 'bin');
|
|
}
|
|
|
|
public function storeSourceBinary(User $user, string $binary, string $extension): array
|
|
{
|
|
$finfo = new \finfo(FILEINFO_MIME_TYPE);
|
|
$mime = strtolower((string) $finfo->buffer($binary));
|
|
$normalizedExtension = $extension !== '' ? $extension : $this->extensionFromMime($mime);
|
|
$relativePath = $this->buildPath((string) config('enhance.source_prefix', 'enhance/sources'), (int) $user->id, sprintf('%s.%s', Str::uuid()->toString(), $normalizedExtension));
|
|
|
|
$this->writeBinary($this->diskName(), $relativePath, $binary, $mime);
|
|
|
|
return [
|
|
'source_disk' => $this->diskName(),
|
|
'source_path' => $relativePath,
|
|
'source_hash' => hash('sha256', $binary),
|
|
];
|
|
}
|
|
|
|
public function putOutputBinary(EnhanceJob $job, string $binary, string $mime, ?string $extension = null): array
|
|
{
|
|
$normalizedMime = strtolower(trim($mime));
|
|
$ext = $extension !== null && $extension !== '' ? strtolower(ltrim($extension, '.')) : $this->extensionFromMime($normalizedMime);
|
|
$filename = sprintf('%s_x%d.%s', Str::uuid()->toString(), (int) $job->scale, $ext);
|
|
$relativePath = $this->buildPath((string) config('enhance.output_prefix', 'enhance/outputs'), (int) $job->user_id, $filename);
|
|
|
|
$this->writeBinary($this->diskName(), $relativePath, $binary, $normalizedMime);
|
|
$dimensions = @getimagesizefromstring($binary) ?: [0, 0];
|
|
|
|
return [
|
|
'disk' => $this->diskName(),
|
|
'path' => $relativePath,
|
|
'hash' => hash('sha256', $binary),
|
|
'width' => (int) ($dimensions[0] ?? 0),
|
|
'height' => (int) ($dimensions[1] ?? 0),
|
|
'filesize' => strlen($binary),
|
|
'mime' => $normalizedMime,
|
|
];
|
|
}
|
|
|
|
public function storePreviewFromBinary(EnhanceJob $job, string $binary): ?array
|
|
{
|
|
$previewBinary = $binary;
|
|
$previewMime = 'image/webp';
|
|
|
|
if ($this->manager !== null) {
|
|
try {
|
|
$previewBinary = (string) $this->manager
|
|
->read($binary)
|
|
->scaleDown(width: 1600, height: 1600)
|
|
->encode(new WebpEncoder(82));
|
|
} catch (\Throwable) {
|
|
$previewMime = strtolower((string) ((new \finfo(FILEINFO_MIME_TYPE))->buffer($binary) ?: 'image/jpeg'));
|
|
$previewBinary = $binary;
|
|
}
|
|
} else {
|
|
$previewMime = strtolower((string) ((new \finfo(FILEINFO_MIME_TYPE))->buffer($binary) ?: 'image/jpeg'));
|
|
}
|
|
|
|
$extension = $this->extensionFromMime($previewMime);
|
|
$relativePath = $this->buildPath(
|
|
(string) config('enhance.preview_prefix', 'enhance/previews'),
|
|
(int) $job->user_id,
|
|
sprintf('%s_preview.%s', Str::uuid()->toString(), $extension),
|
|
);
|
|
|
|
$this->writeBinary($this->diskName(), $relativePath, $previewBinary, $previewMime);
|
|
|
|
return [
|
|
'preview_disk' => $this->diskName(),
|
|
'preview_path' => $relativePath,
|
|
];
|
|
}
|
|
|
|
public function createPreviewFromStoredOutput(EnhanceJob $job, string $disk, string $path): ?array
|
|
{
|
|
$contents = Storage::disk($disk)->get($path);
|
|
|
|
if (! is_string($contents) || $contents === '') {
|
|
return null;
|
|
}
|
|
|
|
return $this->storePreviewFromBinary($job, $contents);
|
|
}
|
|
|
|
public function deleteFiles(EnhanceJob $job): void
|
|
{
|
|
$this->deleteFilesForJob($job);
|
|
}
|
|
|
|
public function deleteGeneratedFiles(EnhanceJob $job): void
|
|
{
|
|
foreach ([
|
|
[$job->output_disk, $job->output_path],
|
|
[$job->preview_disk, $job->preview_path],
|
|
] as [$disk, $path]) {
|
|
$this->safeDelete($disk, $path);
|
|
}
|
|
}
|
|
|
|
public function deleteFilesForJob(EnhanceJob $job): array
|
|
{
|
|
$result = [
|
|
'deleted' => [
|
|
'source' => false,
|
|
'output' => false,
|
|
'preview' => false,
|
|
],
|
|
'skipped' => [],
|
|
'errors' => [],
|
|
];
|
|
|
|
foreach ([
|
|
'source' => [$job->source_disk, $job->source_path],
|
|
'output' => [$job->output_disk, $job->output_path],
|
|
'preview' => [$job->preview_disk, $job->preview_path],
|
|
] as $key => [$disk, $path]) {
|
|
try {
|
|
$deleted = $this->safeDelete($disk, $path);
|
|
$result['deleted'][$key] = $deleted;
|
|
|
|
if (! $deleted && trim((string) $path) !== '') {
|
|
$result['skipped'][] = $key;
|
|
}
|
|
} catch (\Throwable $exception) {
|
|
$result['errors'][$key] = $exception->getMessage();
|
|
|
|
Log::warning('enhance.cleanup.file_delete_failed', [
|
|
'path' => trim((string) $path),
|
|
'disk' => $disk ?: $this->diskName(),
|
|
'message' => $exception->getMessage(),
|
|
]);
|
|
}
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
public function isEnhancePath(?string $path): bool
|
|
{
|
|
$trimmedPath = ltrim(trim((string) $path), '/');
|
|
|
|
if ($trimmedPath === '') {
|
|
return false;
|
|
}
|
|
|
|
foreach ($this->enhancePrefixes() as $prefix) {
|
|
if ($trimmedPath === $prefix || str_starts_with($trimmedPath, $prefix . '/')) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public function safeDelete(?string $disk, ?string $path): bool
|
|
{
|
|
$trimmedPath = ltrim(trim((string) $path), '/');
|
|
|
|
if ($trimmedPath === '') {
|
|
return false;
|
|
}
|
|
|
|
if (! $this->isEnhancePath($trimmedPath)) {
|
|
Log::warning('enhance.cleanup.file_skipped', [
|
|
'path' => $trimmedPath,
|
|
'disk' => $disk ?: $this->diskName(),
|
|
'reason' => 'outside-enhance-prefixes',
|
|
]);
|
|
|
|
return false;
|
|
}
|
|
|
|
$targetDisk = $disk ?: $this->diskName();
|
|
|
|
if (! Storage::disk($targetDisk)->exists($trimmedPath)) {
|
|
return false;
|
|
}
|
|
|
|
$deleted = Storage::disk($targetDisk)->delete($trimmedPath);
|
|
|
|
if ($deleted) {
|
|
Log::info('enhance.cleanup.file_deleted', [
|
|
'path' => $trimmedPath,
|
|
'disk' => $targetDisk,
|
|
]);
|
|
|
|
return true;
|
|
}
|
|
|
|
Log::warning('enhance.cleanup.file_delete_failed', [
|
|
'path' => $trimmedPath,
|
|
'disk' => $targetDisk,
|
|
'message' => 'Storage delete returned false.',
|
|
]);
|
|
|
|
return false;
|
|
}
|
|
|
|
public function listKnownJobPaths(): array
|
|
{
|
|
return EnhanceJob::withTrashed()
|
|
->get(['source_path', 'output_path', 'preview_path'])
|
|
->flatMap(fn (EnhanceJob $job): array => array_values(array_filter([
|
|
ltrim(trim((string) $job->source_path), '/'),
|
|
ltrim(trim((string) $job->output_path), '/'),
|
|
ltrim(trim((string) $job->preview_path), '/'),
|
|
])))
|
|
->unique()
|
|
->values()
|
|
->all();
|
|
}
|
|
|
|
private function buildPath(string $prefix, int $userId, string $filename): string
|
|
{
|
|
return sprintf(
|
|
'%s/%d/%s/%s/%s',
|
|
trim($prefix, '/'),
|
|
$userId,
|
|
now()->format('Y'),
|
|
now()->format('m'),
|
|
ltrim($filename, '/'),
|
|
);
|
|
}
|
|
|
|
private function enhancePrefixes(): array
|
|
{
|
|
return array_values(array_filter(array_unique(array_map(
|
|
static fn (string $prefix): string => trim($prefix, '/'),
|
|
[
|
|
(string) config('enhance.source_prefix', 'enhance/sources'),
|
|
(string) config('enhance.output_prefix', 'enhance/outputs'),
|
|
(string) config('enhance.preview_prefix', 'enhance/previews'),
|
|
],
|
|
))));
|
|
}
|
|
|
|
private function extensionFromMime(string $mime): string
|
|
{
|
|
return match ($mime) {
|
|
'image/jpeg' => 'jpg',
|
|
'image/png' => 'png',
|
|
'image/webp' => 'webp',
|
|
default => 'bin',
|
|
};
|
|
}
|
|
|
|
private function writeBinary(string $disk, string $path, string $binary, string $mime): void
|
|
{
|
|
$written = Storage::disk($disk)->put($path, $binary, [
|
|
'visibility' => 'public',
|
|
'CacheControl' => 'public, max-age=31536000, immutable',
|
|
'ContentType' => $mime,
|
|
]);
|
|
|
|
if ($written !== true) {
|
|
throw new RuntimeException('Unable to store enhance image in storage.');
|
|
}
|
|
}
|
|
} |