ObjectListToStringTransformerGist.php

<?php
/** 
 * Date: 08-Oct-14
 * Time: 11:44
 */



use Doctrine\ORM\EntityManager;
use Symfony\Component\Form\DataTransformerInterface;
use Symfony\Component\Form\Exception\TransformationFailedException;
use Symfony\Component\OptionsResolver\OptionsResolver;
use Symfony\Component\OptionsResolver\OptionsResolverInterface;
use Symfony\Component\PropertyAccess\PropertyAccess;

class ObjectListToStringTransformer implements DataTransformerInterface {

    private $em;
    private $options;

    public function __construct(EntityManager $em, array $options)
    {
        $resolver = new OptionsResolver();
        $this->configureOptions($resolver);
        $this->options = $resolver->resolve($options);
        $this->em = $em;
    }

    /**
     * Transforms a value from the original representation to a transformed representation.
     *
     * This method is called on two occasions inside a form field:
     *
     * 1. When the form field is initialized with the data attached from the datasource (object or array).
     * 2. When data from a request is submitted using {@link Form::submit()} to transform the new input data
     *    back into the renderable format. For example if you have a date field and submit '2009-10-10'
     *    you might accept this value because its easily parsed, but the transformer still writes back
     *    "2009/10/10" onto the form field (for further displaying or other purposes).
     *
     * This method must be able to deal with empty values. Usually this will
     * be NULL, but depending on your implementation other empty values are
     * possible as well (such as empty strings). The reasoning behind this is
     * that value transformers must be chainable. If the transform() method
     * of the first value transformer outputs NULL, the second value transformer
     * must be able to process that value.
     *
     * By convention, transform() should return an empty string if NULL is
     * passed.
     *
     * @param mixed $objects The value in the original representation
     *
     * @return mixed The value in the transformed representation
     *
     * @throws TransformationFailedException When the transformation fails.
     */
    public function transform($objects)
    {
        echo "<hr>";
        if (null === $objects || sizeof($objects) == 0) {
            return new \Doctrine\Common\Collections\ArrayCollection();
        }
        $accessor = PropertyAccess::createPropertyAccessor();
        $return = "";
        $i = 0;
        foreach ($objects as $object) {
            $return .= $i != 0 ? $this->options['delimiter'] : '';
            $return .= $accessor->getValue($object, $this->options['property']);
        }
        return $return;
    }

    /**
     * Transforms a value from the transformed representation to its original
     * representation.
     *
     * This method is called when {@link Form::submit()} is called to transform the requests tainted data
     * into an acceptable format for your data processing/model layer.
     *
     * This method must be able to deal with empty values. Usually this will
     * be an empty string, but depending on your implementation other empty
     * values are possible as well (such as empty strings). The reasoning behind
     * this is that value transformers must be chainable. If the
     * reverseTransform() method of the first value transformer outputs an
     * empty string, the second value transformer must be able to process that
     * value.
     *
     * By convention, reverseTransform() should return NULL if an empty string
     * is passed.
     *
     * @param mixed $string The value in the transformed representation
     *
     * @return mixed The value in the original representation
     *
     * @throws TransformationFailedException When the transformation fails.
     */
    public function reverseTransform($string)
    {
        echo "<hr/>$string";
        if (null === $string || sizeof($string) == 0) {
            return null;
        }
        $result = array();
        $repo = $this->em->getRepository($this->options['class']);
        foreach (explode($this->options['delimiter'], $string) as $propertyString) {
            $object = $repo->findOneBy(
                array(
                    $this->options['property'] => $propertyString,
                )
            );
            if ($object === null) {
                $entityInfo = $this->em->getClassMetadata($this->options['class']);
                $object = new $entityInfo->name;
                $accessor = PropertyAccess::createPropertyAccessor();
                $accessor->setValue($object, $this->options['property'], $propertyString);
                $this->em->persist($object);
            }
            array_push($result, $object);
        }
        var_dump($result);
        return $result;
    }

    private function configureOptions(OptionsResolverInterface $resolver)
    {
        $resolver->setRequired(array(
                'class',
                'property',
                'delimiter'
            )
        );
    }
}