File transfer

app/Addons/AdvancedAdmin/Services/Revisions/RevisionService.php

@@ -0,0 +1,166 @@
+<?php
+
+/**
+ * Revision Service — orchestrates creating, restoring, and pruning revisions.
+ *
+ * @author  Ball Studios <https://git.balls.studio>
+ * @license MIT
+ */
+
+namespace Pterodactyl\Addons\AdvancedAdmin\Services\Revisions;
+
+use Illuminate\Support\Facades\DB;
+use Pterodactyl\Addons\AdvancedAdmin\Models\FileRevision;
+use Pterodactyl\Addons\AdvancedAdmin\Models\RoleAuditLog;
+use Pterodactyl\Addons\AdvancedAdmin\Services\Revisions\RevisionStorageService;
+use Pterodactyl\Addons\AdvancedAdmin\Services\Revisions\ExclusionMatcher;
+
+class RevisionService
+{
+    public function __construct(
+        private readonly RevisionStorageService $storage,
+        private readonly ExclusionMatcher       $exclusions,
+    ) {}
+
+    /**
+     * Record a new revision for a file.
+     * Returns null if the file should be skipped (excluded, too large, binary unchanged, duplicate).
+     */
+    public function record(
+        int    $serverId,
+        string $filePath,
+        string $content,
+        ?int   $authorId   = null,
+        string $summary    = ''
+    ): ?FileRevision {
+        // Security: sanitize path
+        $filePath = $this->storage->guardFilePath($filePath);
+
+        // Skip excluded files
+        if ($this->exclusions->isExcluded($filePath)) {
+            return null;
+        }
+
+        // Skip files above size limit
+        $maxSize = config('advanced-admin.revisions.max_file_size', 10 * 1024 * 1024);
+        if (strlen($content) > $maxSize) {
+            return null;
+        }
+
+        $pathHash    = $this->storage->pathHash($serverId, $filePath);
+        $contentHash = $this->storage->contentHash($content);
+
+        // Deduplicate: if latest revision has same content, skip
+        $latest = FileRevision::query()
+            ->where('server_id', $serverId)
+            ->where('path_hash', $pathHash)
+            ->orderByDesc('revision_number')
+            ->first();
+
+        if ($latest && $latest->content_hash === $contentHash) {
+            return null; // No change
+        }
+
+        $revisionNumber = ($latest?->revision_number ?? 0) + 1;
+
+        return DB::transaction(function () use (
+            $serverId, $filePath, $pathHash, $contentHash,
+            $revisionNumber, $content, $authorId, $summary
+        ) {
+            $stored = $this->storage->store($serverId, $pathHash, $revisionNumber, $content);
+
+            $revision = FileRevision::create([
+                'server_id'       => $serverId,
+                'file_path'       => $filePath,
+                'path_hash'       => $pathHash,
+                'content_hash'    => $contentHash,
+                'revision_number' => $revisionNumber,
+                'storage_key'     => $stored['storage_key'],
+                'storage_type'    => 'full',
+                'size_bytes'      => $stored['size_bytes'],
+                'compressed_size' => $stored['compressed_size'],
+                'author_id'       => $authorId,
+                'change_summary'  => $summary ?: 'File edited via panel',
+            ]);
+
+            $this->updateStorageUsage($serverId, $stored['compressed_size']);
+            $this->enforceRetentionLimits($serverId, $pathHash);
+
+            RoleAuditLog::record($authorId, 'revision.created', 'file_revision', $revision->id, [
+                'server_id' => $serverId,
+                'file_path' => $filePath,
+                'revision'  => $revisionNumber,
+            ]);
+
+            return $revision;
+        });
+    }
+
+    /**
+     * Restore a revision — returns the stored content.
+     */
+    public function restore(FileRevision $revision, ?int $actorId = null): string
+    {
+        $content = $this->storage->retrieve($revision->storage_key);
+
+        RoleAuditLog::record($actorId, 'revision.restored', 'file_revision', $revision->id, [
+            'server_id'  => $revision->server_id,
+            'file_path'  => $revision->file_path,
+            'revision'   => $revision->revision_number,
+        ]);
+
+        return $content;
+    }
+
+    /**
+     * Delete a specific revision from storage and DB.
+     */
+    public function delete(FileRevision $revision): void
+    {
+        DB::transaction(function () use ($revision) {
+            $this->storage->delete($revision->storage_key);
+            $this->updateStorageUsage($revision->server_id, -$revision->compressed_size);
+            $revision->delete();
+        });
+    }
+
+    /**
+     * Enforce per-file and per-server retention limits.
+     * Deletes oldest revisions beyond the cap.
+     */
+    public function enforceRetentionLimits(int $serverId, string $pathHash): void
+    {
+        $maxPerFile = config('advanced-admin.revisions.max_revisions_per_file', 50);
+
+        $revisions = FileRevision::query()
+            ->where('server_id', $serverId)
+            ->where('path_hash', $pathHash)
+            ->orderByDesc('revision_number')
+            ->get();
+
+        $toDelete = $revisions->slice($maxPerFile);
+        foreach ($toDelete as $old) {
+            $this->delete($old);
+        }
+
+        // Per-server storage cap
+        $maxStorage = config('advanced-admin.revisions.max_storage_per_server', 500 * 1024 * 1024);
+        $usage = \Pterodactyl\Addons\AdvancedAdmin\Models\FileRevisionStorageUsage::find($serverId);
+        if ($usage && $usage->total_bytes > $maxStorage) {
+            // Delete oldest revisions across all files until under cap
+            $oldest = FileRevision::query()
+                ->where('server_id', $serverId)
+                ->orderBy('created_at')
+                ->first();
+            if ($oldest) $this->delete($oldest);
+        }
+    }
+
+    private function updateStorageUsage(int $serverId, int $delta): void
+    {
+        \Pterodactyl\Addons\AdvancedAdmin\Models\FileRevisionStorageUsage::updateOrCreate(
+            ['server_id' => $serverId],
+            ['total_bytes' => DB::raw("total_bytes + {$delta}")]
+        );
+    }
+}