APP als Hybrid Version - Anbindung an API

backend/app/Http/Controllers/Api/AuthController.php

@@ -0,0 +1,54 @@
+<?php
+
+namespace App\Http\Controllers\Api;
+
+use App\Http\Controllers\Controller;
+use App\Http\Requests\LoginRequest;
+use App\Models\User;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Hash;
+use Illuminate\Validation\ValidationException;
+
+class AuthController extends Controller
+{
+    public function login(LoginRequest $request): JsonResponse
+    {
+        $credentials = $request->validated();
+        $user = User::query()
+            ->where('email', $credentials['email'])
+            ->first();
+
+        if (! $user || ! Hash::check($credentials['password'], $user->password)) {
+            throw ValidationException::withMessages([
+                'email' => __('auth.failed'),
+            ]);
+        }
+
+        $token = $user->createToken('quasar-app')->accessToken;
+
+        return response()->json([
+            'token' => $token,
+            'tokenType' => 'Bearer',
+            'user' => [
+                'id' => (string) $user->id,
+                'name' => $user->name,
+                'email' => $user->email,
+                'avatar' => $this->avatarFor($user),
+                'mode' => 'remote',
+            ],
+        ]);
+    }
+
+    public function logout(Request $request): JsonResponse
+    {
+        $request->user()?->token()?->revoke();
+
+        return response()->json(null, 204);
+    }
+
+    private function avatarFor(User $user): string
+    {
+        return substr(strtoupper($user->initials()), 0, 3);
+    }
+}

backend/app/Http/Controllers/Api/EventController.php

@@ -18,7 +18,7 @@ class EventController extends Controller
      */
     public function index(Request $request): AnonymousResourceCollection
     {
-        $query = $request->user()->events()->orderBy('date');
+        $query = $request->user()->events()->with('media')->orderBy('date');
 
         // Delta sync: only events updated since a given timestamp
         if ($request->has('since')) {
@@ -50,7 +50,7 @@ class EventController extends Controller
             'note' => $request->validated('note'),
         ]);
 
-        return (new EventResource($event))
+        return (new EventResource($event->load('media')))
             ->response()
             ->setStatusCode(201);
     }
@@ -64,7 +64,7 @@ class EventController extends Controller
             ->where('client_id', $clientId)
             ->firstOrFail();
 
