Surfnet\StepupMiddleware\MiddlewareBundle\Console\Command\EmailVerifiedSecondFactorRemindersCommand

Complexity

Total Complexity

13

Size/Duplication

Total Lines	95
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

4 Methods

Rating	Name	Duplication	Size	Complexity
B	execute()	0	48	8
A	validateInput()	0	14	3
A	configure()	0	15	1
A	__construct()	0	7	1

<?php

/**
 * Copyright 2014 SURFnet bv
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

Missing @link tag in file comment

namespace Surfnet\StepupMiddleware\MiddlewareBundle\Console\Command;

use Assert\Assertion;
use DateInterval;
use DateTime;
use Exception;
use InvalidArgumentException;
use Psr\Log\LoggerInterface;
use Ramsey\Uuid\Uuid;
use Surfnet\StepupMiddleware\CommandHandlingBundle\EventHandling\BufferedEventBus;
use Surfnet\StepupMiddleware\CommandHandlingBundle\Identity\Command\SendVerifiedSecondFactorRemindersCommand;
use Surfnet\StepupMiddleware\CommandHandlingBundle\Pipeline\TransactionAwarePipeline;
use Surfnet\StepupMiddleware\MiddlewareBundle\Service\DBALConnectionHelper;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\OutputInterface;

/**
 * The EmailVerifiedSecondFactorRemindersCommand can be run to send reminders to token registrants.
 *
 * The command utilizes a specific service for this task (VerifiedSecondFactorReminderService). Input validation is
 * performed on the incoming request parameters.
 *
 * @SuppressWarnings(PHPMD.CouplingBetweenObjects)
 */

Missing @category tag in class comment

Missing @package tag in class comment

Missing @author tag in class comment

Missing @license tag in class comment

Missing @link tag in class comment

final class EmailVerifiedSecondFactorRemindersCommand extends Command
{
    protected static $defaultName = 'middleware:cron:email-reminder';

    protected function configure(): void
    {
        $this
            ->setDescription('Sends email reminders to identities with verified tokens more than 7 days old.')
            ->addOption(
                'dry-run',
                null,
                InputOption::VALUE_NONE,
                'Run in dry mode, not sending any email',
            )
            ->addOption(
                'date',
                null,
                InputOption::VALUE_OPTIONAL,
                'The date (Y-m-d) that should be used for sending reminder email messages, defaults to TODAY - 7',
            );
    }

    public function __construct(
        private readonly TransactionAwarePipeline $pipeline,
        private readonly BufferedEventBus $eventBus,
        private readonly DBALConnectionHelper $connection,
        private readonly LoggerInterface $logger,
    ) {
        parent::__construct();
    }

    protected function execute(InputInterface $input, OutputInterface $output): int
    {
        try {
            $this->validateInput($input);
        } catch (InvalidArgumentException $e) {
            $output->writeln('<error>' . $e->getMessage() . '</error>');
            $this->logger->error(sprintf('Invalid arguments passed to the %s', $this->getName()), [$e->getMessage()]);
            return 1;
        }

        $date = new DateTime();
        $date->sub(new DateInterval('P7D'));
        if ($input->hasOption('date') && !is_null($input->getOption('date'))) {
            $receivedDate = $input->getOption('date');
            $date = DateTime::createFromFormat('Y-m-d', $receivedDate);
            if ($date === false) {
                $output->writeln(
                    sprintf(
                        '<error>Error processing the "date" option. Please review the received input: "%s" </error>',
                        $receivedDate
                    )
                );
                return 1;
            }
        }

        $dryRun = false;
        if ($input->hasOption('dry-run') && !is_null($input->getOption('dry-run'))) {
            $dryRun = $input->getOption('dry-run');
        }

        $command = new SendVerifiedSecondFactorRemindersCommand();
        $command->requestedAt = $date;
        $command->dryRun = $dryRun;
        $command->UUID = Uuid::uuid4()->toString();

        $this->connection->beginTransaction();
        try {
            $this->pipeline->process($command);
            $this->eventBus->flush();

            $this->connection->commit();
        } catch (Exception $e) {
            $output->writeln('<error>An Error occurred while sending reminder email messages.</error>');
            $this->connection->rollBack();
            throw $e;
        }
        return 0;
    }

    private function validateInput(InputInterface $input): void

Private method name "EmailVerifiedSecondFactorRemindersCommand::validateInput" must be prefixed with an underscore

    {
        if ($input->hasOption('date')) {
            $date = $input->getOption('date');
            Assertion::nullOrDate(
                $date,
                'Y-m-d',
                'Expected date to be a string and formatted in the Y-m-d date format',
            );
        }

        if ($input->hasOption('dry-run')) {
            $dryRun = $input->getOption('dry-run');
            Assertion::nullOrBoolean($dryRun, 'Expected dry-run parameter to be a boolean value.');
        }
    }
}