chill-bundles/Command/CreateFieldsOnGroupCommand.php

<?php

/*
 * Chill is a software for social workers
 * Copyright (C) 2014 Champs-Libres Coopérative <info@champs-libres.coop>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

namespace Chill\CustomFieldsBundle\Command;

use Chill\CustomFieldsBundle\Service\CustomFieldProvider;
use Doctrine\ORM\EntityManager;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Helper\Table;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\OutputInterface;
use Chill\CustomFieldsBundle\Entity\CustomFieldsGroup;
use Symfony\Component\Console\Question\Question;
use Symfony\Component\Validator\Validator\ValidatorInterface;
use Symfony\Component\Yaml\Parser;
use Symfony\Component\Yaml\Exception\ParseException;
use Chill\CustomFieldsBundle\Entity\CustomField;

/**
 * Class for the command 'chill:custom_fields:populate_group' that
 * Create custom fields from a yml file
 *
 * @author Julien Fastré <julien.fastre@champs-libres.coop>
 * @author Marc Ducobu <marc.ducobu@champs-libres.coop>
 */
class CreateFieldsOnGroupCommand extends Command
{
    const ARG_PATH = 'path';
    const ARG_DELETE = 'delete';
    
    /**
     * @var CustomFieldProvider
     */
    private $customFieldProvider;
    
    /**
     * @var EntityManager
     */
    private $entityManager;
    
    /**
     * @var ValidatorInterface
     */
    private $validator;
    
    private $availableLanguages;
    private $customizablesEntities;
    
    /**
     * CreateFieldsOnGroupCommand constructor.
     *
     * @param CustomFieldProvider $customFieldProvider
     * @param EntityManager $entityManager
     * @param ValidatorInterface $validator
     * @param $availableLanguages
     * @param $customizablesEntities
     */
    public function __construct(
        CustomFieldProvider $customFieldProvider,
        EntityManager $entityManager,
        ValidatorInterface $validator,
        $availableLanguages,
        $customizablesEntities
    ) {
        $this->customFieldProvider = $customFieldProvider;
        $this->entityManager = $entityManager;
        $this->validator = $validator;
        $this->availableLanguages = $availableLanguages;
        $this->customizablesEntities = $customizablesEntities;
        parent::__construct();
    }
    
    protected function configure()
    {
        $this->setName('chill:custom_fields:populate_group')
            ->setDescription('Create custom fields from a yml file')
            ->addArgument(self::ARG_PATH, InputOption::VALUE_REQUIRED,
                'Path to description file')
            ->addOption(self::ARG_DELETE, null, InputOption::VALUE_NONE,
                'If set, delete existing fields');
    }

    /**
     * Delete the existing custom fields for a given customFieldGroup
     *
     * @param CustomFieldsGroup $customFieldsGroup : The custom field group
     */
    protected function deleteFieldsForCFGroup($customFieldsGroup)
    {
        $em = $this->entityManager;

        foreach ($customFieldsGroup->getCustomFields() as $field) {
            $em->remove($field);
        }
    }
    
    /**
     * @param InputInterface $input
     * @param OutputInterface $output
     * @return int|null|void
     */
    protected function execute(InputInterface $input, OutputInterface $output)
    {
        $helper = $this->getHelperSet()->get('question');
        
        $em = $this->entityManager;
        
        $customFieldsGroups = $em
            ->getRepository('ChillCustomFieldsBundle:CustomFieldsGroup')
            ->findAll();
        
        if (count($customFieldsGroups) === 0) {
            $output->writeln('<error>There aren\'t any CustomFieldsGroup recorded'
                . ' Please create at least one.</error>');
        } 
        
        $table = new Table($output);
        $table
            ->setHeaders(array_merge(
                ['id', 'entity'],
                $this->availableLanguages
            ))
            ->setRows($this->_prepareRows($customFieldsGroups))
            ->render()
        ;
        
        $question = new Question(
            "Enter the customfieldGroup's id on which the custom fields should be added: ");
        $question->setNormalizer(
            function($answer) use ($customFieldsGroups) {
                foreach ($customFieldsGroups as $customFieldsGroup) {
                    if ($answer == $customFieldsGroup->getId()) {
                        return $customFieldsGroup;
                    }
                }
                throw new \RunTimeException('The id does not match an existing '
                    . 'CustomFieldsGroup');
            }
        );
        $customFieldsGroup = $helper->ask($input, $output, $question);

        
        if ($input->getOption(self::ARG_DELETE)) {
            $this->deleteFieldsForCFGroup($customFieldsGroup);
        }
            
        $fieldsInput = $this->_parse($input->getArgument(self::ARG_PATH), 
            $output);
        
        $fields = $this->_addFields($customFieldsGroup, $fieldsInput, $output);
    }
    
    private function _prepareRows ($customFieldsGroups) 
    {
        $rows = array();
        $languages = $this->availableLanguages;
        //gather entitites and create an array to access them easily
        $customizableEntities = array();
        foreach ($this->customizablesEntities as $entry) {
            $customizableEntities[$entry['class']] = $entry['name'];
        }
        
        array_walk($customFieldsGroups, 
            function(CustomFieldsGroup $customFieldGroup, $key)
                use ($languages, &$rows, $customizableEntities) {
                    //set id and entity
                    $row = array(
                        $customFieldGroup->getId(),
                        $customizableEntities[$customFieldGroup->getEntity()]
                    );
                    
                    foreach ($languages as $lang) {
                        //todo replace with service to find lang when available
                        $row[] = (isset($customFieldGroup->getName()[$lang])) ?
                                $customFieldGroup->getName()[$lang] :
                            'Not available in this language';
                    }
                    $rows[] = $row;
                }
        );
              
        return $rows;
    }
    
    private function _parse($path, OutputInterface $output)
    {
        $parser = new Parser();
        
        if (!file_exists($path)) {
            throw new \RunTimeException("file does not exist");
        }
        
        try {
            $values = $parser->parse(file_get_contents($path));
        } catch (ParseException $ex) {
            throw new \RunTimeException("The yaml file is not valid", 0, $ex);
        }
        
        return $values;
    }
    
    private function _addFields(CustomFieldsGroup $group, $values, OutputInterface $output)
    {
        
        $em = $this->entityManager;

        $languages = $this->availableLanguages;
        
        foreach($values['fields'] as $slug => $field) {
            //check the cf type exists
            $cfType = $this->customFieldProvider->getCustomFieldByType($field['type']);
            if ($cfType === NULL) {
                throw new \RunTimeException('the type '.$field['type'].' '
                    . 'does not exists');
            }
            
            $cf = new CustomField();
            $cf->setSlug($slug)
                ->setName($field['name'])
                ->setOptions(isset($field['options']) ? $field['options'] : array() )
                ->setOrdering($field['ordering'])
                ->setType($field['type'])
                ->setCustomFieldsGroup($group);
            
            //add to table
            $names = array();
            foreach ($languages as $lang) {
                //todo replace with service to find lang when available
                $names[] = (isset($cf->getName()[$lang])) ?
                    $cf->getName()[$lang] :
                        'Not available in this language';
            }
            
            if ($this->validator->validate($cf)) {
                $em->persist($cf);
                $output->writeln("<info>Adding Custom Field of type "
                    .$cf->getType()."\t with slug ".$cf->getSlug().
                    "\t and names : ".implode($names, ', ')."</info>");
            } else {
                throw new \RunTimeException("Error in field ".$slug);
            }
        }
        
        $em->flush();
    }
}