ImportCommand::writeValidationViolations() - Code Metrics - Inspection of "better exception checking" - mathielen/ImportEngineBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( f25de2...487eea )

by Markus

created 2016-02-09 13:53 UTC

ImportCommand::writeValidationViolations() C

↳ Parent: ImportCommand

Complexity

Conditions	8
Paths	25

Size

Total Lines	40
Code Lines	23

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	50.086

Importance

Changes	5
Bugs	1	Features	2

Metric	Value
c	5
b	1
f	2
dl	0
loc	40
ccs	3
cts	23
cp	0.1303
rs	5.3846
cc	8
eloc	23
nc	25
nop	2
crap	50.086

<?php
namespace Mathielen\ImportEngineBundle\Command;

use Ddeboer\DataImport\Filter\OffsetFilter;
use Mathielen\DataImport\Event\ImportItemEvent;
use Mathielen\ImportEngine\Event\ImportConfigureEvent;
use Mathielen\ImportEngine\Event\ImportRequestEvent;
use Mathielen\ImportEngine\Exception\InvalidConfigurationException;
use Mathielen\ImportEngine\Import\ImportBuilder;
use Mathielen\ImportEngine\Import\Run\ImportRunner;
use Mathielen\ImportEngine\ValueObject\ImportRequest;
use Mathielen\ImportEngine\ValueObject\ImportRun;
use Mathielen\ImportEngineBundle\Utils;
use Symfony\Bundle\FrameworkBundle\Command\ContainerAwareCommand;
use Symfony\Component\Console\Helper\ProgressBar;
use Symfony\Component\Console\Helper\Table;
use Symfony\Component\Console\Helper\TableSeparator;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Validator\ConstraintViolation;

class ImportCommand extends ContainerAwareCommand
{

    const MAX_VIOLATION_ERRORS = 10;

    protected function configure()
    {
        $this->setName('importengine:import')
            ->setDescription('Imports data with a definied importer')
            ->addArgument('source_id', InputArgument::REQUIRED, "id of source. Different StorageProviders need different id data.\n- upload, directory: \"<path/to/file>\"\n- doctrine: \"<id of query>\"\n- service: \"<service>.<method>[?arguments_like_url_query]\"")
            ->addArgument('source_provider', InputArgument::OPTIONAL, 'id of source provider', 'default')
            ->addOption('importer', 'i', InputOption::VALUE_REQUIRED, 'id/name of importer')
            ->addOption('context', 'c', InputOption::VALUE_REQUIRED, 'Supply optional context information to import. Supply key-value data in query style: key=value&otherkey=othervalue&...')
            ->addOption('limit', 'l', InputOption::VALUE_REQUIRED, 'Limit imported rows')
            ->addOption('dryrun', 'd', InputOption::VALUE_NONE, 'Do not import - Validation only')
        ;
    }

    protected function validateInput(InputInterface $input)

    {
        if (!$this->getContainer()->has('mathielen_importengine.import.builder') ||
            !$this->getContainer()->has('mathielen_importengine.import.runner')) {
            throw new InvalidConfigurationException("No importengine services have been found. Did you register the bundle in AppKernel and configured at least one importer in config?");
        }
    }

    protected function execute(InputInterface $input, OutputInterface $output)
    {
        $this->validateInput($input);

        $importerId = $input->getOption('importer');
        $sourceProviderId = $input->getArgument('source_provider');
        $sourceId = $input->getArgument('source_id');
        $isDryrun = $input->getOption('dryrun');
        if ($context = $input->getOption('context')) {
            //parse key=value&key=value string to array
            if (strpos($context, '=') !== false) {
                parse_str($input->getOption('context'), $context);
            }
        }
        $limit = $input->getOption('limit');

        $this->import($output, $importerId, $sourceProviderId, $sourceId, $context, $limit, $isDryrun);
    }

