521 lines
18 KiB
PHP
521 lines
18 KiB
PHP
<?php
|
|
|
|
namespace App\Services\AiEditing;
|
|
|
|
use App\Models\AiEditRequest;
|
|
use App\Models\Event;
|
|
use App\Services\Storage\EventStorageManager;
|
|
use App\Support\ImageHelper;
|
|
use App\Support\WatermarkConfigResolver;
|
|
use Illuminate\Support\Arr;
|
|
use Illuminate\Support\Facades\Http;
|
|
use Illuminate\Support\Facades\Log;
|
|
use Illuminate\Support\Facades\Storage;
|
|
use Illuminate\Support\Str;
|
|
use RuntimeException;
|
|
use Throwable;
|
|
|
|
class AiEditOutputStorageService
|
|
{
|
|
public function __construct(private readonly EventStorageManager $eventStorageManager) {}
|
|
|
|
/**
|
|
* @param array<string, mixed> $output
|
|
* @return array{
|
|
* provider_url: ?string,
|
|
* provider_asset_id: ?string,
|
|
* storage_disk: ?string,
|
|
* storage_path: ?string,
|
|
* mime_type: ?string,
|
|
* width: ?int,
|
|
* height: ?int,
|
|
* bytes: ?int,
|
|
* checksum: ?string,
|
|
* metadata: array<string, mixed>
|
|
* }
|
|
*/
|
|
public function persist(AiEditRequest $request, array $output): array
|
|
{
|
|
$normalized = $this->normalizeOutput($output);
|
|
|
|
if (! $this->outputsEnabled()) {
|
|
return $normalized;
|
|
}
|
|
|
|
$providerUrl = $normalized['provider_url'];
|
|
if (! is_string($providerUrl) || trim($providerUrl) === '') {
|
|
return $normalized;
|
|
}
|
|
|
|
$event = Event::query()
|
|
->with([
|
|
'tenant',
|
|
'eventPackage.package',
|
|
'eventPackages.package',
|
|
'storageAssignments.storageTarget',
|
|
])
|
|
->find($request->event_id);
|
|
|
|
if (! $event) {
|
|
return $this->withStorageFailure(
|
|
$normalized,
|
|
'event_not_found',
|
|
'Could not resolve event while persisting AI output.'
|
|
);
|
|
}
|
|
|
|
try {
|
|
$download = $this->downloadImage($providerUrl);
|
|
$persisted = $this->storeLocally($request, $event, $download);
|
|
|
|
return array_merge($normalized, $persisted);
|
|
} catch (Throwable $exception) {
|
|
Log::warning('AI output local persistence failed', [
|
|
'request_id' => $request->id,
|
|
'event_id' => $request->event_id,
|
|
'provider' => $request->provider,
|
|
'provider_url' => $providerUrl,
|
|
'error' => $exception->getMessage(),
|
|
]);
|
|
|
|
return $this->withStorageFailure(
|
|
$normalized,
|
|
'output_storage_failed',
|
|
$exception->getMessage()
|
|
);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @return array{
|
|
* binary: string,
|
|
* mime_type: string,
|
|
* width: int,
|
|
* height: int,
|
|
* bytes: int,
|
|
* extension: string
|
|
* }
|
|
*/
|
|
private function downloadImage(string $url): array
|
|
{
|
|
$this->assertSourceUrlAllowed($url);
|
|
|
|
$response = Http::accept('*/*')
|
|
->connectTimeout(max(1, (int) config('ai-editing.outputs.connect_timeout_seconds', 10)))
|
|
->timeout(max(1, (int) config('ai-editing.outputs.timeout_seconds', 60)))
|
|
->withHeaders([
|
|
'User-Agent' => (string) config('ai-editing.outputs.user_agent', 'fotospiel-ai-output-fetcher/1.0'),
|
|
])
|
|
->get($url);
|
|
|
|
if (! $response->successful()) {
|
|
throw new RuntimeException(sprintf(
|
|
'Provider output download returned HTTP %d.',
|
|
$response->status()
|
|
));
|
|
}
|
|
|
|
$maxBytes = max(1024, (int) config('ai-editing.outputs.max_download_bytes', 15 * 1024 * 1024));
|
|
$contentLength = (int) ($response->header('Content-Length') ?: 0);
|
|
if ($contentLength > $maxBytes) {
|
|
throw new RuntimeException(sprintf(
|
|
'Provider output exceeds maximum allowed size (%d bytes).',
|
|
$maxBytes
|
|
));
|
|
}
|
|
|
|
$binary = $response->body();
|
|
if (! is_string($binary) || $binary === '') {
|
|
throw new RuntimeException('Provider output is empty.');
|
|
}
|
|
|
|
$bytes = strlen($binary);
|
|
if ($bytes > $maxBytes) {
|
|
throw new RuntimeException(sprintf(
|
|
'Downloaded output exceeds maximum allowed size (%d bytes).',
|
|
$maxBytes
|
|
));
|
|
}
|
|
|
|
$imageInfo = @getimagesizefromstring($binary);
|
|
if (! is_array($imageInfo)) {
|
|
throw new RuntimeException('Provider output is not a valid image.');
|
|
}
|
|
|
|
$mimeType = $this->normalizeMimeType(
|
|
$imageInfo['mime'] ?? $response->header('Content-Type')
|
|
);
|
|
if (! str_starts_with($mimeType, 'image/')) {
|
|
throw new RuntimeException('Provider output did not return an image mime type.');
|
|
}
|
|
|
|
return [
|
|
'binary' => $binary,
|
|
'mime_type' => $mimeType,
|
|
'width' => (int) ($imageInfo[0] ?? 0),
|
|
'height' => (int) ($imageInfo[1] ?? 0),
|
|
'bytes' => $bytes,
|
|
'extension' => $this->extensionForMimeType($mimeType, $url),
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @param array{
|
|
* binary: string,
|
|
* mime_type: string,
|
|
* width: int,
|
|
* height: int,
|
|
* bytes: int,
|
|
* extension: string
|
|
* } $download
|
|
* @return array{
|
|
* storage_disk: ?string,
|
|
* storage_path: ?string,
|
|
* mime_type: ?string,
|
|
* width: ?int,
|
|
* height: ?int,
|
|
* bytes: ?int,
|
|
* checksum: ?string,
|
|
* metadata: array<string, mixed>
|
|
* }
|
|
*/
|
|
private function storeLocally(AiEditRequest $request, Event $event, array $download): array
|
|
{
|
|
$disk = $this->eventStorageManager->getHotDiskForEvent($event);
|
|
$eventSlug = trim((string) ($event->slug ?? ''));
|
|
if ($eventSlug === '') {
|
|
$eventSlug = 'event-'.$event->id;
|
|
}
|
|
|
|
$baseName = Str::uuid()->toString();
|
|
$baseDirectory = sprintf('events/%s/ai-edits/%d', $eventSlug, $request->id);
|
|
$originalPath = sprintf('%s/original/%s.%s', $baseDirectory, $baseName, $download['extension']);
|
|
Storage::disk($disk)->put($originalPath, $download['binary']);
|
|
|
|
$thumbnailPath = sprintf('%s/thumbnails/%s_thumb.jpg', $baseDirectory, $baseName);
|
|
$thumbnailRelative = ImageHelper::makeThumbnailOnDisk($disk, $originalPath, $thumbnailPath, 640, 82);
|
|
|
|
$watermarkConfig = WatermarkConfigResolver::resolve($event);
|
|
$finalPath = $originalPath;
|
|
$finalThumbnailPath = $thumbnailRelative;
|
|
$watermarkApplied = false;
|
|
|
|
if ($this->shouldApplyWatermark($watermarkConfig)) {
|
|
$watermarkedPath = sprintf('%s/watermarked/%s.%s', $baseDirectory, $baseName, $download['extension']);
|
|
$resolvedWatermarkedPath = ImageHelper::copyWithWatermark($disk, $originalPath, $watermarkedPath, $watermarkConfig);
|
|
if (is_string($resolvedWatermarkedPath) && $resolvedWatermarkedPath !== '') {
|
|
$finalPath = $resolvedWatermarkedPath;
|
|
$watermarkApplied = true;
|
|
}
|
|
|
|
if ($thumbnailRelative) {
|
|
$watermarkedThumbPath = sprintf('%s/watermarked/%s_thumb.jpg', $baseDirectory, $baseName);
|
|
$resolvedWatermarkedThumbPath = ImageHelper::copyWithWatermark($disk, $thumbnailRelative, $watermarkedThumbPath, $watermarkConfig);
|
|
if (is_string($resolvedWatermarkedThumbPath) && $resolvedWatermarkedThumbPath !== '') {
|
|
$finalThumbnailPath = $resolvedWatermarkedThumbPath;
|
|
}
|
|
}
|
|
}
|
|
|
|
$finalBinary = Storage::disk($disk)->get($finalPath);
|
|
$finalImageInfo = is_string($finalBinary) ? @getimagesizefromstring($finalBinary) : false;
|
|
$finalMimeType = is_array($finalImageInfo)
|
|
? $this->normalizeMimeType($finalImageInfo['mime'] ?? $download['mime_type'])
|
|
: $download['mime_type'];
|
|
$finalWidth = is_array($finalImageInfo) ? (int) ($finalImageInfo[0] ?? 0) : $download['width'];
|
|
$finalHeight = is_array($finalImageInfo) ? (int) ($finalImageInfo[1] ?? 0) : $download['height'];
|
|
$finalBytes = Storage::disk($disk)->exists($finalPath)
|
|
? (int) Storage::disk($disk)->size($finalPath)
|
|
: $download['bytes'];
|
|
$checksum = is_string($finalBinary) && $finalBinary !== ''
|
|
? hash('sha256', $finalBinary)
|
|
: null;
|
|
|
|
$metadata = [
|
|
'storage' => [
|
|
'original_path' => $originalPath,
|
|
'thumbnail_path' => $thumbnailRelative,
|
|
'watermarked_path' => $watermarkApplied ? $finalPath : null,
|
|
'watermarked_thumbnail_path' => $finalThumbnailPath !== $thumbnailRelative ? $finalThumbnailPath : null,
|
|
'watermark_applied' => $watermarkApplied,
|
|
'stored_at' => now()->toIso8601String(),
|
|
],
|
|
];
|
|
|
|
$this->recordAssetSafely($event, $disk, $originalPath, [
|
|
'variant' => 'ai_original',
|
|
'mime_type' => $download['mime_type'],
|
|
'size_bytes' => $download['bytes'],
|
|
'status' => 'hot',
|
|
'processed_at' => now(),
|
|
'photo_id' => $request->photo_id,
|
|
'meta' => ['ai_request_id' => $request->id],
|
|
]);
|
|
|
|
if ($finalPath !== $originalPath) {
|
|
$this->recordAssetSafely($event, $disk, $finalPath, [
|
|
'variant' => 'ai_watermarked',
|
|
'mime_type' => $finalMimeType,
|
|
'size_bytes' => $finalBytes,
|
|
'checksum' => $checksum,
|
|
'status' => 'hot',
|
|
'processed_at' => now(),
|
|
'photo_id' => $request->photo_id,
|
|
'meta' => ['ai_request_id' => $request->id],
|
|
]);
|
|
}
|
|
|
|
if ($thumbnailRelative) {
|
|
$this->recordAssetSafely($event, $disk, $thumbnailRelative, [
|
|
'variant' => 'ai_thumbnail',
|
|
'mime_type' => 'image/jpeg',
|
|
'size_bytes' => Storage::disk($disk)->exists($thumbnailRelative)
|
|
? (int) Storage::disk($disk)->size($thumbnailRelative)
|
|
: null,
|
|
'status' => 'hot',
|
|
'processed_at' => now(),
|
|
'photo_id' => $request->photo_id,
|
|
'meta' => ['ai_request_id' => $request->id],
|
|
]);
|
|
}
|
|
|
|
if ($finalThumbnailPath && $finalThumbnailPath !== $thumbnailRelative) {
|
|
$this->recordAssetSafely($event, $disk, $finalThumbnailPath, [
|
|
'variant' => 'ai_watermarked_thumbnail',
|
|
'mime_type' => 'image/jpeg',
|
|
'size_bytes' => Storage::disk($disk)->exists($finalThumbnailPath)
|
|
? (int) Storage::disk($disk)->size($finalThumbnailPath)
|
|
: null,
|
|
'status' => 'hot',
|
|
'processed_at' => now(),
|
|
'photo_id' => $request->photo_id,
|
|
'meta' => ['ai_request_id' => $request->id],
|
|
]);
|
|
}
|
|
|
|
return [
|
|
'storage_disk' => $disk,
|
|
'storage_path' => $finalPath,
|
|
'mime_type' => $finalMimeType,
|
|
'width' => $finalWidth > 0 ? $finalWidth : null,
|
|
'height' => $finalHeight > 0 ? $finalHeight : null,
|
|
'bytes' => $finalBytes > 0 ? $finalBytes : null,
|
|
'checksum' => $checksum,
|
|
'metadata' => $metadata,
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @param array<string, mixed> $attributes
|
|
*/
|
|
private function recordAssetSafely(Event $event, string $disk, string $path, array $attributes): void
|
|
{
|
|
try {
|
|
$this->eventStorageManager->recordAsset($event, $disk, $path, $attributes);
|
|
} catch (Throwable $exception) {
|
|
Log::warning('AI output asset metadata recording failed', [
|
|
'event_id' => $event->id,
|
|
'disk' => $disk,
|
|
'path' => $path,
|
|
'error' => $exception->getMessage(),
|
|
]);
|
|
}
|
|
}
|
|
|
|
private function shouldApplyWatermark(array $watermarkConfig): bool
|
|
{
|
|
return ($watermarkConfig['type'] ?? 'none') !== 'none'
|
|
&& trim((string) ($watermarkConfig['asset'] ?? '')) !== ''
|
|
&& ! (bool) ($watermarkConfig['serve_originals'] ?? false);
|
|
}
|
|
|
|
private function outputsEnabled(): bool
|
|
{
|
|
return (bool) config('ai-editing.outputs.enabled', true);
|
|
}
|
|
|
|
private function assertSourceUrlAllowed(string $url): void
|
|
{
|
|
$parsed = parse_url($url);
|
|
if (! is_array($parsed)) {
|
|
throw new RuntimeException('Provider output URL is invalid.');
|
|
}
|
|
|
|
$scheme = strtolower((string) ($parsed['scheme'] ?? ''));
|
|
if (! in_array($scheme, ['http', 'https'], true)) {
|
|
throw new RuntimeException('Provider output URL scheme is not allowed.');
|
|
}
|
|
|
|
$host = strtolower((string) ($parsed['host'] ?? ''));
|
|
if ($host === '') {
|
|
throw new RuntimeException('Provider output URL host is missing.');
|
|
}
|
|
|
|
if (
|
|
$host === 'localhost'
|
|
|| str_ends_with($host, '.local')
|
|
|| str_ends_with($host, '.internal')
|
|
|| str_ends_with($host, '.invalid')
|
|
|| str_ends_with($host, '.test')
|
|
) {
|
|
throw new RuntimeException('Provider output URL host is blocked.');
|
|
}
|
|
|
|
if (filter_var($host, FILTER_VALIDATE_IP) !== false) {
|
|
$isPublicIp = filter_var(
|
|
$host,
|
|
FILTER_VALIDATE_IP,
|
|
FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE
|
|
) !== false;
|
|
|
|
if (! $isPublicIp) {
|
|
throw new RuntimeException('Provider output URL host is not publicly routable.');
|
|
}
|
|
}
|
|
|
|
$allowedHosts = array_values(array_filter(array_map(
|
|
static fn (mixed $value): string => strtolower(trim((string) $value)),
|
|
(array) config('ai-editing.outputs.allowed_hosts', [])
|
|
)));
|
|
|
|
if ($allowedHosts === []) {
|
|
return;
|
|
}
|
|
|
|
foreach ($allowedHosts as $allowedHost) {
|
|
if ($allowedHost === '') {
|
|
continue;
|
|
}
|
|
|
|
if ($host === $allowedHost || str_ends_with($host, '.'.$allowedHost)) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
throw new RuntimeException('Provider output URL host is not in allowed host list.');
|
|
}
|
|
|
|
/**
|
|
* @param array<string, mixed> $output
|
|
* @return array{
|
|
* provider_url: ?string,
|
|
* provider_asset_id: ?string,
|
|
* storage_disk: ?string,
|
|
* storage_path: ?string,
|
|
* mime_type: ?string,
|
|
* width: ?int,
|
|
* height: ?int,
|
|
* bytes: ?int,
|
|
* checksum: ?string,
|
|
* metadata: array<string, mixed>
|
|
* }
|
|
*/
|
|
private function normalizeOutput(array $output): array
|
|
{
|
|
return [
|
|
'provider_url' => $this->normalizeOptionalString((string) Arr::get($output, 'provider_url', '')),
|
|
'provider_asset_id' => $this->normalizeOptionalString((string) Arr::get($output, 'provider_asset_id', '')),
|
|
'storage_disk' => $this->normalizeOptionalString((string) Arr::get($output, 'storage_disk', '')),
|
|
'storage_path' => $this->normalizeOptionalString((string) Arr::get($output, 'storage_path', '')),
|
|
'mime_type' => $this->normalizeOptionalString((string) Arr::get($output, 'mime_type', '')),
|
|
'width' => is_numeric(Arr::get($output, 'width')) ? (int) Arr::get($output, 'width') : null,
|
|
'height' => is_numeric(Arr::get($output, 'height')) ? (int) Arr::get($output, 'height') : null,
|
|
'bytes' => is_numeric(Arr::get($output, 'bytes')) ? (int) Arr::get($output, 'bytes') : null,
|
|
'checksum' => $this->normalizeOptionalString((string) Arr::get($output, 'checksum', '')),
|
|
'metadata' => is_array(Arr::get($output, 'metadata')) ? (array) Arr::get($output, 'metadata') : [],
|
|
];
|
|
}
|
|
|
|
private function normalizeOptionalString(?string $value): ?string
|
|
{
|
|
if ($value === null) {
|
|
return null;
|
|
}
|
|
|
|
$trimmed = trim($value);
|
|
|
|
return $trimmed !== '' ? $trimmed : null;
|
|
}
|
|
|
|
private function normalizeMimeType(?string $value): string
|
|
{
|
|
$mimeType = strtolower(trim((string) $value));
|
|
|
|
if ($mimeType === '') {
|
|
return 'image/jpeg';
|
|
}
|
|
|
|
$parts = explode(';', $mimeType);
|
|
|
|
return trim((string) $parts[0]) !== '' ? trim((string) $parts[0]) : 'image/jpeg';
|
|
}
|
|
|
|
private function extensionForMimeType(string $mimeType, string $url): string
|
|
{
|
|
$map = [
|
|
'image/jpeg' => 'jpg',
|
|
'image/png' => 'png',
|
|
'image/webp' => 'webp',
|
|
'image/gif' => 'gif',
|
|
'image/heic' => 'heic',
|
|
'image/heif' => 'heif',
|
|
];
|
|
|
|
if (array_key_exists($mimeType, $map)) {
|
|
return $map[$mimeType];
|
|
}
|
|
|
|
$path = (string) parse_url($url, PHP_URL_PATH);
|
|
$extension = strtolower(pathinfo($path, PATHINFO_EXTENSION));
|
|
if ($extension !== '') {
|
|
return $extension;
|
|
}
|
|
|
|
return 'jpg';
|
|
}
|
|
|
|
/**
|
|
* @param array{
|
|
* provider_url: ?string,
|
|
* provider_asset_id: ?string,
|
|
* storage_disk: ?string,
|
|
* storage_path: ?string,
|
|
* mime_type: ?string,
|
|
* width: ?int,
|
|
* height: ?int,
|
|
* bytes: ?int,
|
|
* checksum: ?string,
|
|
* metadata: array<string, mixed>
|
|
* } $output
|
|
* @return array{
|
|
* provider_url: ?string,
|
|
* provider_asset_id: ?string,
|
|
* storage_disk: ?string,
|
|
* storage_path: ?string,
|
|
* mime_type: ?string,
|
|
* width: ?int,
|
|
* height: ?int,
|
|
* bytes: ?int,
|
|
* checksum: ?string,
|
|
* metadata: array<string, mixed>
|
|
* }
|
|
*/
|
|
private function withStorageFailure(array $output, string $code, string $message): array
|
|
{
|
|
$metadata = $output['metadata'];
|
|
$metadata['storage'] = array_merge(
|
|
is_array($metadata['storage'] ?? null) ? $metadata['storage'] : [],
|
|
[
|
|
'failed' => true,
|
|
'error_code' => $code,
|
|
'error_message' => Str::limit($message, 500, ''),
|
|
'failed_at' => now()->toIso8601String(),
|
|
]
|
|
);
|
|
|
|
$output['metadata'] = $metadata;
|
|
|
|
return $output;
|
|
}
|
|
}
|