Graviton\CoreBundle\Command\DirectImportCommand::execute()

Complexity

Conditions	39
Paths	5664

Size

Total Lines	206
Code Lines	131

Duplication

Lines	61
Ratio	29.61 %

Importance

Changes	1
Bugs	0	Features	0

<?php
    protected function execute(InputInterface $input, OutputInterface $output)
    {
        $location = $input->getArgument('location');

        $this->container = $container = $this->getContainer();

$container = $this->getContainer() is of type object<Symfony\Component\DependencyInjection\ContainerInterface>, but the property $container was declared to be of type object<Symfony\Component\DependencyInjection\Container>. Are you sure that you always receive this specific sub-class here, or does it make sense to add an instanceof check?

        $this->modelTranslatable = $container->get('graviton.i18n.model.translatable');
        /** @var DocumentManager $documentManager */
        $documentManager = $container->get('doctrine_mongodb.odm.default_document_manager');

        $output->writeln('Importing from: '.$location);

        /**
         * @param SplFileInfo $file
         * @return bool
         */
        $filter = function (SplFileInfo $file) {
            if ($file->getExtension() !== 'yml' || $file->isDir()) {
                return false;
            }
            return true;
        };

        $finder  = new Finder();
        $finder->files()->in($location)->ignoreDotFiles(true)->filter($filter);

        $totalFiles = $finder->count();
        $progress = new ProgressBar($output, $totalFiles);
        $errors = [];
        $success = [];

        // CoreTypes and Refferences
        $referenceObjects = [];

        // Do this by rest
        $restObjects = [];

        /** @var SplFileInfo $file */
        foreach ($finder as $file) {
            $fileName = str_replace($location, '', $file->getPathname());

            $progress->advance();

            $contents = explode('---', $file->getContents());
            if (!$contents || count($contents)!==3) {

The expression $contents 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.

                $errors[$fileName] = 'Content of file is incorrect, could not parse it with --- ';
                continue;
            }

            $target = trim(str_replace('target:', '', $contents[1]));
            $yaml = $contents[2];

            // Make Service Name:
            $targets = explode('/', $target);
            if (!$targets || count($targets)<3) {

The expression $targets 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.

                $errors[$fileName] = 'Target is not correctly defined: '.json_encode($targets);
                continue;
            }
            $domain = $targets[1];

            try {
                $data = Yaml::parse($yaml);
            } catch (ParseException $e) {
                $errors[$fileName] = 'Could not parse yml file';
                continue;
            }

            if (!$data) {

The expression $data 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.

                $errors[$fileName] = 'Yml file is empty or parsed as empty.';
                continue;
            }

            // Locate class name graviton.i18n.document.language
            $service = $this->findServiceObject($targets, $fileName);
            $objectClass = $service['class'];
            $serviceName = $service['service'];

            if (!$objectClass) {
                $restObjects[] = ['target'=> $target, 'data' =>$data];
                continue;
            }

            if (array_key_exists('items', $data) && is_array($data['items'])) {
                foreach ($data['items'] as $item) {

This code seems to be duplicated across your project.

                    $object = clone $objectClass;
                    $translated = [];
                    if ($object instanceof TranslatableDocumentInterface) {
                        $translated = $object->getTranslatableFields();
                    }
                    if (is_object($object)) {
                        foreach ($item as $key => $value) {
                            $method = 'set' . ucfirst($key);
                            if (method_exists($object, $method)) {
                                if (is_array($value) && in_array($key, $translated)) {
                                    $this->generateLanguages($domain, $value);
                                } elseif (is_array($value)) {
                                    $referenceObjects[$key] = [
                                        'data'    => $data,
                                        'file'    => $fileName,
                                        'service' => $serviceName
                                    ];
                                } else {
                                    try {
                                        $object->$method($value);
                                    } catch (\Exception $e) {
                                        $errors[$fileName] = 'Method: '.$method.
                                            ' with:'.$value.' error:'.$e->getMessage();
                                        continue;
                                    }
                                }
                            }
                        }
                        $documentManager->persist($object);
                    }
                }
            } else {
                $object = clone $objectClass;
                $method = false;
                $id = false;
                foreach ($data as $key => $value) {

This code seems to be duplicated across your project.

                    $translated = [];
                    if ($object instanceof TranslatableDocumentInterface) {
                        $translated = $object->getTranslatableFields();
                    }
                    if ($key == 'id') {
                        $id = $value;
                    }
                    $method = 'set' . ucfirst($key);
                    if (method_exists($object, $method)) {
                        if (is_array($value) && in_array($key, $translated)) {
                            $this->generateLanguages($domain, $value, $id);
                            $object->$method(reset($value));
                        } elseif (is_array($value)) {
                            $referenceObjects[$key] = [
                                'data'    => $data,
                                'file'    => $fileName,
                                'service' => $serviceName
                            ];
                        } else {
                            try {
                                $object->$method($value);
                            } catch (\Exception $e) {
                                $errors[$fileName] = 'Method: '.$method.' with:'.$value.' error:'.$e->getMessage();
                                continue;
                            }
                        }
                    }
                }
                if ($method) {

The expression $method of type false|string is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== false instead.

                    $documentManager->persist($object);
                }
            }

            try {
                $documentManager->flush();
                $documentManager->clear();
            } catch (\Exception $e) {
                $errors[$fileName] = 'Save error:'.$e->getMessage();
                continue;
            }
            $success[] = $fileName;
        }

        $progress->finish();

        // Resume:
        $inserted = $totalFiles - count($restObjects) - count($errors);
        $output->writeln("\n".'<info>Inserted Objects:'.$inserted.'</info>');

        // REST $restObjects
        if ($restObjects) {

The expression $restObjects 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.

            $output->writeln("\n".'Rest Objects:'.count($restObjects));
            $errorsRest = $this->putRestObject($restObjects, $output);
            $errors = array_merge($errors, $errorsRest);
        }

        // Referenced object update
        if ($referenceObjects) {

The expression $referenceObjects 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.

            $output->writeln("\n".'References Updating: '.count($referenceObjects));
            $errorsRefs = $this->updateReferences($referenceObjects, $output);
            $errors = array_merge($errors, $errorsRefs);
        }


        // Output's
        $output->writeln("\n".'<error>============ Errors: '.count($errors).' ============</error>');
        if (!$errors) {

The expression $errors 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.

            $output->writeln('<comment>Done without errors</comment>');
        } else {
            foreach ($errors as $fileName => $error) {
                $errString = is_array($error) ? json_encode($error) : $error;
                $output->writeln("<comment>$fileName : $errString</comment>");
            }
        }

        $documentManager->flush();
        $output->writeln("\n".'<info>============ Success: '.count($success).' ============</info>');
        if (!$success) {

The expression $success 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.

            $output->writeln('No files imported');
        }

        $output->writeln('<info>============ End ============</info>'."\n");
        if (count($errors)) {
            $output->writeln('<error>============ Errors: '.count($errors).', please review ============</error>'."\n");
        }

    }