TenantAtlas/apps/platform/app/Jobs/BulkTenantSyncJob.php

<?php

namespace App\Jobs;

use App\Jobs\Concerns\BridgesFailedOperationRun;
use App\Jobs\Middleware\EnsureQueuedExecutionLegitimate;
use App\Jobs\Operations\TenantSyncWorkerJob;
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;

class BulkTenantSyncJob implements ShouldQueue
{
    use BridgesFailedOperationRun;
    use Dispatchable;
    use InteractsWithQueue;
    use Queueable;
    use SerializesModels;

    public int $timeout = 180;

    public bool $failOnTimeout = true;

    public ?OperationRun $operationRun = null;

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

    public function middleware(): array
    {
        return [new EnsureQueuedExecutionLegitimate];
    }

    public function handle(OperationRunService $runs): void
    {
        if (! $this->operationRun instanceof OperationRun) {
            throw new RuntimeException('OperationRun is required for BulkTenantSyncJob.');
        }

        $this->operationRun->refresh();

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

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

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

        $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 $targetTenantId) {
                dispatch(new TenantSyncWorkerJob(
                    tenantId: $targetTenantId,
                    userId: $this->userId,
                    operationRun: $this->operationRun,
                    context: $this->context,
                ));
            }
        }
    }

    /**
     * @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;
    }
}