-        return new EventResource($event);
+        return new EventResource($event->load('media'));
     }
 
     /**
@@ -103,7 +103,7 @@ class EventController extends Controller
 
         $event->update($data);
 
-        return new EventResource($event->fresh());
+        return new EventResource($event->fresh()->load('media'));
     }
 
     /**

backend/app/Http/Controllers/Api/EventMediaController.php

@@ -0,0 +1,138 @@
+<?php
+
+namespace App\Http\Controllers\Api;
+
+use App\Http\Controllers\Controller;
+use App\Http\Requests\StoreEventMediaRequest;
+use App\Http\Resources\EventMediaResource;
+use App\Models\EventMedia;
+use App\Services\EventMediaImageProcessor;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+use Illuminate\Http\Response;
+use Illuminate\Support\Facades\Storage;
+
+class EventMediaController extends Controller
+{
+    public function index(Request $request, string $clientId): JsonResponse
+    {
+        $event = $request->user()->events()
+            ->where('client_id', $clientId)
+            ->firstOrFail();
+
+        return response()->json([
+            'data' => EventMediaResource::collection(
+                $event->media()->orderBy('created_at')->get()
+            ),
+        ]);
+    }
+
+    public function store(
+        StoreEventMediaRequest $request,
+        EventMediaImageProcessor $processor,
+        string $clientId
+    ): JsonResponse {
+        $event = $request->user()->events()
+            ->where('client_id', $clientId)
+            ->firstOrFail();
+
+        $collection = $request->validated('collection') ?? 'gallery';
+        $processed = $processor->process($request->file('file'));
+        $uuid = (string) str()->uuid();
+        $directory = "event-media/{$request->user()->id}/{$event->client_id}";
+        $path = "{$directory}/{$uuid}.jpg";
+        $previewPath = "{$directory}/{$uuid}_preview.jpg";
+        $thumbnailPath = "{$directory}/{$uuid}_thumb.jpg";
+
+        Storage::disk('local')->put($path, $processed['original']);
+        Storage::disk('local')->put($previewPath, $processed['preview']);
+        Storage::disk('local')->put($thumbnailPath, $processed['thumbnail']);
+
+        if ($collection === 'key_image') {
+            $this->deleteExistingKeyImages($event->media()->where('collection', 'key_image')->get());
+        }
+
+        $media = $event->media()->create([
+            'uuid' => $uuid,
+            'user_id' => $request->user()->id,
+            'collection' => $collection,
+            'name' => $request->file('file')->getClientOriginalName(),
+            'mime_type' => $processed['mime_type'],
+            'disk' => 'local',
+            'path' => $path,
+            'thumbnail_path' => $thumbnailPath,
+            'preview_path' => $previewPath,
+            'size' => $processed['size'],
+            'width' => $processed['width'],
+            'height' => $processed['height'],
+            'thumbnail_width' => $processed['thumbnail_width'],
+            'thumbnail_height' => $processed['thumbnail_height'],
+            'preview_width' => $processed['preview_width'],
+            'preview_height' => $processed['preview_height'],
+        ]);
+
+        if ($collection === 'key_image') {
+            $event->update(['image' => "/event-media/{$media->id}/thumb"]);
+        }
+
+        return (new EventMediaResource($media))
+            ->response()
+            ->setStatusCode(201);
+    }
+
+    public function show(Request $request, EventMedia $media, string $variant): Response
+    {
+        abort_unless(in_array($variant, ['thumb', 'preview', 'original'], true), 404);
+        abort_unless((int) $media->user_id === (int) $request->user()->id, 404);
+
+        $path = match ($variant) {
+            'thumb' => $media->thumbnail_path,
+            'preview' => $media->preview_path ?: $media->thumbnail_path,
+            default => $media->path,
+        };
+
+        abort_unless(is_string($path) && $path !== '', 404);
+        abort_unless(Storage::disk($media->disk)->exists($path), 404);
+
+        return response(Storage::disk($media->disk)->get($path), 200, [
+            'Content-Type' => 'image/jpeg',
+            'Cache-Control' => 'private, max-age=604800',
+        ]);
+    }
+
+    public function destroy(Request $request, string $clientId, EventMedia $media): JsonResponse
+    {
+        $event = $request->user()->events()
+            ->where('client_id', $clientId)
+            ->firstOrFail();
+
+        abort_unless((int) $media->event_id === (int) $event->id, 404);
+
+        $wasKeyImage = $media->collection === 'key_image';
+        $this->deleteMediaFiles($media);
+        $media->delete();
+
+        if ($wasKeyImage) {
+            $event->update(['image' => null]);
+        }
+
+        return response()->json(null, 204);
+    }
+
+    private function deleteExistingKeyImages(iterable $mediaItems): void
+    {
+        foreach ($mediaItems as $media) {
+            $this->deleteMediaFiles($media);
+            $media->delete();
+        }
+    }
+
+    private function deleteMediaFiles(EventMedia $media): void
+    {
+        Storage::disk($media->disk)->delete(array_filter([
+            $media->path,
+            $media->preview_path,
+            $media->thumbnail_path,
+        ]));
+    }
+}

backend/app/Http/Controllers/Api/SettingsController.php

@@ -0,0 +1,32 @@
+<?php
+
+namespace App\Http\Controllers\Api;
+
+use App\Http\Controllers\Controller;
+use App\Http\Requests\UpdateSettingsRequest;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+
+class SettingsController extends Controller
+{
+    public function show(Request $request): JsonResponse
+    {
+        return response()->json([
+            'data' => $request->user()->settings?->settings ?? null,
+        ]);
+    }
+
+    public function update(UpdateSettingsRequest $request): JsonResponse
+    {
+        $settings = $request->validated('settings');
+
+        $userSettings = $request->user()->settings()->updateOrCreate(
+            [],
+            ['settings' => $settings],
+        );
+
+        return response()->json([
+            'data' => $userSettings->settings,
+        ]);
+    }
+}

backend/app/Http/Controllers/Api/SettingsMediaController.php

@@ -0,0 +1,97 @@
+<?php
+
+namespace App\Http\Controllers\Api;
+
+use App\Http\Controllers\Controller;
+use App\Http\Requests\StoreSettingsMediaRequest;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+use Illuminate\Http\Response;
+use Illuminate\Http\UploadedFile;
+use Illuminate\Support\Facades\Storage;
+use RuntimeException;
+
+class SettingsMediaController extends Controller
+{
+    private const BACKGROUND_MAX_SIDE = 1600;
+
+    private const BACKGROUND_QUALITY = 86;
+
+    public function store(StoreSettingsMediaRequest $request): JsonResponse
+    {
+        $processed = $this->processBackground($request->file('file'));
+        $path = $this->backgroundPath((int) $request->user()->id);
+
+        Storage::disk('local')->put($path, $processed['contents']);
+
+        return response()->json([
+            'data' => [
+                'url' => '/settings/media/background?v='.time(),
+                'width' => $processed['width'],
+                'height' => $processed['height'],
+                'mimeType' => 'image/jpeg',
+                'size' => strlen($processed['contents']),
+            ],
+        ], 201);
+    }
+
+    public function show(Request $request): Response
+    {
+        $path = $this->backgroundPath((int) $request->user()->id);
+
+        abort_unless(Storage::disk('local')->exists($path), 404);
+
+        return response(Storage::disk('local')->get($path), 200, [
+            'Content-Type' => 'image/jpeg',
+            'Cache-Control' => 'private, max-age=604800',
+        ]);
+    }
+
+    public function destroy(Request $request): JsonResponse
+    {
+        Storage::disk('local')->delete($this->backgroundPath((int) $request->user()->id));
+
+        return response()->json(null, 204);
+    }
+
+    private function backgroundPath(int $userId): string
+    {
+        return "settings-media/{$userId}/background.jpg";
+    }
+
+    /**
+     * @return array{contents: string, width: int, height: int}
+     */
+    private function processBackground(UploadedFile $file): array
+    {
+        $source = imagecreatefromstring((string) file_get_contents($file->getRealPath()));
+
+        if (! $source) {
+            throw new RuntimeException('The uploaded background image could not be processed.');
+        }
+
+        $sourceWidth = imagesx($source);
+        $sourceHeight = imagesy($source);
+        $scale = min(1, self::BACKGROUND_MAX_SIDE / max($sourceWidth, $sourceHeight));
+        $width = max(1, (int) round($sourceWidth * $scale));
+        $height = max(1, (int) round($sourceHeight * $scale));
+
+        $canvas = imagecreatetruecolor($width, $height);
+        $background = imagecolorallocate($canvas, 255, 255, 255);
+        imagefilledrectangle($canvas, 0, 0, $width, $height, $background);
+        imagecopyresampled($canvas, $source, 0, 0, 0, 0, $width, $height, $sourceWidth, $sourceHeight);
+
+        imagedestroy($source);
+
+        ob_start();
+        imagejpeg($canvas, null, self::BACKGROUND_QUALITY);
+        $contents = (string) ob_get_clean();
+        imagedestroy($canvas);
+
+        return [
+            'contents' => $contents,
+            'width' => $width,
+            'height' => $height,
+        ];
+    }
+}