    protected function import(OutputInterface $output, $importerId, $sourceProviderId, $sourceId, $context=null, $limit=null, $isDryrun=false)
    {
        $output->writeln("Commencing ".($isDryrun?'<comment>dry-run</comment> ':'')."import using importer ".(empty($importerId)?'<comment>unknown</comment>':"<info>$importerId</info>")." with source provider <info>$sourceProviderId</info> and source id <info>$sourceId</info>");

        $sourceId = Utils::parseSourceId($sourceId);
        $progress = new ProgressBar($output);

        //set limit
        if ($limit) {
            $output->writeln("Limiting import to <info>$limit</info> rows.");

            $this->getContainer()->get('event_dispatcher')->addListener(ImportConfigureEvent::AFTER_BUILD, function (ImportConfigureEvent $event) use ($limit) {
                $event->getImport()->importer()->filters()->add(new OffsetFilter(0, $limit));
            });
        }

        //show discovered importer id
        if (empty($importerId)) {
            $this->getContainer()->get('event_dispatcher')->addListener(ImportRequestEvent::DISCOVERED, function (ImportRequestEvent $event) use ($output) {
                $importerId = $event->getImportRequest()->getImporterId();
                $output->writeln("Importer discovered: <info>$importerId</info>");
            });
        }

        /** @var ImportBuilder $importBuilder */
        $importBuilder = $this->getContainer()->get('mathielen_importengine.import.builder');

        $importRequest = new ImportRequest($sourceId, $sourceProviderId, $importerId, Utils::whoAmI().'@CLI');

        $import = $importBuilder->buildFromRequest($importRequest);

        //apply context info from commandline
        $importRun = $import->getRun();
        if ($context) {
            $importRun->setContext($context);
        }

        //status callback
        $this->getContainer()->get('event_dispatcher')->addListener(ImportItemEvent::AFTER_READ, function (ImportItemEvent $event) use ($output, &$progress) {
            /** @var ImportRun $importRun */
            $importRun = $event->getContext()->getRun();
            $stats = $importRun->getStatistics();
            $processed = isset($stats['processed'])?$stats['processed']:0;
            $max = $importRun->getInfo()['count'];

            if ($progress->getMaxSteps() != $max) {
                $progress = new ProgressBar($output, $max);
                $progress->start();
            }

            $progress->setProgress($processed);
        });

        /** @var ImportRunner $importRunner */
        $importRunner = $this->getContainer()->get('mathielen_importengine.import.runner');
        if ($isDryrun) {
            $importRunner->dryRun($import);
        } else {
            $importRunner->run($import);
        }

        $progress->finish();
        $output->writeln('');
        $output->writeln("<info>Import done</info>");
        $output->writeln('');

        $this->writeStatistics($importRun->getStatistics(), new Table($output));

        $this->writeValidationViolations(
            $import
                ->importer()
                ->validation()
                ->getViolations(),
            new Table($output));

        $output->writeln('');
    }

    protected function writeValidationViolations(array $violations, Table $table)
    {
        if (empty($violations)) {
            return;
        }
        $violations = $violations['source'] + $violations['target'];

        $table
            ->setHeaders(array('Constraint', 'Occurrences (lines)'))
        ;

        $tree = [];
        foreach ($violations as $line=>$validations) {
            /** @var ConstraintViolation $validation */
            foreach ($validations as $validation) {
                $key = $validation->__toString();
                if (!isset($tree[$key])) {
                    $tree[$key] = [];
                }
                $tree[$key][] = $line;
            }
        }

        $i = 0;
        foreach ($tree as $violation=>$lines) {
            $table->addRow([$violation, join(', ', Utils::numbersToRangeText($lines))]);
            ++$i;

            if ($i === self::MAX_VIOLATION_ERRORS) {
                $table->addRow(new TableSeparator());
                $table->addRow(array(null, 'There are more errors...'));

                break;
            }
        }

        if ($i > 0) {
            $table->render();
        }
    }

    protected function writeStatistics(array $statistics, Table $table)
    {
        $rows = [];
        foreach ($statistics as $k=>$v) {
            $rows[] = [$k, $v];
        }

        $table
            ->setHeaders(array('Statistics'))
            ->setRows($rows)
        ;
        $table->render();
    }

}


