ae9b9160ac
- Served the guest PWA at /g/{token} and introduced a mobile-friendly gallery page with lazy-loaded thumbnails, themed colors, lightbox, and download links plus new gallery data client (resources/js/guest/pages/PublicGalleryPage.tsx:1, resources/js/guest/services/galleryApi.ts:1, resources/js/guest/router.tsx:1). Added i18n strings for the public gallery experience (resources/js/guest/i18n/messages.ts:1).
- Ensured checkout step changes snap back to the progress bar on mobile via smooth scroll anchoring (resources/ js/pages/marketing/checkout/CheckoutWizard.tsx:1).
- Enabled tenant admins to export all approved event photos through a new download action that streams a ZIP archive, with translations and routing in place (app/Http/Controllers/Tenant/EventPhotoArchiveController.php:1, app/Filament/Resources/EventResource.php:1, routes/web.php:1, resources/lang/de/admin.php:1, resources/lang/en/admin.php:1).
1220 lines
45 KiB
PHP
1220 lines
45 KiB
PHP
<?php
|
|
|
|
namespace App\Http\Controllers\Api;
|
|
|
|
use Carbon\Carbon;
|
|
use Carbon\CarbonImmutable;
|
|
use Illuminate\Http\Request;
|
|
use Illuminate\Routing\Controller as BaseController;
|
|
use Illuminate\Support\Facades\DB;
|
|
use Illuminate\Support\Facades\Log;
|
|
use Illuminate\Support\Facades\RateLimiter;
|
|
use Illuminate\Support\Facades\Storage;
|
|
use Illuminate\Support\Str;
|
|
use Symfony\Component\HttpFoundation\Response;
|
|
use App\Support\ImageHelper;
|
|
use App\Services\EventJoinTokenService;
|
|
use App\Services\Storage\EventStorageManager;
|
|
use App\Models\Event;
|
|
use App\Models\EventJoinToken;
|
|
use Illuminate\Http\JsonResponse;
|
|
use Illuminate\Support\Arr;
|
|
use App\Models\Photo;
|
|
use App\Models\EventMediaAsset;
|
|
|
|
class EventPublicController extends BaseController
|
|
{
|
|
public function __construct(
|
|
private readonly EventJoinTokenService $joinTokenService,
|
|
private readonly EventStorageManager $eventStorageManager,
|
|
) {
|
|
}
|
|
|
|
/**
|
|
* @return JsonResponse|array{0: object, 1: EventJoinToken}
|
|
*/
|
|
private function resolvePublishedEvent(Request $request, string $token, array $columns = ['id']): JsonResponse|array
|
|
{
|
|
$rateLimiterKey = sprintf('event:token:%s:%s', $token, $request->ip());
|
|
|
|
$joinToken = $this->joinTokenService->findToken($token, true);
|
|
|
|
if (! $joinToken) {
|
|
return $this->handleTokenFailure($request, $rateLimiterKey, 'invalid_token', Response::HTTP_NOT_FOUND, [
|
|
'token' => Str::limit($token, 12),
|
|
]);
|
|
}
|
|
|
|
if ($joinToken->revoked_at !== null) {
|
|
return $this->handleTokenFailure($request, $rateLimiterKey, 'token_revoked', Response::HTTP_GONE, [
|
|
'token' => Str::limit($token, 12),
|
|
]);
|
|
}
|
|
|
|
if ($joinToken->expires_at !== null) {
|
|
$expiresAt = CarbonImmutable::parse($joinToken->expires_at);
|
|
|
|
if ($expiresAt->isPast()) {
|
|
return $this->handleTokenFailure($request, $rateLimiterKey, 'token_expired', Response::HTTP_GONE, [
|
|
'token' => Str::limit($token, 12),
|
|
'expired_at' => $expiresAt->toAtomString(),
|
|
]);
|
|
}
|
|
}
|
|
|
|
if ($joinToken->usage_limit !== null && $joinToken->usage_count >= $joinToken->usage_limit) {
|
|
return $this->handleTokenFailure($request, $rateLimiterKey, 'token_expired', Response::HTTP_GONE, [
|
|
'token' => Str::limit($token, 12),
|
|
'usage_count' => $joinToken->usage_count,
|
|
'usage_limit' => $joinToken->usage_limit,
|
|
]);
|
|
}
|
|
|
|
$columns = array_unique(array_merge($columns, ['status']));
|
|
|
|
$event = DB::table('events')
|
|
->where('id', $joinToken->event_id)
|
|
->first($columns);
|
|
|
|
if (! $event) {
|
|
return $this->handleTokenFailure($request, $rateLimiterKey, 'invalid_token', Response::HTTP_NOT_FOUND, [
|
|
'token' => Str::limit($token, 12),
|
|
'reason' => 'event_missing',
|
|
]);
|
|
}
|
|
|
|
if (($event->status ?? null) !== 'published') {
|
|
Log::notice('Join token event not public', [
|
|
'token' => Str::limit($token, 12),
|
|
'event_id' => $event->id ?? null,
|
|
'ip' => $request->ip(),
|
|
]);
|
|
|
|
return response()->json([
|
|
'error' => [
|
|
'code' => 'event_not_public',
|
|
'message' => 'This event is not publicly accessible.',
|
|
],
|
|
], Response::HTTP_FORBIDDEN);
|
|
}
|
|
|
|
RateLimiter::clear($rateLimiterKey);
|
|
|
|
if (isset($event->status)) {
|
|
unset($event->status);
|
|
}
|
|
|
|
return [$event, $joinToken];
|
|
}
|
|
|
|
/**
|
|
* @return JsonResponse|array{0: Event, 1: EventJoinToken}
|
|
*/
|
|
private function resolveGalleryEvent(Request $request, string $token): JsonResponse|array
|
|
{
|
|
$result = $this->resolvePublishedEvent($request, $token, ['id']);
|
|
|
|
if ($result instanceof JsonResponse) {
|
|
return $result;
|
|
}
|
|
|
|
[$eventRecord, $joinToken] = $result;
|
|
|
|
$event = Event::with(['tenant', 'eventPackage.package'])->find($eventRecord->id);
|
|
|
|
if (! $event) {
|
|
return response()->json([
|
|
'error' => [
|
|
'code' => 'event_not_found',
|
|
'message' => 'The event associated with this gallery could not be located.',
|
|
],
|
|
], Response::HTTP_NOT_FOUND);
|
|
}
|
|
|
|
$expiresAt = optional($event->eventPackage)->gallery_expires_at;
|
|
|
|
if ($expiresAt instanceof Carbon && $expiresAt->isPast()) {
|
|
return response()->json([
|
|
'error' => [
|
|
'code' => 'gallery_expired',
|
|
'message' => 'The gallery is no longer available for this event.',
|
|
'expired_at' => $expiresAt->toIso8601String(),
|
|
],
|
|
], Response::HTTP_GONE);
|
|
}
|
|
|
|
return [$event, $joinToken];
|
|
}
|
|
|
|
private function handleTokenFailure(Request $request, string $rateLimiterKey, string $code, int $status, array $context = []): JsonResponse
|
|
{
|
|
if (RateLimiter::tooManyAttempts($rateLimiterKey, 10)) {
|
|
Log::warning('Join token rate limit exceeded', array_merge([
|
|
'ip' => $request->ip(),
|
|
], $context));
|
|
|
|
return response()->json([
|
|
'error' => [
|
|
'code' => 'token_rate_limited',
|
|
'message' => 'Too many invalid join token attempts. Try again later.',
|
|
],
|
|
], Response::HTTP_TOO_MANY_REQUESTS);
|
|
}
|
|
|
|
RateLimiter::hit($rateLimiterKey, 300);
|
|
|
|
Log::notice('Join token access denied', array_merge([
|
|
'code' => $code,
|
|
'ip' => $request->ip(),
|
|
], $context));
|
|
|
|
return response()->json([
|
|
'error' => [
|
|
'code' => $code,
|
|
'message' => $this->tokenErrorMessage($code),
|
|
],
|
|
], $status);
|
|
}
|
|
|
|
private function tokenErrorMessage(string $code): string
|
|
{
|
|
return match ($code) {
|
|
'invalid_token' => 'The provided join token is invalid.',
|
|
'token_expired' => 'The join token has expired.',
|
|
'token_revoked' => 'The join token has been revoked.',
|
|
default => 'Access denied.',
|
|
};
|
|
}
|
|
|
|
private function getLocalized($value, $locale, $default = '') {
|
|
if (is_string($value) && json_decode($value) !== null) {
|
|
$data = json_decode($value, true);
|
|
return $data[$locale] ?? $data['de'] ?? $default;
|
|
}
|
|
return $value ?: $default;
|
|
}
|
|
|
|
private function toPublicUrl(?string $path): ?string
|
|
{
|
|
if (! $path) return null;
|
|
// Already absolute URL
|
|
if (str_starts_with($path, 'http://') || str_starts_with($path, 'https://')) return $path;
|
|
// Already a public storage URL
|
|
if (str_starts_with($path, '/storage/')) return $path;
|
|
if (str_starts_with($path, 'storage/')) return '/' . $path;
|
|
|
|
// Common relative paths stored in DB (e.g. 'photos/...', 'thumbnails/...', 'events/...')
|
|
if (str_starts_with($path, 'photos/') || str_starts_with($path, 'thumbnails/') || str_starts_with($path, 'events/')) {
|
|
return Storage::url($path);
|
|
}
|
|
|
|
// Absolute server paths pointing into storage/app/public (Linux/Windows)
|
|
$normalized = str_replace('\\', '/', $path);
|
|
$needle = '/storage/app/public/';
|
|
if (str_contains($normalized, $needle)) {
|
|
$rel = substr($normalized, strpos($normalized, $needle) + strlen($needle));
|
|
return '/storage/' . ltrim($rel, '/');
|
|
}
|
|
|
|
return $path; // fallback as-is
|
|
}
|
|
|
|
private function translateLocalized(string|array|null $value, string $locale, string $fallback = ''): string
|
|
{
|
|
if (is_array($value)) {
|
|
$primary = $value[$locale] ?? $value['de'] ?? $value['en'] ?? null;
|
|
|
|
return $primary ?? (reset($value) ?: $fallback);
|
|
}
|
|
|
|
if (is_string($value) && $value !== '') {
|
|
return $value;
|
|
}
|
|
|
|
return $fallback;
|
|
}
|
|
|
|
private function buildGalleryBranding(Event $event): array
|
|
{
|
|
$defaultPrimary = '#f43f5e';
|
|
$defaultSecondary = '#fb7185';
|
|
$defaultBackground = '#ffffff';
|
|
|
|
$eventBranding = Arr::get($event->settings, 'branding', []);
|
|
$tenantBranding = Arr::get($event->tenant?->settings, 'branding', []);
|
|
|
|
return [
|
|
'primary_color' => Arr::get($eventBranding, 'primary_color')
|
|
?? Arr::get($tenantBranding, 'primary_color')
|
|
?? $defaultPrimary,
|
|
'secondary_color' => Arr::get($eventBranding, 'secondary_color')
|
|
?? Arr::get($tenantBranding, 'secondary_color')
|
|
?? $defaultSecondary,
|
|
'background_color' => Arr::get($eventBranding, 'background_color')
|
|
?? Arr::get($tenantBranding, 'background_color')
|
|
?? $defaultBackground,
|
|
];
|
|
}
|
|
|
|
private function encodeGalleryCursor(Photo $photo): string
|
|
{
|
|
return base64_encode(json_encode([
|
|
'id' => $photo->id,
|
|
'created_at' => $photo->created_at?->toIso8601String(),
|
|
]));
|
|
}
|
|
|
|
private function decodeGalleryCursor(?string $cursor): ?array
|
|
{
|
|
if (! $cursor) {
|
|
return null;
|
|
}
|
|
|
|
$decoded = json_decode(base64_decode($cursor, true) ?: '', true);
|
|
|
|
if (! is_array($decoded) || ! isset($decoded['id'], $decoded['created_at'])) {
|
|
return null;
|
|
}
|
|
|
|
try {
|
|
return [
|
|
'id' => (int) $decoded['id'],
|
|
'created_at' => Carbon::parse($decoded['created_at']),
|
|
];
|
|
} catch (\Throwable $e) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
private function makeGalleryPhotoResource(Photo $photo, string $token): array
|
|
{
|
|
$thumbnail = $this->toPublicUrl($photo->thumbnail_path ?? null) ?? $this->toPublicUrl($photo->file_path ?? null);
|
|
$full = $this->toPublicUrl($photo->file_path ?? null);
|
|
|
|
return [
|
|
'id' => $photo->id,
|
|
'thumbnail_url' => $thumbnail,
|
|
'full_url' => $full,
|
|
'download_url' => route('api.v1.gallery.photos.download', [
|
|
'token' => $token,
|
|
'photo' => $photo->id,
|
|
]),
|
|
'likes_count' => $photo->likes_count,
|
|
'guest_name' => $photo->guest_name,
|
|
'created_at' => $photo->created_at?->toIso8601String(),
|
|
];
|
|
}
|
|
|
|
public function gallery(Request $request, string $token)
|
|
{
|
|
$locale = $request->query('locale', app()->getLocale());
|
|
|
|
$resolved = $this->resolveGalleryEvent($request, $token);
|
|
|
|
if ($resolved instanceof JsonResponse) {
|
|
return $resolved;
|
|
}
|
|
|
|
/** @var array{0: Event, 1: EventJoinToken} $resolved */
|
|
[$event] = $resolved;
|
|
|
|
$branding = $this->buildGalleryBranding($event);
|
|
$expiresAt = optional($event->eventPackage)->gallery_expires_at;
|
|
|
|
return response()->json([
|
|
'event' => [
|
|
'id' => $event->id,
|
|
'name' => $this->translateLocalized($event->name, $locale, 'Fotospiel Event'),
|
|
'slug' => $event->slug,
|
|
'description' => $this->translateLocalized($event->description, $locale, ''),
|
|
'gallery_expires_at' => $expiresAt?->toIso8601String(),
|
|
],
|
|
'branding' => $branding,
|
|
]);
|
|
}
|
|
|
|
public function galleryPhotos(Request $request, string $token)
|
|
{
|
|
$resolved = $this->resolveGalleryEvent($request, $token);
|
|
|
|
if ($resolved instanceof JsonResponse) {
|
|
return $resolved;
|
|
}
|
|
|
|
/** @var array{0: Event, 1: EventJoinToken} $resolved */
|
|
[$event] = $resolved;
|
|
|
|
$limit = (int) $request->query('limit', 30);
|
|
$limit = max(1, min($limit, 60));
|
|
|
|
$cursor = $this->decodeGalleryCursor($request->query('cursor'));
|
|
|
|
$query = Photo::query()
|
|
->where('event_id', $event->id)
|
|
->where('status', 'approved')
|
|
->orderByDesc('created_at')
|
|
->orderByDesc('id');
|
|
|
|
if ($cursor) {
|
|
/** @var Carbon $cursorTime */
|
|
$cursorTime = $cursor['created_at'];
|
|
$cursorId = $cursor['id'];
|
|
|
|
$query->where(function ($inner) use ($cursorTime, $cursorId) {
|
|
$inner->where('created_at', '<', $cursorTime)
|
|
->orWhere(function ($nested) use ($cursorTime, $cursorId) {
|
|
$nested->where('created_at', '=', $cursorTime)
|
|
->where('id', '<', $cursorId);
|
|
});
|
|
});
|
|
}
|
|
|
|
$photos = $query->limit($limit + 1)->get();
|
|
|
|
$hasMore = $photos->count() > $limit;
|
|
$items = $photos->take($limit);
|
|
|
|
$nextCursor = null;
|
|
|
|
if ($hasMore) {
|
|
$cursorPhoto = $photos->slice($limit, 1)->first();
|
|
if ($cursorPhoto instanceof Photo) {
|
|
$nextCursor = $this->encodeGalleryCursor($cursorPhoto);
|
|
}
|
|
}
|
|
|
|
return response()->json([
|
|
'data' => $items->map(fn (Photo $photo) => $this->makeGalleryPhotoResource($photo, $token))->all(),
|
|
'next_cursor' => $nextCursor,
|
|
]);
|
|
}
|
|
|
|
public function galleryPhotoDownload(Request $request, string $token, int $photo)
|
|
{
|
|
$resolved = $this->resolveGalleryEvent($request, $token);
|
|
|
|
if ($resolved instanceof JsonResponse) {
|
|
return $resolved;
|
|
}
|
|
|
|
/** @var array{0: Event, 1: EventJoinToken} $resolved */
|
|
[$event] = $resolved;
|
|
|
|
$record = Photo::with('mediaAsset')
|
|
->where('id', $photo)
|
|
->where('event_id', $event->id)
|
|
->where('status', 'approved')
|
|
->first();
|
|
|
|
if (! $record) {
|
|
return response()->json([
|
|
'error' => [
|
|
'code' => 'photo_not_found',
|
|
'message' => 'The requested photo is no longer available.',
|
|
],
|
|
], Response::HTTP_NOT_FOUND);
|
|
}
|
|
|
|
$asset = $record->mediaAsset ?? EventMediaAsset::where('photo_id', $record->id)->where('variant', 'original')->first();
|
|
|
|
if ($asset) {
|
|
$disk = $asset->disk ?? config('filesystems.default');
|
|
$path = $asset->path ?? $record->file_path;
|
|
|
|
try {
|
|
if ($path && Storage::disk($disk)->exists($path)) {
|
|
$stream = Storage::disk($disk)->readStream($path);
|
|
|
|
if ($stream) {
|
|
$extension = pathinfo($path, PATHINFO_EXTENSION) ?: 'jpg';
|
|
$filename = sprintf('fotospiel-event-%s-photo-%s.%s', $event->id, $record->id, $extension);
|
|
$mime = $asset->mime_type ?? 'image/jpeg';
|
|
|
|
return response()->streamDownload(function () use ($stream) {
|
|
fpassthru($stream);
|
|
fclose($stream);
|
|
}, $filename, [
|
|
'Content-Type' => $mime,
|
|
]);
|
|
}
|
|
}
|
|
} catch (\Throwable $e) {
|
|
Log::warning('Gallery photo download failed', [
|
|
'event_id' => $event->id,
|
|
'photo_id' => $record->id,
|
|
'disk' => $asset->disk ?? null,
|
|
'path' => $asset->path ?? null,
|
|
'error' => $e->getMessage(),
|
|
]);
|
|
}
|
|
}
|
|
|
|
$publicUrl = $this->toPublicUrl($record->file_path ?? null);
|
|
|
|
if ($publicUrl) {
|
|
return redirect()->away($publicUrl);
|
|
}
|
|
|
|
return response()->json([
|
|
'error' => [
|
|
'code' => 'photo_unavailable',
|
|
'message' => 'The requested photo could not be downloaded.',
|
|
],
|
|
], Response::HTTP_NOT_FOUND);
|
|
}
|
|
|
|
public function event(Request $request, string $token)
|
|
{
|
|
$result = $this->resolvePublishedEvent($request, $token, [
|
|
'id',
|
|
'slug',
|
|
'name',
|
|
'default_locale',
|
|
'created_at',
|
|
'updated_at',
|
|
'event_type_id',
|
|
]);
|
|
|
|
if ($result instanceof JsonResponse) {
|
|
return $result;
|
|
}
|
|
|
|
[$event, $joinToken] = $result;
|
|
|
|
$locale = $request->query('locale', $event->default_locale ?? 'de');
|
|
$nameData = json_decode($event->name, true);
|
|
$localizedName = $nameData[$locale] ?? $nameData['de'] ?? $event->name;
|
|
|
|
$eventType = null;
|
|
if ($event->event_type_id) {
|
|
$eventType = DB::table('event_types')
|
|
->where('id', $event->event_type_id)
|
|
->first(['slug as type_slug', 'name as type_name']);
|
|
}
|
|
|
|
$eventTypeData = $eventType ? [
|
|
'slug' => $eventType->type_slug,
|
|
'name' => $this->getLocalized($eventType->type_name, $locale, 'Event'),
|
|
'icon' => $eventType->type_slug === 'wedding' ? 'heart' : 'guests',
|
|
] : [
|
|
'slug' => 'general',
|
|
'name' => $this->getLocalized('Event', $locale, 'Event'),
|
|
'icon' => 'guests',
|
|
];
|
|
|
|
if ($joinToken) {
|
|
$this->joinTokenService->incrementUsage($joinToken);
|
|
}
|
|
|
|
return response()->json([
|
|
'id' => $event->id,
|
|
'slug' => $event->slug,
|
|
'name' => $localizedName,
|
|
'default_locale' => $event->default_locale,
|
|
'created_at' => $event->created_at,
|
|
'updated_at' => $event->updated_at,
|
|
'type' => $eventTypeData,
|
|
'join_token' => $joinToken?->token,
|
|
])->header('Cache-Control', 'no-store');
|
|
}
|
|
|
|
public function stats(Request $request, string $token)
|
|
{
|
|
$result = $this->resolvePublishedEvent($request, $token, ['id']);
|
|
|
|
if ($result instanceof JsonResponse) {
|
|
return $result;
|
|
}
|
|
|
|
[$event] = $result;
|
|
$eventId = $event->id;
|
|
$eventModel = Event::with('storageAssignments.storageTarget')->findOrFail($eventId);
|
|
|
|
// Approximate online guests as distinct recent uploaders in last 10 minutes.
|
|
$tenMinutesAgo = CarbonImmutable::now()->subMinutes(10);
|
|
$onlineGuests = DB::table('photos')
|
|
->where('event_id', $eventId)
|
|
->where('created_at', '>=', $tenMinutesAgo)
|
|
->distinct('guest_name')
|
|
->count('guest_name');
|
|
|
|
// Tasks solved as number of photos linked to a task (proxy metric).
|
|
$tasksSolved = DB::table('photos')->where('event_id', $eventId)->whereNotNull('task_id')->count();
|
|
|
|
$latestPhotoAt = DB::table('photos')->where('event_id', $eventId)->max('created_at');
|
|
|
|
$payload = [
|
|
'online_guests' => $onlineGuests,
|
|
'tasks_solved' => $tasksSolved,
|
|
'latest_photo_at' => $latestPhotoAt,
|
|
];
|
|
|
|
$etag = sha1(json_encode($payload));
|
|
$reqEtag = $request->headers->get('If-None-Match');
|
|
if ($reqEtag && $reqEtag === $etag) {
|
|
return response('', 304);
|
|
}
|
|
|
|
return response()->json($payload)
|
|
->header('Cache-Control', 'no-store')
|
|
->header('ETag', $etag);
|
|
}
|
|
|
|
public function emotions(Request $request, string $token)
|
|
{
|
|
$result = $this->resolvePublishedEvent($request, $token, ['id']);
|
|
|
|
if ($result instanceof JsonResponse) {
|
|
return $result;
|
|
}
|
|
|
|
[$event] = $result;
|
|
$eventId = $event->id;
|
|
$locale = $request->query('locale', 'de');
|
|
|
|
$rows = DB::table('emotions')
|
|
->join('emotion_event_type', 'emotions.id', '=', 'emotion_event_type.emotion_id')
|
|
->join('event_types', 'emotion_event_type.event_type_id', '=', 'event_types.id')
|
|
->join('events', 'events.event_type_id', '=', 'event_types.id')
|
|
->where('events.id', $eventId)
|
|
->select([
|
|
'emotions.id',
|
|
'emotions.name',
|
|
'emotions.icon as emoji',
|
|
'emotions.description'
|
|
])
|
|
->orderBy('emotions.sort_order')
|
|
->get();
|
|
|
|
$payload = $rows->map(function ($r) use ($locale) {
|
|
$nameData = json_decode($r->name, true);
|
|
$name = $nameData[$locale] ?? $nameData['de'] ?? $r->name;
|
|
|
|
$descriptionData = json_decode($r->description, true);
|
|
$description = $descriptionData ? ($descriptionData[$locale] ?? $descriptionData['de'] ?? '') : '';
|
|
|
|
return [
|
|
'id' => (int) $r->id,
|
|
'slug' => 'emotion-' . $r->id, // Generate slug from ID
|
|
'name' => $name,
|
|
'emoji' => $r->emoji,
|
|
'description' => $description,
|
|
];
|
|
});
|
|
|
|
$etag = sha1($payload->toJson());
|
|
$reqEtag = $request->headers->get('If-None-Match');
|
|
if ($reqEtag && $reqEtag === $etag) {
|
|
return response('', 304);
|
|
}
|
|
|
|
return response()->json($payload)
|
|
->header('Cache-Control', 'public, max-age=300')
|
|
->header('ETag', $etag);
|
|
}
|
|
|
|
public function tasks(Request $request, string $token)
|
|
{
|
|
$result = $this->resolvePublishedEvent($request, $token, ['id']);
|
|
|
|
if ($result instanceof JsonResponse) {
|
|
return $result;
|
|
}
|
|
|
|
[$event] = $result;
|
|
$eventId = $event->id;
|
|
|
|
$query = DB::table('tasks')
|
|
->join('task_collection_task', 'tasks.id', '=', 'task_collection_task.task_id')
|
|
->join('event_task_collection', 'task_collection_task.task_collection_id', '=', 'event_task_collection.task_collection_id')
|
|
->where('event_task_collection.event_id', $eventId)
|
|
->select([
|
|
'tasks.id',
|
|
'tasks.title',
|
|
'tasks.description',
|
|
'tasks.example_text as instructions',
|
|
'tasks.emotion_id',
|
|
'tasks.sort_order'
|
|
])
|
|
->orderBy('event_task_collection.sort_order')
|
|
->orderBy('tasks.sort_order')
|
|
->limit(20);
|
|
|
|
$rows = $query->get();
|
|
$locale = $request->query('locale', 'de');
|
|
|
|
$payload = $rows->map(function ($r) use ($locale) {
|
|
// Handle JSON fields for multilingual content
|
|
$getLocalized = function ($field, $default = '') use ($r, $locale) {
|
|
$value = $r->$field;
|
|
if (is_string($value) && json_decode($value) !== null) {
|
|
$data = json_decode($value, true);
|
|
return $data[$locale] ?? $data['de'] ?? $default;
|
|
}
|
|
return $value ?: $default;
|
|
};
|
|
|
|
// Get emotion info if emotion_id exists
|
|
$emotion = null;
|
|
if ($r->emotion_id) {
|
|
$emotionRow = DB::table('emotions')->where('id', $r->emotion_id)->first(['name']);
|
|
if ($emotionRow && isset($emotionRow->name)) {
|
|
$value = $emotionRow->name;
|
|
if (is_string($value) && json_decode($value) !== null) {
|
|
$data = json_decode($value, true);
|
|
$emotionName = $data[$locale] ?? $data['de'] ?? 'Unbekannte Emotion';
|
|
} else {
|
|
$emotionName = $value ?: 'Unbekannte Emotion';
|
|
}
|
|
$emotion = [
|
|
'slug' => 'emotion-' . $r->emotion_id, // Generate slug from ID
|
|
'name' => $emotionName,
|
|
];
|
|
}
|
|
}
|
|
|
|
return [
|
|
'id' => (int) $r->id,
|
|
'title' => $getLocalized('title', 'Unbenannte Aufgabe'),
|
|
'description' => $getLocalized('description', ''),
|
|
'instructions' => $getLocalized('instructions', ''),
|
|
'duration' => 3, // Default 3 minutes (no duration field in DB)
|
|
'is_completed' => false, // Default false (no is_completed field in DB)
|
|
'emotion' => $emotion,
|
|
];
|
|
});
|
|
|
|
// If no tasks found, return empty array instead of 404
|
|
if ($payload->isEmpty()) {
|
|
$payload = collect([]);
|
|
}
|
|
|
|
$etag = sha1($payload->toJson());
|
|
$reqEtag = $request->headers->get('If-None-Match');
|
|
if ($reqEtag && $reqEtag === $etag) {
|
|
return response('', 304);
|
|
}
|
|
|
|
return response()->json($payload)
|
|
->header('Cache-Control', 'public, max-age=300')
|
|
->header('ETag', $etag);
|
|
}
|
|
|
|
public function photos(Request $request, string $token)
|
|
{
|
|
$result = $this->resolvePublishedEvent($request, $token, ['id']);
|
|
|
|
if ($result instanceof JsonResponse) {
|
|
return $result;
|
|
}
|
|
|
|
[$event] = $result;
|
|
$eventId = $event->id;
|
|
|
|
$deviceId = (string) $request->header('X-Device-Id', 'anon');
|
|
$filter = $request->query('filter');
|
|
|
|
$since = $request->query('since');
|
|
$query = DB::table('photos')
|
|
->leftJoin('tasks', 'photos.task_id', '=', 'tasks.id')
|
|
->select([
|
|
'photos.id',
|
|
'photos.file_path',
|
|
'photos.thumbnail_path',
|
|
'photos.likes_count',
|
|
'photos.emotion_id',
|
|
'photos.task_id',
|
|
'photos.guest_name',
|
|
'tasks.title as task_title'
|
|
])
|
|
->where('photos.event_id', $eventId)
|
|
->orderByDesc('photos.created_at')
|
|
->limit(60);
|
|
|
|
// MyPhotos filter
|
|
if ($filter === 'myphotos' && $deviceId !== 'anon') {
|
|
$query->where('guest_name', $deviceId);
|
|
}
|
|
|
|
if ($since) {
|
|
$query->where('photos.created_at', '>', $since);
|
|
}
|
|
$locale = $request->query('locale', 'de');
|
|
|
|
$rows = $query->get()->map(function ($r) use ($locale) {
|
|
$r->file_path = $this->toPublicUrl((string)($r->file_path ?? ''));
|
|
$r->thumbnail_path = $this->toPublicUrl((string)($r->thumbnail_path ?? ''));
|
|
|
|
// Localize task title if present
|
|
if ($r->task_title) {
|
|
$r->task_title = $this->getLocalized($r->task_title, $locale, 'Unbenannte Aufgabe');
|
|
}
|
|
|
|
return $r;
|
|
});
|
|
$latestPhotoAt = DB::table('photos')->where('event_id', $eventId)->max('created_at');
|
|
$payload = [
|
|
'data' => $rows,
|
|
'latest_photo_at' => $latestPhotoAt,
|
|
];
|
|
$etag = sha1(json_encode([$since, $filter, $deviceId, $latestPhotoAt]));
|
|
$reqEtag = $request->headers->get('If-None-Match');
|
|
if ($reqEtag && $reqEtag === $etag) {
|
|
return response('', 304);
|
|
}
|
|
return response()->json($payload)
|
|
->header('Cache-Control', 'no-store')
|
|
->header('ETag', $etag)
|
|
->header('Last-Modified', (string)$latestPhotoAt);
|
|
}
|
|
|
|
public function photo(int $id)
|
|
{
|
|
$row = DB::table('photos')
|
|
->join('events', 'photos.event_id', '=', 'events.id')
|
|
->leftJoin('tasks', 'photos.task_id', '=', 'tasks.id')
|
|
->select([
|
|
'photos.id',
|
|
'photos.event_id',
|
|
'photos.file_path',
|
|
'photos.thumbnail_path',
|
|
'photos.likes_count',
|
|
'photos.emotion_id',
|
|
'photos.task_id',
|
|
'photos.created_at',
|
|
'tasks.title as task_title'
|
|
])
|
|
->where('photos.id', $id)
|
|
->where('events.status', 'published')
|
|
->first();
|
|
if (! $row) {
|
|
return response()->json(['error' => ['code' => 'not_found', 'message' => 'Photo not found or event not public']], 404);
|
|
}
|
|
$row->file_path = $this->toPublicUrl((string)($row->file_path ?? ''));
|
|
$row->thumbnail_path = $this->toPublicUrl((string)($row->thumbnail_path ?? ''));
|
|
|
|
// Localize task title if present
|
|
$locale = request()->query('locale', 'de');
|
|
if ($row->task_title) {
|
|
$row->task_title = $this->getLocalized($row->task_title, $locale, 'Unbenannte Aufgabe');
|
|
}
|
|
|
|
return response()->json($row)->header('Cache-Control', 'no-store');
|
|
}
|
|
|
|
public function like(Request $request, int $id)
|
|
{
|
|
$deviceId = (string) $request->header('X-Device-Id', 'anon');
|
|
$deviceId = substr(preg_replace('/[^a-zA-Z0-9_-]/', '', $deviceId), 0, 64);
|
|
if ($deviceId === '') {
|
|
$deviceId = 'anon';
|
|
}
|
|
|
|
$photo = DB::table('photos')
|
|
->join('events', 'photos.event_id', '=', 'events.id')
|
|
->where('photos.id', $id)
|
|
->where('events.status', 'published')
|
|
->first(['photos.id', 'photos.event_id']);
|
|
if (! $photo) {
|
|
return response()->json(['error' => ['code' => 'not_found', 'message' => 'Photo not found or event not public']], 404);
|
|
}
|
|
|
|
// Idempotent like per device
|
|
$exists = DB::table('photo_likes')->where('photo_id', $id)->where('guest_name', $deviceId)->exists();
|
|
if ($exists) {
|
|
$count = (int) DB::table('photos')->where('id', $id)->value('likes_count');
|
|
return response()->json(['liked' => true, 'likes_count' => $count]);
|
|
}
|
|
|
|
DB::beginTransaction();
|
|
try {
|
|
DB::table('photo_likes')->insert([
|
|
'photo_id' => $id,
|
|
'guest_name' => $deviceId,
|
|
'ip_address' => 'device',
|
|
'created_at' => now(),
|
|
]);
|
|
DB::table('photos')->where('id', $id)->update([
|
|
'likes_count' => DB::raw('likes_count + 1'),
|
|
'updated_at' => now(),
|
|
]);
|
|
DB::commit();
|
|
} catch (\Throwable $e) {
|
|
DB::rollBack();
|
|
Log::warning('like failed', ['error' => $e->getMessage()]);
|
|
}
|
|
|
|
$count = (int) DB::table('photos')->where('id', $id)->value('likes_count');
|
|
|
|
return response()->json(['liked' => true, 'likes_count' => $count]);
|
|
}
|
|
|
|
public function upload(Request $request, string $token)
|
|
{
|
|
$result = $this->resolvePublishedEvent($request, $token, ['id']);
|
|
|
|
if ($result instanceof JsonResponse) {
|
|
return $result;
|
|
}
|
|
|
|
[$event] = $result;
|
|
$eventId = $event->id;
|
|
|
|
$deviceId = (string) $request->header('X-Device-Id', 'anon');
|
|
$deviceId = substr(preg_replace('/[^a-zA-Z0-9_-]/', '', $deviceId), 0, 64) ?: 'anon';
|
|
|
|
// Per-device cap per event (MVP: 50)
|
|
$deviceCount = DB::table('photos')->where('event_id', $eventId)->where('guest_name', $deviceId)->count();
|
|
if ($deviceCount >= 50) {
|
|
return response()->json(['error' => ['code' => 'limit_reached', 'message' => 'Upload-Limit erreicht']], 429);
|
|
}
|
|
|
|
$validated = $request->validate([
|
|
'photo' => ['required', 'image', 'max:6144'], // 6 MB
|
|
'emotion_id' => ['nullable', 'integer'],
|
|
'emotion_slug' => ['nullable', 'string'],
|
|
'task_id' => ['nullable', 'integer'],
|
|
'guest_name' => ['nullable', 'string', 'max:255'],
|
|
]);
|
|
|
|
$file = $validated['photo'];
|
|
$disk = $this->eventStorageManager->getHotDiskForEvent($eventModel);
|
|
$path = Storage::disk($disk)->putFile("events/{$eventId}/photos", $file);
|
|
$url = $this->resolveDiskUrl($disk, $path);
|
|
|
|
// Generate thumbnail (JPEG) under photos/thumbs
|
|
$baseName = pathinfo($path, PATHINFO_FILENAME);
|
|
$thumbRel = "events/{$eventId}/photos/thumbs/{$baseName}_thumb.jpg";
|
|
$thumbPath = ImageHelper::makeThumbnailOnDisk($disk, $path, $thumbRel, 640, 82);
|
|
$thumbUrl = $thumbPath
|
|
? $this->resolveDiskUrl($disk, $thumbPath)
|
|
: $url;
|
|
|
|
$photoId = DB::table('photos')->insertGetId([
|
|
'event_id' => $eventId,
|
|
'task_id' => $validated['task_id'] ?? null,
|
|
'guest_name' => $validated['guest_name'] ?? $deviceId,
|
|
'file_path' => $url,
|
|
'thumbnail_path' => $thumbUrl,
|
|
'likes_count' => 0,
|
|
|
|
// Handle emotion_id: prefer explicit ID, fallback to slug lookup, then default
|
|
'emotion_id' => $this->resolveEmotionId($validated, $eventId),
|
|
'is_featured' => 0,
|
|
'metadata' => null,
|
|
'created_at' => now(),
|
|
'updated_at' => now(),
|
|
]);
|
|
|
|
$asset = $this->eventStorageManager->recordAsset($eventModel, $disk, $path, [
|
|
'variant' => 'original',
|
|
'mime_type' => $file->getClientMimeType(),
|
|
'size_bytes' => $file->getSize(),
|
|
'checksum' => hash_file('sha256', $file->getRealPath()),
|
|
'status' => 'hot',
|
|
'processed_at' => now(),
|
|
'photo_id' => $photoId,
|
|
]);
|
|
|
|
if ($thumbPath) {
|
|
$this->eventStorageManager->recordAsset($eventModel, $disk, $thumbPath, [
|
|
'variant' => 'thumbnail',
|
|
'mime_type' => 'image/jpeg',
|
|
'status' => 'hot',
|
|
'processed_at' => now(),
|
|
'photo_id' => $photoId,
|
|
'size_bytes' => Storage::disk($disk)->exists($thumbPath)
|
|
? Storage::disk($disk)->size($thumbPath)
|
|
: null,
|
|
'meta' => [
|
|
'source_variant_id' => $asset->id,
|
|
],
|
|
]);
|
|
}
|
|
|
|
DB::table('photos')
|
|
->where('id', $photoId)
|
|
->update(['media_asset_id' => $asset->id]);
|
|
|
|
return response()->json([
|
|
'id' => $photoId,
|
|
'file_path' => $url,
|
|
'thumbnail_path' => $thumbUrl,
|
|
], 201);
|
|
}
|
|
|
|
/**
|
|
* Resolve emotion_id from validation data, supporting both direct ID and slug lookup
|
|
*/
|
|
private function resolveEmotionId(array $validated, int $eventId): int
|
|
{
|
|
// 1. Use explicit emotion_id if provided
|
|
if (isset($validated['emotion_id']) && $validated['emotion_id'] !== null) {
|
|
return (int) $validated['emotion_id'];
|
|
}
|
|
|
|
// 2. Resolve from emotion_slug if provided (format: 'emotion-{id}')
|
|
if (isset($validated['emotion_slug']) && $validated['emotion_slug']) {
|
|
$slug = $validated['emotion_slug'];
|
|
if (str_starts_with($slug, 'emotion-')) {
|
|
$id = (int) substr($slug, 8); // Remove 'emotion-' prefix
|
|
if ($id > 0) {
|
|
// Verify emotion exists and is available for this event
|
|
$exists = DB::table('emotions')
|
|
->join('emotion_event_type', 'emotions.id', '=', 'emotion_event_type.emotion_id')
|
|
->join('events', 'emotion_event_type.event_type_id', '=', 'events.event_type_id')
|
|
->where('emotions.id', $id)
|
|
->where('events.id', $eventId)
|
|
->exists();
|
|
|
|
if ($exists) {
|
|
return $id;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// 3. Fallback: Get first available emotion for this event type
|
|
$defaultEmotion = DB::table('emotions')
|
|
->join('emotion_event_type', 'emotions.id', '=', 'emotion_event_type.emotion_id')
|
|
->join('events', 'emotion_event_type.event_type_id', '=', 'events.event_type_id')
|
|
->where('events.id', $eventId)
|
|
->orderBy('emotions.sort_order')
|
|
->value('emotions.id');
|
|
|
|
return $defaultEmotion ?: 1; // Ultimate fallback to emotion ID 1 (assuming "Happy" exists)
|
|
}
|
|
public function achievements(Request $request, string $identifier)
|
|
{
|
|
$result = $this->resolvePublishedEvent($request, $identifier, ['id']);
|
|
|
|
if ($result instanceof JsonResponse) {
|
|
return $result;
|
|
}
|
|
|
|
[$event] = $result;
|
|
$eventId = $event->id;
|
|
$locale = $request->query('locale', 'de');
|
|
|
|
$totalPhotos = (int) DB::table('photos')->where('event_id', $eventId)->count();
|
|
$uniqueGuests = (int) DB::table('photos')->where('event_id', $eventId)->distinct('guest_name')->count('guest_name');
|
|
$tasksSolved = (int) DB::table('photos')->where('event_id', $eventId)->whereNotNull('task_id')->count();
|
|
$likesTotal = (int) DB::table('photos')->where('event_id', $eventId)->sum('likes_count');
|
|
|
|
$summary = [
|
|
'total_photos' => $totalPhotos,
|
|
'unique_guests' => $uniqueGuests,
|
|
'tasks_solved' => $tasksSolved,
|
|
'likes_total' => $likesTotal,
|
|
];
|
|
|
|
$guestNameParam = trim((string) $request->query('guest_name', ''));
|
|
$deviceIdHeader = (string) $request->headers->get('X-Device-Id', '');
|
|
$deviceId = substr(preg_replace('/[^A-Za-z0-9 _\-]/', '', $deviceIdHeader), 0, 120);
|
|
$candidate = $guestNameParam !== '' ? $guestNameParam : $deviceId;
|
|
$guestIdentifier = $candidate !== '' ? substr(preg_replace('/[^A-Za-z0-9 _\-]/', '', $candidate), 0, 120) : null;
|
|
|
|
$personal = null;
|
|
if ($guestIdentifier) {
|
|
$personalPhotos = (int) DB::table('photos')
|
|
->where('event_id', $eventId)
|
|
->where('guest_name', $guestIdentifier)
|
|
->count();
|
|
|
|
$personalTasks = (int) DB::table('photos')
|
|
->where('event_id', $eventId)
|
|
->where('guest_name', $guestIdentifier)
|
|
->whereNotNull('task_id')
|
|
->distinct('task_id')
|
|
->count('task_id');
|
|
|
|
$personalLikes = (int) DB::table('photos')
|
|
->where('event_id', $eventId)
|
|
->where('guest_name', $guestIdentifier)
|
|
->sum('likes_count');
|
|
|
|
$badgeBlueprints = [
|
|
['id' => 'first_photo', 'title' => 'Erstes Foto', 'description' => 'Lade dein erstes Foto hoch.', 'target' => 1, 'metric' => 'photos'],
|
|
['id' => 'five_photos', 'title' => 'Fotoflair', 'description' => 'Fuenf Fotos hochgeladen.', 'target' => 5, 'metric' => 'photos'],
|
|
['id' => 'first_task', 'title' => 'Aufgabenstarter', 'description' => 'Erste Aufgabe erfuellt.', 'target' => 1, 'metric' => 'tasks'],
|
|
['id' => 'task_master', 'title' => 'Aufgabenmeister', 'description' => 'Fuenf Aufgaben erfuellt.', 'target' => 5, 'metric' => 'tasks'],
|
|
['id' => 'crowd_pleaser', 'title' => 'Publikumsliebling', 'description' => 'Sammle zwanzig Likes.', 'target' => 20, 'metric' => 'likes'],
|
|
];
|
|
|
|
$personalBadges = [];
|
|
foreach ($badgeBlueprints as $badge) {
|
|
$value = 0;
|
|
if ($badge['metric'] === 'photos') {
|
|
$value = $personalPhotos;
|
|
} elseif ($badge['metric'] === 'tasks') {
|
|
$value = $personalTasks;
|
|
} else {
|
|
$value = $personalLikes;
|
|
}
|
|
|
|
$personalBadges[] = [
|
|
'id' => $badge['id'],
|
|
'title' => $badge['title'],
|
|
'description' => $badge['description'],
|
|
'earned' => $value >= $badge['target'],
|
|
'progress' => $value,
|
|
'target' => $badge['target'],
|
|
];
|
|
}
|
|
|
|
$personal = [
|
|
'guest_name' => $guestIdentifier,
|
|
'photos' => $personalPhotos,
|
|
'tasks' => $personalTasks,
|
|
'likes' => $personalLikes,
|
|
'badges' => $personalBadges,
|
|
];
|
|
}
|
|
|
|
$topUploads = DB::table('photos')
|
|
->select('guest_name', DB::raw('COUNT(*) as total'), DB::raw('SUM(likes_count) as likes'))
|
|
->where('event_id', $eventId)
|
|
->groupBy('guest_name')
|
|
->orderByDesc('total')
|
|
->limit(5)
|
|
->get()
|
|
->map(fn ($row) => [
|
|
'guest' => $row->guest_name,
|
|
'photos' => (int) $row->total,
|
|
'likes' => (int) $row->likes,
|
|
])
|
|
->values();
|
|
|
|
$topLikes = DB::table('photos')
|
|
->select('guest_name', DB::raw('SUM(likes_count) as likes'), DB::raw('COUNT(*) as total'))
|
|
->where('event_id', $eventId)
|
|
->groupBy('guest_name')
|
|
->orderByDesc('likes')
|
|
->limit(5)
|
|
->get()
|
|
->map(fn ($row) => [
|
|
'guest' => $row->guest_name,
|
|
'likes' => (int) $row->likes,
|
|
'photos' => (int) $row->total,
|
|
])
|
|
->values();
|
|
|
|
$topPhotoRow = DB::table('photos')
|
|
->leftJoin('tasks', 'photos.task_id', '=', 'tasks.id')
|
|
->where('photos.event_id', $eventId)
|
|
->orderByDesc('photos.likes_count')
|
|
->orderByDesc('photos.created_at')
|
|
->select([
|
|
'photos.id',
|
|
'photos.guest_name',
|
|
'photos.likes_count',
|
|
'photos.file_path',
|
|
'photos.thumbnail_path',
|
|
'photos.created_at',
|
|
'tasks.title as task_title',
|
|
])
|
|
->first();
|
|
|
|
$topPhoto = $topPhotoRow ? [
|
|
'photo_id' => (int) $topPhotoRow->id,
|
|
'guest' => $topPhotoRow->guest_name,
|
|
'likes' => (int) $topPhotoRow->likes_count,
|
|
'task' => $topPhotoRow->task_title,
|
|
'created_at' => $topPhotoRow->created_at,
|
|
'thumbnail' => $this->toPublicUrl($topPhotoRow->thumbnail_path ?: $topPhotoRow->file_path),
|
|
] : null;
|
|
|
|
$trendingEmotionRow = DB::table('photos')
|
|
->join('emotions', 'photos.emotion_id', '=', 'emotions.id')
|
|
->where('photos.event_id', $eventId)
|
|
->select('emotions.id', 'emotions.name', DB::raw('COUNT(*) as total'))
|
|
->groupBy('emotions.id', 'emotions.name')
|
|
->orderByDesc('total')
|
|
->first();
|
|
|
|
$trendingEmotion = $trendingEmotionRow ? [
|
|
'emotion_id' => (int) $trendingEmotionRow->id,
|
|
'name' => $this->getLocalized($trendingEmotionRow->name, $locale, $trendingEmotionRow->name),
|
|
'count' => (int) $trendingEmotionRow->total,
|
|
] : null;
|
|
|
|
$timeline = DB::table('photos')
|
|
->where('event_id', $eventId)
|
|
->selectRaw('DATE(created_at) as day, COUNT(*) as photos, COUNT(DISTINCT guest_name) as guests')
|
|
->groupBy('day')
|
|
->orderBy('day')
|
|
->limit(14)
|
|
->get()
|
|
->map(fn ($row) => [
|
|
'date' => $row->day,
|
|
'photos' => (int) $row->photos,
|
|
'guests' => (int) $row->guests,
|
|
])
|
|
->values();
|
|
|
|
$feed = DB::table('photos')
|
|
->leftJoin('tasks', 'photos.task_id', '=', 'tasks.id')
|
|
->where('photos.event_id', $eventId)
|
|
->orderByDesc('photos.created_at')
|
|
->limit(12)
|
|
->get([
|
|
'photos.id',
|
|
'photos.guest_name',
|
|
'photos.thumbnail_path',
|
|
'photos.file_path',
|
|
'photos.likes_count',
|
|
'photos.created_at',
|
|
'tasks.title as task_title',
|
|
])
|
|
->map(fn ($row) => [
|
|
'photo_id' => (int) $row->id,
|
|
'guest' => $row->guest_name,
|
|
'task' => $row->task_title,
|
|
'likes' => (int) $row->likes_count,
|
|
'created_at' => $row->created_at,
|
|
'thumbnail' => $this->toPublicUrl($row->thumbnail_path ?: $row->file_path),
|
|
])
|
|
->values();
|
|
|
|
$payload = [
|
|
'summary' => $summary,
|
|
'personal' => $personal,
|
|
'leaderboards' => [
|
|
'uploads' => $topUploads,
|
|
'likes' => $topLikes,
|
|
],
|
|
'highlights' => [
|
|
'top_photo' => $topPhoto,
|
|
'trending_emotion' => $trendingEmotion,
|
|
'timeline' => $timeline,
|
|
],
|
|
'feed' => $feed,
|
|
];
|
|
|
|
$etag = sha1(json_encode($payload));
|
|
$ifNoneMatch = $request->headers->get('If-None-Match');
|
|
if ($ifNoneMatch && $ifNoneMatch === $etag) {
|
|
return response('', 304);
|
|
}
|
|
|
|
return response()->json($payload)
|
|
->header('Cache-Control', 'no-store')
|
|
->header('ETag', $etag);
|
|
}
|
|
}
|
|
|
|
private function resolveDiskUrl(string $disk, string $path): string
|
|
{
|
|
try {
|
|
return Storage::disk($disk)->url($path);
|
|
} catch (\Throwable $e) {
|
|
Log::debug('Falling back to raw path for storage URL', [
|
|
'disk' => $disk,
|
|
'path' => $path,
|
|
'error' => $e->getMessage(),
|
|
]);
|
|
|
|
return $path;
|
|
}
|
|
}
|