backend/app/Http/Requests/LoginRequest.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace App\Http\Requests;
+
+use Illuminate\Foundation\Http\FormRequest;
+
+class LoginRequest extends FormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    /**
+     * Get the validation rules that apply to the request.
+     *
+     * @return array<string, \Illuminate\Contracts\Validation\ValidationRule|array<mixed>|string>
+     */
+    public function rules(): array
+    {
+        return [
+            'email' => ['required', 'email'],
+            'password' => ['required', 'string'],
+        ];
+    }
+}

backend/app/Http/Requests/StoreEventMediaRequest.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace App\Http\Requests;
+
+use Illuminate\Foundation\Http\FormRequest;
+
+class StoreEventMediaRequest extends FormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    /**
+     * Get the validation rules that apply to the request.
+     *
+     * @return array<string, \Illuminate\Contracts\Validation\ValidationRule|array<mixed>|string>
+     */
+    public function rules(): array
+    {
+        return [
+            'file' => ['required', 'image', 'mimes:jpg,jpeg,png,webp', 'max:10240'],
+            'collection' => ['nullable', 'in:key_image,gallery'],
+        ];
+    }
+}

backend/app/Http/Requests/StoreSettingsMediaRequest.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Http\Requests;
+
+use Illuminate\Foundation\Http\FormRequest;
+
+class StoreSettingsMediaRequest extends FormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    /**
+     * @return array<string, \Illuminate\Contracts\Validation\ValidationRule|array<mixed>|string>
+     */
+    public function rules(): array
+    {
+        return [
+            'file' => ['required', 'image', 'mimes:jpg,jpeg,png,webp', 'max:10240'],
+        ];
+    }
+}