1		<?php
2		namespace Mathielen\ImportEngineBundle\Command;
3
4		use Ddeboer\DataImport\Filter\OffsetFilter;
5		use Mathielen\DataImport\Event\ImportItemEvent;
6		use Mathielen\ImportEngine\Event\ImportConfigureEvent;
7		use Mathielen\ImportEngine\Event\ImportRequestEvent;
8		use Mathielen\ImportEngine\Exception\InvalidConfigurationException;
9		use Mathielen\ImportEngine\Import\ImportBuilder;
10		use Mathielen\ImportEngine\Import\Run\ImportRunner;
11		use Mathielen\ImportEngine\ValueObject\ImportRequest;
12		use Mathielen\ImportEngine\ValueObject\ImportRun;
13		use Mathielen\ImportEngineBundle\Utils;
14		use Symfony\Bundle\FrameworkBundle\Command\ContainerAwareCommand;
15		use Symfony\Component\Console\Helper\ProgressBar;
16		use Symfony\Component\Console\Helper\Table;
17		use Symfony\Component\Console\Helper\TableSeparator;
18		use Symfony\Component\Console\Input\InputArgument;
19		use Symfony\Component\Console\Input\InputInterface;
20		use Symfony\Component\Console\Input\InputOption;
21		use Symfony\Component\Console\Output\OutputInterface;
22		use Symfony\Component\Validator\ConstraintViolation;
23
24		class ImportCommand extends ContainerAwareCommand
25		{
26
27		const MAX_VIOLATION_ERRORS = 10;
28
29	4	protected function configure()
30		{
31	4	$this->setName('importengine:import')
32	4	->setDescription('Imports data with a definied importer')
33	4	->addArgument('source_id', InputArgument::REQUIRED, "id of source. Different StorageProviders need different id data.\n- upload, directory: \"<path/to/file>\"\n- doctrine: \"<id of query>\"\n- service: \"<service>.<method>[?arguments_like_url_query]\"")
34	4	->addArgument('source_provider', InputArgument::OPTIONAL, 'id of source provider', 'default')
35	4	->addOption('importer', 'i', InputOption::VALUE_REQUIRED, 'id/name of importer')
36	4	->addOption('context', 'c', InputOption::VALUE_REQUIRED, 'Supply optional context information to import. Supply key-value data in query style: key=value&otherkey=othervalue&...')
37	4	->addOption('limit', 'l', InputOption::VALUE_REQUIRED, 'Limit imported rows')
38	4	->addOption('dryrun', 'd', InputOption::VALUE_NONE, 'Do not import - Validation only')
39		;
40	4	}
41
42	4	protected function validateInput(InputInterface $input)
		0 ignored issues – show Unused Code introduced 2015-12-04 08:37 UTC by Report Bug Copy Issue Report The parameter `$input` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
43		{
44	4	if (!$this->getContainer()->has('mathielen_importengine.import.builder') \|\|
45	4	!$this->getContainer()->has('mathielen_importengine.import.runner')) {
46		throw new InvalidConfigurationException("No importengine services have been found. Did you register the bundle in AppKernel and configured at least one importer in config?");
47		}
48	4	}
49
50	4	protected function execute(InputInterface $input, OutputInterface $output)
51		{
52	4	$this->validateInput($input);
53
54	4	$importerId = $input->getOption('importer');
55	4	$sourceProviderId = $input->getArgument('source_provider');
56	4	$sourceId = $input->getArgument('source_id');
57	4	$isDryrun = $input->getOption('dryrun');
58	4	if ($context = $input->getOption('context')) {
59		//parse key=value&key=value string to array
60		if (strpos($context, '=') !== false) {
61		parse_str($input->getOption('context'), $context);
62		}
63		}
64	4	$limit = $input->getOption('limit');
65
66	4	$this->import($output, $importerId, $sourceProviderId, $sourceId, $context, $limit, $isDryrun);
67	4	}
68
69	4	protected function import(OutputInterface $output, $importerId, $sourceProviderId, $sourceId, $context=null, $limit=null, $isDryrun=false)
70		{
71	4	$output->writeln("Commencing ".($isDryrun?'<comment>dry-run</comment> ':'')."import using importer ".(empty($importerId)?'<comment>unknown</comment>':"<info>$importerId</info>")." with source provider <info>$sourceProviderId</info> and source id <info>$sourceId</info>");
72
73	4	$sourceId = Utils::parseSourceId($sourceId);
74	4	$progress = new ProgressBar($output);
75
76		//set limit
77	4	if ($limit) {
78	1	$output->writeln("Limiting import to <info>$limit</info> rows.");
79
80		$this->getContainer()->get('event_dispatcher')->addListener(ImportConfigureEvent::AFTER_BUILD, function (ImportConfigureEvent $event) use ($limit) {
81		$event->getImport()->importer()->filters()->add(new OffsetFilter(0, $limit));
82	1	});
83		}
84
85		//show discovered importer id
86	4	if (empty($importerId)) {
87		$this->getContainer()->get('event_dispatcher')->addListener(ImportRequestEvent::DISCOVERED, function (ImportRequestEvent $event) use ($output) {
88		$importerId = $event->getImportRequest()->getImporterId();
89		$output->writeln("Importer discovered: <info>$importerId</info>");
90	2	});
91		}
92
93		/** @var ImportBuilder $importBuilder */
94	4	$importBuilder = $this->getContainer()->get('mathielen_importengine.import.builder');
95
96	4	$importRequest = new ImportRequest($sourceId, $sourceProviderId, $importerId, Utils::whoAmI().'@CLI');
97
98	4	$import = $importBuilder->buildFromRequest($importRequest);
99
100		//apply context info from commandline
101	4	$importRun = $import->getRun();
102	4	if ($context) {
103		$importRun->setContext($context);
104		}
105
106		//status callback
107	4	$this->getContainer()->get('event_dispatcher')->addListener(ImportItemEvent::AFTER_READ, function (ImportItemEvent $event) use ($output, &$progress) {
108		/** @var ImportRun $importRun */
109		$importRun = $event->getContext()->getRun();
110		$stats = $importRun->getStatistics();
111		$processed = isset($stats['processed'])?$stats['processed']:0;
112		$max = $importRun->getInfo()['count'];
113
114		if ($progress->getMaxSteps() != $max) {
115		$progress = new ProgressBar($output, $max);
116		$progress->start();
117		}
118
119		$progress->setProgress($processed);
120	4	});
121
122		/** @var ImportRunner $importRunner */
123	4	$importRunner = $this->getContainer()->get('mathielen_importengine.import.runner');
124	4	if ($isDryrun) {
125	1	$importRunner->dryRun($import);
126		} else {
127	3	$importRunner->run($import);
128		}
129
130	4	$progress->finish();
131	4	$output->writeln('');
132	4	$output->writeln("<info>Import done</info>");
133	4	$output->writeln('');
134
135	4	$this->writeStatistics($importRun->getStatistics(), new Table($output));
136
137	4	$this->writeValidationViolations(
138		$import
139	4	->importer()
140	4	->validation()
141	4	->getViolations(),
142	4	new Table($output));
143
144	4	$output->writeln('');
145	4	}
146
147	4	protected function writeValidationViolations(array $violations, Table $table)
148		{
149	4	if (empty($violations)) {
150	4	return;
151		}
152		$violations = $violations['source'] + $violations['target'];
153
154		$table
155		->setHeaders(array('Constraint', 'Occurrences (lines)'))
156		;
157
158		$tree = [];
159		foreach ($violations as $line=>$validations) {
160		/** @var ConstraintViolation $validation */
161		foreach ($validations as $validation) {
162		$key = $validation->__toString();
163		if (!isset($tree[$key])) {
164		$tree[$key] = [];
165		}
166		$tree[$key][] = $line;
167		}
168		}
169
170		$i = 0;
171		foreach ($tree as $violation=>$lines) {
172		$table->addRow([$violation, join(', ', Utils::numbersToRangeText($lines))]);
173		++$i;
174
175		if ($i === self::MAX_VIOLATION_ERRORS) {
176		$table->addRow(new TableSeparator());
177		$table->addRow(array(null, 'There are more errors...'));
178
179		break;
180		}
181		}
182
183		if ($i > 0) {
184		$table->render();
185		}
186		}
187
188	4	protected function writeStatistics(array $statistics, Table $table)
189		{
190	4	$rows = [];
191	4	foreach ($statistics as $k=>$v) {
192		$rows[] = [$k, $v];
193		}
194
195		$table
196	4	->setHeaders(array('Statistics'))
197	4	->setRows($rows)
198		;
199	4	$table->render();
200	4	}
201
202		}
203

mathielen / ImportEngineBundle

Push — master ( f25de2...487eea )

ImportCommand::writeValidationViolations() C

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like