ldc-gen-game-web/app/Jobs/ProcessExportCodesUniques.php

<?php

declare(strict_types=1);

namespace App\Jobs;

use App\Mail\Jobs\CodeExportSucceed;
use App\Mail\Jobs\JobFailed;
use App\Models\Code;
use Exception;
use Illuminate\Contracts\Queue\ShouldBeUnique;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Queue\Queueable;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\File;
use Illuminate\Support\Facades\Mail;
use Throwable;
use ZipArchive;

class ProcessExportCodesUniques implements ShouldBeUnique, ShouldQueue
{
    use Queueable;

    /**
     * The number of seconds the job can run before timing out.
     *
     * 28800 seconds (8 hours)
     *
     * @var int
     */
    public $timeout = 28800;

    /**
     * The export file name
     *
     * @var string
     */
    protected $exportFileName;

    /**
     * Create a new job instance.
     *
     * @param  int  $nbCodeFic  Nombre de codes par fichiers.
     * @param  int  $nbCodeTot  Nombre total de codes à exporter.
     * @param  int  $nbCodeLigne  Nombre de codes par ligne.
     */
    public function __construct(
        protected int $nbCodeFic,
        protected int $nbCodeTot,
        protected int $nbCodeLigne
    ) {
    }

    /**
     * Execute the job.
     */
    public function handle(): void
    {
        DB::transaction(function (): void {
            $this->exportFileName = sprintf(
                'CodesUniques_%s',
                date('dmY_His')
            );

            $exportFilePath = storage_path(sprintf('export_codes_uniques/%s.zip', $this->exportFileName));

            try {
                $lastExportedCodeId = Code::query()
                    ->where('code_exported', true)
                    ->orderBy('id', 'desc')->first()->id ?? null;

                $filesPath = $this->generateCsvFiles($lastExportedCodeId);

                // * Compression des fichiers.
                $zip = new ZipArchive();
                if ($zip->open($exportFilePath, ZipArchive::CREATE) === true) {
                    foreach ($filesPath as $filePath) {
                        if (File::exists($filePath)) {
                            $zip->addFile($filePath, \pathinfo($filePath, \PATHINFO_BASENAME));
                        }
                    }
                    $zip->close();
                }

                // * On vide le dossier temporaire des fichiers csv.
                foreach ($filesPath as $filePath) {
                    if (File::exists($filePath)) {
                        File::delete($filePath);
                    }
                }

                // * Envoi de mail à MAIL_ADMIN avec le nom du ZIP "CodesUniques_". date('dmY_His') .".zip".
                Mail::to(config('mail.admin'))->send(new CodeExportSucceed(
                    $this->nbCodeFic,
                    $this->nbCodeTot,
                    $this->nbCodeLigne,
                    $exportFilePath
                ));
            } catch (Exception $e) {
                // * Clear exported file in case of Failure.
                if (File::exists($exportFilePath)) {
                    File::delete($exportFilePath);
                }
                throw $e;
            } // end try
        });
    }

    /**
     * Generate CSV File using the job parameters
     *
     * @param  int|null  $lastExportedCodeId
     * @return array Array of temp files
     *
     * @phpcs:disable Generic.Metrics.CyclomaticComplexity.TooHigh
     */
    private function generateCsvFiles($lastExportedCodeId = null): array
    {
        // phpcs:enable
        $outPaths             = [];
        $totalExportedCodes   = 0;
        $currentFilename      = 1;
        $currentExportedCodes = 0;
        $currentLineCodes     = ($this->nbCodeLigne === 1 ? 1 : 0);

        $paginate = intval(config('codes.paginate', 65535));

        // ! Guess code ids instead of getting thme from base.
        $codes = [];
        $id    = ($lastExportedCodeId ?? 0) + 1;
        for ($i = 0; $i < $this->nbCodeTot; $i++) {
            $codes[] = $id++;
        }

        $exportedCodesId = [];

        $tempFilePath = \storage_path(\sprintf(
            'export_codes_uniques/tmp/%s_%s.csv',
            $this->exportFileName,
            $currentFilename
        ));
        $outPaths[]   = $tempFilePath;

        foreach ($codes as $code) {
            if ($currentExportedCodes < $this->nbCodeTot) {
                if ($currentLineCodes === ($this->nbCodeLigne === 1 ? 1 : $this->nbCodeLigne - 1)) {
                    File::append($tempFilePath, Code::intToSerial($code) . "\n");
                    $currentLineCodes = ($this->nbCodeLigne === 1 ? 1 : 0);
                } else {
                    File::append($tempFilePath, Code::intToSerial($code) . ';');
                    $currentLineCodes++;
                } // end if

                $totalExportedCodes++;
                $currentExportedCodes++;

                $exportedCodesId[] = $code;

                if ($currentExportedCodes === $this->nbCodeFic) {
                    $currentFilename++;
                    $currentExportedCodes = 0;

                    $tempFilePath = \storage_path(\sprintf(
                        'export_codes_uniques/tmp/%s_%s.csv',
                        $this->exportFileName,
                        $currentFilename
                    ));
                    $outPaths[]   = $tempFilePath;
                }
                // ? Have we reached pagination limit for mass saving ?
                if (count($exportedCodesId) === $paginate) {
                    Code::query()->whereIn('id', $exportedCodesId)->update(['code_exported' => true]);
                    $exportedCodesId = [];
                }
            } // end if
        } // end foreach

        // ? Are there exported codes to save ?
        if (count($exportedCodesId)) {
            Code::query()->whereIn('id', $exportedCodesId)->update(['code_exported' => true]);
        }

        return $outPaths;
    }

    /**
     * In case of job failure
     */
    public function failed(Throwable $exception): void
    {
        Mail::to(config('mail.admin'))->send(
            new JobFailed(self::class, [
                'message' => $exception->getMessage(),
                'trace'   => $exception->getTraceAsString(),
            ])
        );
    }
}