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

<?php

namespace App\Jobs;

use App\Mail\Jobs\CodeExportSucceed;
use App\Mail\Jobs\JobFailed;
use App\Models\Code;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldBeUnique;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\File;
use Illuminate\Support\Facades\Mail;

class ProcessExportCodesUniques implements ShouldQueue, ShouldBeUnique
{
    use Dispatchable;
    use InteractsWithQueue;
    use Queueable;
    use SerializesModels;

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

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

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

    /**
     * Execute the job.
     *
     * @return void
     */
    public function handle()
    {
        DB::transaction(function () {
            $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 integer|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
     *
     * @param \Throwable $exception
     * @return void
     */
    public function failed(\Throwable $exception)
    {
        Mail::to(config('mail.admin'))->send(
            new JobFailed(__CLASS__, [
                'message' => $exception->getMessage(),
                'trace' => $exception->getTraceAsString()
            ])
        );
    }
}