DirectImportCommand::updateReferences() - Code Metrics - Inspection of "Fast import of initial YML data files" - libgraviton/graviton - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — feature/directimport-for-initi... ( 2461f0 )

unknown

created 2016-03-07 13:55 UTC

DirectImportCommand::updateReferences() B

↳ Parent: DirectImportCommand

Complexity

Conditions	4
Paths	4

Size

Total Lines	47
Code Lines	31

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	47
rs	8.6845
cc	4
eloc	31
nc	4
nop	2

<?php
/**
 * Created by PhpStorm.
 * User: taachja1
 * Date: 03/03/16
 * Time: 16:42
 *
 * Import direct into db
 *
 * php vendor/graviton/graviton/bin/graviton DirectImportCommand:initialData /path-to-data-folder
 * Run first /initial and then /data
 */

namespace Graviton\CoreBundle\Command;

use Graviton\I18nBundle\Document\TranslatableDocumentInterface;
use GuzzleHttp\Client;
use GuzzleHttp\Exception\ClientException;
use GuzzleHttp\Exception\ServerException;
use Symfony\Bundle\FrameworkBundle\Command\ContainerAwareCommand;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\DependencyInjection\Container;
use Symfony\Component\Finder\Finder;
use Symfony\Component\Finder\SplFileInfo;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\Yaml\Exception\ParseException;
use Symfony\Component\Yaml\Yaml;
use Graviton\I18nBundle\Document\Translatable;
use Graviton\I18nBundle\Model\Translatable as ModelTranslatable;
use Symfony\Component\Console\Helper\ProgressBar;
use Doctrine\ODM\MongoDB\DocumentManager;
use Graviton\RestBundle\Validator\Form;
use Graviton\ExceptionBundle\Exception\ValidationException;
use Graviton\DocumentBundle\Service\FormDataMapperInterface;
use Graviton\RestBundle\Model\DocumentModel;

/**
 * Class DirectImportCommand
 * @package Graviton\CoreBundle\Command
 * @author  List of contributors <https://github.com/libgraviton/graviton/graphs/contributors>
 * @license http://opensource.org/licenses/gpl-license.php GNU Public License
 * @link    http://swisscom.ch
 * @return  void
 */
class DirectImportCommand extends ContainerAwareCommand
{
    /** @var ModelTranslatable */
    protected $modelTranslatable;

    /** @var Container */
    protected $container;

    /**
     * Starting Command
     * @return void
     */
    protected function configure()
    {
        $this
            ->setName('DirectImportCommand:initialData')
            ->setDescription('Greet someone')
            ->addArgument('location', InputArgument::REQUIRED, 'Full path to location of folder to import');
    }

