feat(platform): fresh mail, pdf and storage implementation

2026-09-02 13:21:02 +00:00 · 2026-08-21 11:15:24 +02:00
parent a7b272c731
commit c35999aa9b
17 changed files with 1569 additions and 0 deletions
@@ -0,0 +1,175 @@
+<?php
+
+namespace App\Platform\Storage\Http;
+
+use App\Platform\Http\Controller;
+use App\Platform\Storage\Application\BackupService;
+use App\Platform\Storage\Jobs\CreateBackupJob;
+use App\Platform\Storage\Rules\PathToZip;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+use Illuminate\Http\Response;
+use Spatie\Backup\BackupDestination\Backup;
+use Spatie\Backup\Helpers\Format;
+use Symfony\Component\HttpFoundation\StreamedResponse;
+
+/**
+ * The archives kept on a storage target.
+ *
+ * Which target is a per-request decision: `file_disk_id` selects one, and
+ * without it the backup purpose setting decides, falling back to the default
+ * disk. Every action re-resolves it, so a caller may list one disk and delete
+ * from another in the same session.
+ *
+ * An archive is addressed by its path on that disk, and a path is only ever
+ * accepted if it names a zip -- the one thing standing between these endpoints
+ * and an arbitrary file on the storage target.
+ */
+class BackupsController extends Controller
+{
+    public function __construct(
+        private readonly BackupService $backupService,
+    ) {}
+
+    /**
+     * What is currently stored on the selected disk, newest-first only insofar
+     * as the destination hands them back that way.
+     *
+     * Anything that goes wrong while reading -- credentials the remote rejects,
+     * a bucket that is not there, a network that is not either -- is answered
+     * with 200 and an empty list carrying an error marker beside it, rather
+     * than a failure status. The screen renders "no backups yet" plus the
+     * driver's own words about why. Preserved: the SPA switches on the marker,
+     * not on the status code.
+     */
+    public function index(Request $request): JsonResponse
+    {
+        $this->authorize('manage backups');
+
+        try {
+            $target = $this->backupService->getDestination($request->file_disk_id);
+
+            $archives = $target
+                ->backups()
+                ->map(function (Backup $archive) {
+                    return [
+                        'path' => $archive->path(),
+                        'created_at' => $archive->date()->format('Y-m-d H:i:s'),
+                        'size' => Format::humanReadableSize($archive->sizeInBytes()),
+                    ];
+                })
+                ->toArray();
+
+            return response()->json([
+                'backups' => $archives,
+            ]);
+        } catch (\Exception $failure) {
+            return response()->json([
+                'backups' => [],
+                'error' => 'invalid_disk_credentials',
+                'error_message' => $failure->getMessage(),
+            ]);
+        }
+    }
+
+    /**
+     * Queue an archive run and answer immediately.
+     *
+     * The whole body is handed to the job untouched -- `option` (everything,
+     * database only, or files only) and the disk selection are read there, and
+     * the reply says nothing about whether the run later succeeded. Nothing is
+     * validated at this end, so an unrecognised option is a job-time problem,
+     * not a request-time one.
+     */
+    public function store(Request $request): JsonResponse
+    {
+        $this->authorize('manage backups');
+
+        $payload = $request->all();
+
+        dispatch(new CreateBackupJob($payload))->onQueue(config('backup.queue.name'));
+
+        return response()->json(['success' => true]);
+    }
+
+    /**
+     * Remove one archive from the selected disk.
+     *
+     * The route carries a `{backup}` segment because the endpoint is registered
+     * as part of a resource, but nothing reads it -- the archive is identified
+     * by the `path` in the body, and the segment can be any value at all.
+     *
+     * KNOWN DEFECT: a path that names no archive on the disk leaves the search
+     * empty and the delete is attempted on nothing, which is a 500 rather than
+     * a 404. Reproduced as found.
+     */
+    public function destroy($disk, Request $request): JsonResponse
+    {
+        $this->authorize('manage backups');
+
+        $path = $this->requireArchivePath($request);
+
+        $target = $this->backupService->getDestination($request->file_disk_id);
+
+        $target
+            ->backups()
+            ->first(function (Backup $archive) use ($path) {
+                return $archive->path() === $path;
+            })
+            ->delete();
+
+        return response()->json(['success' => true]);
+    }
+
+    /**
+     * Stream one archive back as a download.
+     *
+     * Sent as a stream rather than a file response because the archive may live
+     * on a remote disk and is never staged locally. The length is taken from
+     * the destination's own metadata, so the browser gets a progress bar; the
+     * no-cache headers keep an intermediary from holding on to a database dump.
+     *
+     * A path that names nothing is 422 with a bare sentence -- plain text, not
+     * the JSON envelope the rest of the controller answers with. Preserved.
+     */
+    public function download(Request $request): Response|StreamedResponse
+    {
+        $this->authorize('manage backups');
+
+        $path = $this->requireArchivePath($request);
+
+        $target = $this->backupService->getDestination($request->file_disk_id);
+
+        $archive = $target->backups()->first(function (Backup $candidate) use ($path) {
+            return $candidate->path() === $path;
+        });
+
+        if (! $archive) {
+            return response('Backup not found', 422);
+        }
+
+        $name = pathinfo($archive->path(), PATHINFO_BASENAME);
+
+        return response()->stream(function () use ($archive) {
+            $stream = $archive->stream();
+            fpassthru($stream);
+            if (is_resource($stream)) {
+                fclose($stream);
+            }
+        }, 200, [
+            'Cache-Control' => 'must-revalidate, post-check=0, pre-check=0',
+            'Content-Type' => 'application/zip',
+            'Content-Length' => $archive->sizeInBytes(),
+            'Content-Disposition' => 'attachment; filename="'.$name.'"',
+            'Pragma' => 'public',
+        ]);
+    }
+
+    /**
+     * The archive path both write endpoints work from: required, and a zip.
+     */
+    private function requireArchivePath(Request $request): string
+    {
+        return $request->validate(['path' => ['required', new PathToZip]])['path'];
+    }
+}