backend/app/Http/Requests/UpdateSettingsRequest.php

@@ -0,0 +1,37 @@
+<?php
+
+namespace App\Http\Requests;
+
+use Illuminate\Foundation\Http\FormRequest;
+
+class UpdateSettingsRequest extends FormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    /**
+     * Get the validation rules that apply to the request.
+     *
+     * @return array<string, \Illuminate\Contracts\Validation\ValidationRule|array<mixed>|string>
+     */
+    public function rules(): array
+    {
+        return [
+            'settings' => ['required', 'array'],
+            'settings.theme' => ['nullable', 'string', 'max:50'],
+            'settings.floatingLines' => ['nullable', 'array'],
+            'settings.appearance' => ['nullable', 'string', 'max:50'],
+            'settings.accentColor' => ['nullable', 'string', 'max:50'],
+            'settings.language' => ['nullable', 'string', 'max:10'],
+            'settings.emotionGradientStart' => ['nullable', 'string', 'max:20'],
+            'settings.emotionGradientEnd' => ['nullable', 'string', 'max:20'],
+            'settings.timelineZoom' => ['nullable', 'numeric', 'min:0.1', 'max:10'],
+            'settings.timelineScrollLeft' => ['nullable', 'numeric', 'min:0'],
+            'settings.showFps' => ['nullable', 'boolean'],
+            'settings.presets' => ['nullable', 'array'],
+            'settings.activePresetId' => ['nullable', 'string', 'max:100'],
+        ];
+    }
+}

backend/app/Http/Resources/EventMediaResource.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace App\Http\Resources;
+
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+class EventMediaResource extends JsonResource
+{
+    public function toArray(Request $request): array
+    {
+        return [
+            'id' => (string) $this->id,
+            'uuid' => $this->uuid,
+            'type' => 'image',
+            'collection' => $this->collection,
+            'name' => $this->name,
+            'mimeType' => $this->mime_type,
+            'size' => $this->size,
+            'width' => $this->width,
+            'height' => $this->height,
+            'thumbnailWidth' => $this->thumbnail_width,
+            'thumbnailHeight' => $this->thumbnail_height,
+            'previewWidth' => $this->preview_width,
+            'previewHeight' => $this->preview_height,
+            'src' => "/event-media/{$this->id}/thumb",
+            'thumbnailUrl' => "/event-media/{$this->id}/thumb",
+            'previewUrl' => "/event-media/{$this->id}/preview",
+            'originalUrl' => "/event-media/{$this->id}/original",
+            'createdAt' => $this->created_at->getTimestampMs(),
+        ];
+    }
+}

backend/app/Http/Resources/EventResource.php

@@ -18,6 +18,7 @@ class EventResource extends JsonResource
             'gradientPreset' => $this->gradient_preset,
             'image' => $this->image,
             'note' => $this->note ?? '',
