Application\Service\Exporter\Exporter

Complexity

Total Complexity

12

Size/Duplication

Total Lines	131
Duplicated Lines	0 %

Test Coverage

Coverage

63.16%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	export()	0	30	2
A	writeCards()	0	17	4
A	getWriter()	0	6	1
A	exportAndSendMessage()	0	14	2
A	exportAsync()	0	14	1
A	__construct()	0	10	1
A	reloadExport()	0	5	1

<?php

declare(strict_types=1);

namespace Application\Service\Exporter;

use Application\Enum\ExportFormat;
use Application\Model\Export;
use Application\Model\User;
use Application\Repository\CardRepository;
use Application\Repository\ExportRepository;
use Application\Service\MessageQueuer;
use Ecodev\Felix\Service\Mailer;
use InvalidArgumentException;
use Throwable;

class Exporter
{
    public function __construct(
        private readonly ExportRepository $exportRepository,
        private readonly CardRepository $cardRepository,
        private readonly MessageQueuer $messageQueuer,
        private readonly Mailer $mailer,
        private readonly Writer $zip,
        private readonly Writer $pptx,
        private readonly Writer $csv,
        private readonly string $phpPath
    ) {
    }

    /**
     * Export asynchronously in a separate process.
     *
     * This should be the preferred way to do big export
     */
    public function exportAsync(Export $export): void
    {
        $args = [
            realpath('bin/export.php'),
            $export->getId(),
        ];

        $escapedArgs = array_map('escapeshellarg', $args);

        // Forward SERVER_NAME to CLI command
        $env = 'SERVER_NAME=' . escapeshellarg(getenv('SERVER_NAME'));

        $cmd = $env . ' ' . escapeshellcmd($this->phpPath) . ' ' . implode(' ', $escapedArgs) . ' > /dev/null 2>&1 &';
        exec($cmd);
    }

    /**
     * Export immediately and return the v $export object.
     *
     * Because this method will indirectly clear the EntityManager any existing object
     * before calling this method will become invalid and must be re-fetched from DB.
     */
    public function export(Export $export): Export
    {
        $writer = $this->getWriter($export);
        $title = $export->getSite()->value . '-' . $export->getId();

        // Poor man's security by using hard-to-guess suffix
        $suffix = bin2hex(random_bytes(5));

        $filename = $title . '-' . $suffix . '.' . $writer->getExtension();

        $export->markAsInProgress($filename);
        _em()->flush();

        try {
            $writer->initialize($export, $title);
            $this->writeCards($writer, $export);
            $writer->finalize();

            $reloadExport = $this->reloadExport($export);
            $reloadExport->markAsDone();
        } catch (Throwable $throwable) {
            $reloadExport = $this->reloadExport($export);
            $reloadExport->markAsErrored($throwable);

            throw $throwable;
        } finally {
            _em()->flush();
        }

        return $reloadExport;
    }

    private function reloadExport(Export $export): Export
    {
        User::reloadCurrentUser();

        return $this->exportRepository->findOneById($export->getId());

The method findOneById() does not exist on Application\Repository\ExportRepository. Since you implemented __call, consider adding a @method annotation.

    }

    /**
     * Export immediately and send an email to the export creator.
     *
     * This must only be used via CLI, because export might be very long (several minutes)
     * and the email is sent synchronously
     */
    public function exportAndSendMessage(int $id): void
    {
        /** @var null|Export $export */
        $export = $this->exportRepository->findOneById($id);
        if (!$export) {
            throw new InvalidArgumentException('Could not find export with ID: ' . $id);
        }

        $export = $this->export($export);

        $user = $export->getCreator();
        $message = $this->messageQueuer->queueExportDone($user, $export);

It seems like $user can also be of type null; however, parameter $user of Application\Service\MessageQueuer::queueExportDone() does only seem to accept Application\Model\User, maybe add an additional type check?

        $this->mailer->sendMessage($message);
    }

    private function getWriter(Export $export): Writer
    {
        return match ($export->getFormat()) {
            ExportFormat::Zip => $this->zip,
            ExportFormat::Pptx => $this->pptx,
            ExportFormat::Csv => $this->csv,
        };
    }

    /**
     * Write all cards in small batches to avoid exploding PHP memory.
     */
    private function writeCards(Writer $writer, Export $export): void
    {
        $lastCardId = 0;
        while (true) {
            $cards = $this->cardRepository->getExportCards($export, $lastCardId);
            // If nothing to process anymore, stop the whole thing
            if (!$cards) {

The expression $cards of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

                break;
            }

            foreach ($cards as $card) {
                $writer->write($card);
                $lastCardId = $card->getId();
            }

            _em()->flush();
            _em()->clear();
        }
    }
}