TenantAtlas/app/Jobs/BulkBackupSetRestoreJob.php

<?php

namespace App\Jobs;

use App\Jobs\Operations\BackupSetRestoreWorkerJob;
use App\Models\OperationRun;
use App\Services\OperationRunService;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;
use RuntimeException;
use Throwable;

class BulkBackupSetRestoreJob implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    public int $bulkRunId = 0;

    public ?OperationRun $operationRun = null;

    /**
     * @param  array<int, mixed>  $backupSetIds
     * @param  array<string, mixed>  $context
     */
    public function __construct(
        public int $tenantId,
        public int $userId,
        public array $backupSetIds,
        ?OperationRun $operationRun = null,
        public array $context = [],
    ) {
        $this->operationRun = $operationRun;
        $this->bulkRunId = $operationRun?->getKey() ? (int) $operationRun->getKey() : 0;
    }

    public function handle(OperationRunService $runs): void
    {
        $this->operationRun = $this->resolveOperationRun();

        $this->operationRun->refresh();

        if ($this->operationRun->status === 'completed') {
            return;
        }

        $runs->updateRun($this->operationRun, 'running');

        $ids = $this->normalizeIds($this->backupSetIds);

        $runs->incrementSummaryCounts($this->operationRun, ['total' => count($ids)]);

        $chunkSize = (int) config('tenantpilot.bulk_operations.chunk_size', 10);
        $chunkSize = max(1, $chunkSize);

        foreach (array_chunk($ids, $chunkSize) as $chunk) {
            foreach ($chunk as $backupSetId) {
                dispatch(new BackupSetRestoreWorkerJob(
                    tenantId: $this->tenantId,
                    userId: $this->userId,
                    backupSetId: $backupSetId,
                    operationRun: $this->operationRun,
                    context: $this->context,
                ));
            }
        }
    }

    public function failed(Throwable $e): void
    {
        $run = $this->operationRun;

        if (! $run instanceof OperationRun && $this->bulkRunId > 0) {
            $run = OperationRun::query()->find($this->bulkRunId);
        }

        if (! $run instanceof OperationRun) {
            return;
        }

        /** @var OperationRunService $runs */
        $runs = app(OperationRunService::class);

        $runs->updateRun(
            $run,
            status: 'completed',
            outcome: 'failed',
            failures: [[
                'code' => 'bulk_job.failed',
                'message' => $e->getMessage(),
            ]],
        );
    }

    private function resolveOperationRun(): OperationRun
    {
        if ($this->operationRun instanceof OperationRun) {
            return $this->operationRun;
        }

        if ($this->bulkRunId > 0) {
            $run = OperationRun::query()->find($this->bulkRunId);

            if ($run instanceof OperationRun) {
                return $run;
            }
        }

        throw new RuntimeException('OperationRun is required for BulkBackupSetRestoreJob.');
    }

    /**
     * @param  array<int, mixed>  $ids
     * @return array<int, int>
     */
    private function normalizeIds(array $ids): array
    {
        $normalized = [];

        foreach ($ids as $id) {
            if (is_int($id)) {
                $normalized[] = $id;

                continue;
            }

            if (is_numeric($id)) {
                $normalized[] = (int) $id;
            }
        }

        $normalized = array_values(array_unique($normalized));
        sort($normalized);

        return $normalized;
    }
}