+            'media' => EventMediaResource::collection($this->whenLoaded('media')),
             'syncStatus' => 'synced',
             'createdAt' => $this->created_at->getTimestampMs(),
             'updatedAt' => $this->updated_at->getTimestampMs(),

backend/app/Models/Event.php

@@ -5,6 +5,7 @@ namespace App\Models;
 use Illuminate\Database\Eloquent\Factories\HasFactory;
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Database\Eloquent\Relations\BelongsTo;
+use Illuminate\Database\Eloquent\Relations\HasMany;
 
 class Event extends Model
 {
@@ -35,4 +36,9 @@ class Event extends Model
     {
         return $this->belongsTo(User::class);
     }
+
+    public function media(): HasMany
+    {
+        return $this->hasMany(EventMedia::class);
+    }
 }

backend/app/Models/EventMedia.php

@@ -0,0 +1,66 @@
+<?php
+
+namespace App\Models;
+
+use Illuminate\Database\Eloquent\Factories\HasFactory;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+use Illuminate\Support\Str;
+
+class EventMedia extends Model
+{
+    /** @use HasFactory<\Database\Factories\EventMediaFactory> */
+    use HasFactory;
+
+    protected $fillable = [
+        'uuid',
+        'user_id',
+        'event_id',
+        'collection',
+        'name',
+        'mime_type',
+        'disk',
+        'path',
+        'thumbnail_path',
+        'preview_path',
+        'size',
+        'width',
+        'height',
+        'thumbnail_width',
+        'thumbnail_height',
+        'preview_width',
+        'preview_height',
+    ];
+
+    protected function casts(): array
+    {
+        return [
+            'size' => 'integer',
+            'width' => 'integer',
+            'height' => 'integer',
+            'thumbnail_width' => 'integer',
+            'thumbnail_height' => 'integer',
+            'preview_width' => 'integer',
+            'preview_height' => 'integer',
+        ];
+    }
+
+    protected static function booted(): void
+    {
+        static::creating(function (EventMedia $media): void {
+            if (! $media->uuid) {
+                $media->uuid = (string) Str::uuid();
+            }
+        });
+    }
+
+    public function event(): BelongsTo
+    {
+        return $this->belongsTo(Event::class);
+    }
+
+    public function user(): BelongsTo
+    {
+        return $this->belongsTo(User::class);
+    }
+}

backend/app/Models/User.php

@@ -5,6 +5,7 @@ namespace App\Models;
 // use Illuminate\Contracts\Auth\MustVerifyEmail;
 use Illuminate\Database\Eloquent\Factories\HasFactory;
 use Illuminate\Database\Eloquent\Relations\HasMany;
+use Illuminate\Database\Eloquent\Relations\HasOne;
 use Illuminate\Foundation\Auth\User as Authenticatable;
 use Illuminate\Notifications\Notifiable;
 use Illuminate\Support\Str;
@@ -57,6 +58,11 @@ class User extends Authenticatable
         return $this->hasMany(Event::class);
     }
 