    /**
     * @param  InputInterface  $input  Sf command line input
     * @param  OutputInterface $output Sf command line output
     * @return void
     */
    protected function execute(InputInterface $input, OutputInterface $output)
    {
        $location = $input->getArgument('location');

        $this->container = $container = $this->getContainer();
class Alien {}

class Dalek extends Alien {}

class Plot
{
    /** @var  Dalek */
    public $villain;
}

$alien = new Alien();
$plot = new Plot();
if ($alien instanceof Dalek) {
    $plot->villain = $alien;
}
        $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) {

                $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) {

                $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) {

                $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) {

                    $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) {

                    $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) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
                    $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) {

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

        // Referenced object update
        if ($referenceObjects) {

            $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) {

            $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) {

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

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

    }



    /**
     * generate strings for languages
     *
     * @param string      $domain     Domain Name
     * @param array       $languages  Translated language values
     * @param string|bool $idLanguage Id to reference name
     *
     * @return void
     */
    private function generateLanguages($domain, $languages, $idLanguage = false)
    {
        foreach ($languages as $language => $translation) {
            if ($idLanguage) {
                $id = implode('-', array($domain, $idLanguage, $translation));
            } else {
                $id = implode('-', array($domain, $language, $translation));
            }

            $record = new Translatable;
            $record->setId($id);
            $record->setDomain($domain);
            $record->setLocale($language);
            $record->setOriginal($translation);
            $this->modelTranslatable->insertRecord($record);
        }
    }

    /**
     * Some Objects can be done by inserting directly.
     *
     * @param  array           $restObjects Array of data to be sent via rest
     * @param  OutputInterface $output      Sf command line output for progress
     * @return array
     */
    private function putRestObject($restObjects, $output)
    {
        $errors = [];
        $progress = new ProgressBar($output, count($restObjects));
        $client = new Client();

        /** @var SplFileInfo $file */
        foreach ($restObjects as $values) {
            $progress->advance();
            $target = $values['target'];
            $json = [
                'json' => $values['data']
            ];
            try {
                $client->request(
                    'PUT',
                    'http://localhost:8000' . $target,
                    $json
                );
            } catch (ServerException $e) {
                $errors['REST server: ' . $target] = $e->getMessage() . ' Json:' . json_encode($json);
            } catch (ClientException $e) {
                $errors['REST client: ' . $target] = $e->getMessage() . ' Json:' . json_encode($json);
            }
        }
        $progress->finish();

        return $errors;
    }

    /**
     * @param array           $referenceObjects Array of objects to be referenced
     * @param OutputInterface $output           Command line output
     * @return array
     */
    private function updateReferences($referenceObjects, $output)
    {
        $errors = [];
        $progress = new ProgressBar($output, count($referenceObjects));

        /** @var Form $formValidator */
        $formValidator = $this->container->get('graviton.rest.validator.form');
        /** @var FormDataMapperInterface $formDataMapper */
        $formDataMapper = $this->container->get('graviton.document.service.formdatamapper');
        $request = new Request();
        $request->setMethod('PUT');

        foreach ($referenceObjects as $id => $ref) {
            $progress->advance();
            // Get Reference
            $data = $ref['data'];
            $fileName = $ref['file'];
            $model = str_replace('.document.', '.model.', $ref['service']);

            if ($this->container->has($model)) {
                /** @var DocumentModel $modelClass */
                $modelClass = $this->container->get($model);
                $formValidator->getForm($request, $modelClass);
                $form = $formValidator->getForm($request, $modelClass);

                try {
                    $record = $formValidator->checkForm(
                        $form,
                        $modelClass,
                        $formDataMapper,
                        json_encode($data)
                    );
                } catch (ValidationException $e) {
                    $err = $formValidator->getErrorMessages($form);
                    $errors[] = $fileName.': '.$id . ': '.json_encode($err);
                    continue;
                }

                $modelClass->updateRecord($id, $record);
            } else {
                $errors[] = $fileName . ': Model not found to make relation';
            }
        }

        $progress->finish();
        return $errors;
    }

    /**
     * @param array  $targets  Path parts to service
     * @param string $fileName File name for easier find error.
     * @return array
     */
    private function findServiceObject($targets, $fileName)
    {
        // Locate class name graviton.i18n.document.language
        $cleanedName = $targets[1].str_replace('refi-', '', $targets[2]);
        $serviceNames = [
            'gravitondyn.'.$cleanedName.'.document.'.$cleanedName,
            'gravitondyn.evojabasics'.$cleanedName.'.document.evojabasics'.$cleanedName,
            'gravitondyn.'.$targets[2].'.document.'.$targets[2],
            'graviton.'.$targets[1].'.document.'.$targets[2]
        ];
        $objectClass = false;
        $serviceName = false;
        foreach ($serviceNames as $serviceName) {
            $serviceName = strtolower(str_replace('-', '', $serviceName));
            if ($this->container->has($serviceName)) {
                try {
                    $objectClass = $this->container->get($serviceName);
                } catch (\Exception $e) {
                    $errors[$fileName] = 'Service name not found: '.$serviceName;
foreach ($collection as $item) {
    $myArray['foo'] = $item->getFoo();

    if ($item->hasBar()) {
        $myArray['bar'] = $item->getBar();
    }

    // do something with $myArray
}
                }
                break;
            }
        }

        return [
            'class' => $objectClass,
            'service' => $serviceName
        ];
    }
}


1			<?php
2			/**
3			* Created by PhpStorm.
4			* User: taachja1
5			* Date: 03/03/16
6			* Time: 16:42
7			*
8			* Import direct into db
9			*
10			* php vendor/graviton/graviton/bin/graviton DirectImportCommand:initialData /path-to-data-folder
11			* Run first /initial and then /data
12			*/
13
14			namespace Graviton\CoreBundle\Command;
15
16			use Graviton\I18nBundle\Document\TranslatableDocumentInterface;
17			use GuzzleHttp\Client;
18			use GuzzleHttp\Exception\ClientException;
19			use GuzzleHttp\Exception\ServerException;
20			use Symfony\Bundle\FrameworkBundle\Command\ContainerAwareCommand;
21			use Symfony\Component\Console\Input\InputArgument;
22			use Symfony\Component\Console\Input\InputInterface;
23			use Symfony\Component\Console\Output\OutputInterface;
24			use Symfony\Component\DependencyInjection\Container;
25			use Symfony\Component\Finder\Finder;
26			use Symfony\Component\Finder\SplFileInfo;
27			use Symfony\Component\HttpFoundation\Request;
28			use Symfony\Component\Yaml\Exception\ParseException;
29			use Symfony\Component\Yaml\Yaml;
30			use Graviton\I18nBundle\Document\Translatable;
31			use Graviton\I18nBundle\Model\Translatable as ModelTranslatable;
32			use Symfony\Component\Console\Helper\ProgressBar;
33			use Doctrine\ODM\MongoDB\DocumentManager;
34			use Graviton\RestBundle\Validator\Form;
35			use Graviton\ExceptionBundle\Exception\ValidationException;
36			use Graviton\DocumentBundle\Service\FormDataMapperInterface;
37			use Graviton\RestBundle\Model\DocumentModel;
38
39			/**
40			* Class DirectImportCommand

libgraviton / graviton

Push — feature/directimport-for-initi... ( 2461f0 )

DirectImportCommand::updateReferences() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like