DH\Auditor\Provider\Doctrine\Persistence\Command\CleanAuditLogsCommand::execute()

Complexity

Conditions	22
Paths	1159

Size

Total Lines	146
Code Lines	82

Duplication

Lines	0
Ratio	0 %

Importance

Changes	5
Bugs	0	Features	0

<?php
    protected function execute(InputInterface $input, OutputInterface $output): int
    {
        if (!$this->lock()) {
            $output->writeln('The command is already running in another process.');

            return Command::SUCCESS;
        }

        $io = new SymfonyStyle($input, $output);

        $keep = $input->getArgument('keep');
        $keep = (\is_array($keep) ? $keep[0] : $keep);

        /** @var string $date */
        $date = $input->getOption('date');
        $until = null;

        if ($date) {
            // Use custom date if provided
            try {
                $until = new DateTimeImmutable($date);
            } catch (Exception $e) {
                $io->error(sprintf('Invalid date format provided: %s', $date));
            }
        } else {
            // Fall back to default retention period
            $until = $this->validateKeepArgument($keep, $io);
        }

        if (null === $until) {
            return Command::SUCCESS;
        }

        /** @var DoctrineProvider $provider */
        $provider = $this->auditor->getProvider(DoctrineProvider::class);
        $schemaManager = new SchemaManager($provider);

        /** @var StorageService[] $storageServices */
        $storageServices = $provider->getStorageServices();

        // auditable classes by storage entity manager
        $count = 0;

        // Collect auditable classes from auditing storage managers
        $rawExcludeValues = $input->getOption('exclude') ?? [];
        $rawIncludeValues = $input->getOption('include') ?? [];
        $excludeEntities = \is_array($rawExcludeValues) ? $rawExcludeValues : [$rawExcludeValues];
        $includeEntities = \is_array($rawIncludeValues) ? $rawIncludeValues : [$rawIncludeValues];
        $repository = $schemaManager->collectAuditableEntities();
        $filteredRepository = [];

        foreach ($repository as $name => $entityClasses) {
            foreach ($entityClasses as $entityClass => $table) {
                if (
                    !\in_array($entityClass, $excludeEntities, true)
                    && (
                        empty($includeEntities)
                        || \in_array($entityClass, $includeEntities, true)
                    )
                ) {
                    $filteredRepository[$name][$entityClass] = $table;
                }
            }
        }

        $repository = $filteredRepository;

        foreach ($repository as $name => $entities) {
            $count += \count($entities);
        }

        $message = sprintf(
            "You are about to clean audits created before <comment>%s</comment>: %d classes involved.\n Do you want to proceed?",
            $until->format(self::UNTIL_DATE_FORMAT),
            $count
        );

        $confirm = $input->getOption('no-confirm') ? true : $io->confirm($message, false);
        $dryRun = (bool) $input->getOption('dry-run');
        $dumpSQL = (bool) $input->getOption('dump-sql');

        if ($confirm) {
            /** @var Configuration $configuration */
            $configuration = $provider->getConfiguration();

            $progressBar = new ProgressBar($output, $count);
            $progressBar->setBarWidth(70);
            $progressBar->setFormat("%message%\n".$progressBar->getFormatDefinition('debug'));

            $progressBar->setMessage('Starting...');
            $progressBar->start();

            $queries = [];

            /**
             * @var string                $name
             * @var array<string, string> $classes
             */
            foreach ($repository as $name => $classes) {
                foreach ($classes as $entity => $tablename) {
                    $connection = $storageServices[$name]->getEntityManager()->getConnection();
                    $auditTable = $schemaManager->resolveAuditTableName($entity, $configuration, $connection->getDatabasePlatform());

                    $queryBuilder = $connection->createQueryBuilder();
                    $queryBuilder
                        ->delete($auditTable)
                        ->where('created_at < :until')
                        ->setParameter('until', $until->format(self::UNTIL_DATE_FORMAT))
                    ;

                    if ($dumpSQL) {
                        $queries[] = str_replace(':until', "'".$until->format(self::UNTIL_DATE_FORMAT)."'", $queryBuilder->getSQL());
                    }

                    if (!$dryRun) {
                        DoctrineHelper::executeStatement($queryBuilder);
                    }

                    $progressBar->setMessage(sprintf('Cleaning audit tables... (<info>%s</info>)', $auditTable));
                    $progressBar->advance();
                }
            }

            $progressBar->setMessage('Cleaning audit tables... (<info>done</info>)');
            $progressBar->display();

            $io->newLine();
            if ($dumpSQL) {
                $io->newLine();
                $io->writeln('SQL queries to be run:');
                foreach ($queries as $query) {
                    $io->writeln($query);
                }
            }

            $io->newLine();
            $io->success('Success.');
        } else {
            $io->success('Cancelled.');
        }

        // if not released explicitly, Symfony releases the lock
        // automatically when the execution of the command ends
        $this->release();

        return Command::SUCCESS;
    }