+    public function settings(): HasOne
+    {
+        return $this->hasOne(UserSetting::class);
+    }
+
     public function initials(): string
     {
         return Str::of($this->name)

backend/app/Models/UserSetting.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace App\Models;
+
+use Illuminate\Database\Eloquent\Factories\HasFactory;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+
+class UserSetting extends Model
+{
+    /** @use HasFactory<\Database\Factories\UserSettingFactory> */
+    use HasFactory;
+
+    protected $fillable = [
+        'settings',
+    ];
+
+    protected function casts(): array
+    {
+        return [
+            'settings' => 'array',
+        ];
+    }
+
+    public function user(): BelongsTo
+    {
+        return $this->belongsTo(User::class);
+    }
+}

backend/app/Services/EventMediaImageProcessor.php

@@ -0,0 +1,125 @@
+<?php
+
+namespace App\Services;
+
+use Illuminate\Http\UploadedFile;
+use RuntimeException;
+
+class EventMediaImageProcessor
+{
+    private const MAX_ORIGINAL_SIDE = 3508;
+
+    private const PREVIEW_MAX_SIDE = 900;
+
+    private const THUMBNAIL_SIZE = 320;
+
+    /**
+     * @return array{
+     *     original: string,
+     *     preview: string,
+     *     thumbnail: string,
+     *     width: int,
+     *     height: int,
+     *     preview_width: int,
+     *     preview_height: int,
+     *     thumbnail_width: int,
+     *     thumbnail_height: int,
+     *     mime_type: string,
+     *     size: int
+     * }
+     */
+    public function process(UploadedFile $file): array
+    {
+        $source = imagecreatefromstring((string) file_get_contents($file->getRealPath()));
+
+        if (! $source) {
+            throw new RuntimeException('The uploaded image could not be processed.');
+        }
+
+        $sourceWidth = imagesx($source);
+        $sourceHeight = imagesy($source);
+
+        $original = $this->resizeContain($source, $sourceWidth, $sourceHeight, self::MAX_ORIGINAL_SIDE);
+        $preview = $this->resizeContain($source, $sourceWidth, $sourceHeight, self::PREVIEW_MAX_SIDE, 84);
+        $thumbnail = $this->resizeCover($source, $sourceWidth, $sourceHeight, self::THUMBNAIL_SIZE);
+
+        imagedestroy($source);
+
+        return [
+            'original' => $original['contents'],
+            'preview' => $preview['contents'],
+            'thumbnail' => $thumbnail['contents'],
+            'width' => $original['width'],
+            'height' => $original['height'],
+            'preview_width' => $preview['width'],
+            'preview_height' => $preview['height'],
+            'thumbnail_width' => self::THUMBNAIL_SIZE,
+            'thumbnail_height' => self::THUMBNAIL_SIZE,
+            'mime_type' => 'image/jpeg',
+            'size' => strlen($original['contents']),
+        ];
+    }
+
+    /**
+     * @return array{contents: string, width: int, height: int}
+     */
+    private function resizeContain(
+        \GdImage $source,
+        int $sourceWidth,
+        int $sourceHeight,
+        int $maxSide,
+        int $quality = 90
+    ): array {
+        $scale = min(1, $maxSide / max($sourceWidth, $sourceHeight));
+        $width = max(1, (int) round($sourceWidth * $scale));
+        $height = max(1, (int) round($sourceHeight * $scale));
+
+        $canvas = imagecreatetruecolor($width, $height);
+        $this->fillCanvas($canvas, $width, $height);
+        imagecopyresampled($canvas, $source, 0, 0, 0, 0, $width, $height, $sourceWidth, $sourceHeight);
+
+        return [
+            'contents' => $this->encodeJpeg($canvas, $quality),
+            'width' => $width,
+            'height' => $height,
+        ];
+    }
+
+    /**
+     * @return array{contents: string, width: int, height: int}
+     */
+    private function resizeCover(\GdImage $source, int $sourceWidth, int $sourceHeight, int $size): array
+    {
+        $scale = max($size / $sourceWidth, $size / $sourceHeight);
+        $width = (int) round($sourceWidth * $scale);
+        $height = (int) round($sourceHeight * $scale);
+        $x = (int) round(($size - $width) / 2);
+        $y = (int) round(($size - $height) / 2);
+
+        $canvas = imagecreatetruecolor($size, $size);
+        $this->fillCanvas($canvas, $size, $size);
+        imagecopyresampled($canvas, $source, $x, $y, 0, 0, $width, $height, $sourceWidth, $sourceHeight);
+
+        return [
+            'contents' => $this->encodeJpeg($canvas, 80),
+            'width' => $size,
+            'height' => $size,
+        ];
+    }
+
+    private function fillCanvas(\GdImage $canvas, int $width, int $height): void
+    {
+        $background = imagecolorallocate($canvas, 255, 255, 255);
+        imagefilledrectangle($canvas, 0, 0, $width, $height, $background);
+    }
+
+    private function encodeJpeg(\GdImage $image, int $quality): string
+    {
+        ob_start();
+        imagejpeg($image, null, $quality);
+        $contents = (string) ob_get_clean();
+        imagedestroy($image);
+
+        return $contents;
+    }
+}