lexik / lexikformfilterbundle Goto Github PK

<?php
namespace SportTV\ManageBundle\Form;

use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\OptionsResolver\OptionsResolverInterface;

use Lexik\Bundle\FormFilterBundle\Filter\Extension\Type\TextFilterType;

class TeamFilter extends AbstractType
{
    public function buildForm(FormBuilderInterface $builder, array $options)
    {
        $builder
            ->add(
                'name',
                'filter_text', 
                array(
                    'widget_controls' => false,
                    'widget_control_group' => false,
                    'attr' => array('placeholder' => 'Name'),
                    'condition_pattern' => TextFilterType::PATTERN_CONTAINS
                )
            )
            ->add('competition', 'filter_entity', array(
                'class' => 'CommonBundle:Competition',
                'property' => 'name'
            ))
        ;
    }

    public function getName()
    {
        return 'team_filter';
    }
}

        $form = $this->createForm(new TeamFilter());
        $form->bindRequest($this->get('request'));

        $filterBuilder = $em->getRepository('CommonBundle:Team')->getPagingQuery($sport);
        $this->get('lexik_form_filter.query_builder_updater')->addFilterConditions($form, $filterBuilder);

        $builder
            ->add('lesson', 'filter_entity', array(
                'class' => 'Salem\EntityBundle\Entity\Lesson',
                'property' => 'name',
                'empty_value' => 'Выберите билет',
                'empty_data' => null,
                'query_builder' => function(EntityRepository $repository) {
                    $qb = $repository->createQueryBuilder('l');

                    return $qb;
                }
            ));

public function buildForm(FormBuilderInterface $builder, array $options) {
        $builder->add('nombre', 'filter_text', array(
            'condition_pattern' => FilterOperands::STRING_BOTH, 
            'label' => 'Nombre'));
        $builder->add('categoria', 'filter_entity', array(
            'class' => 'ProjectDeportivoBundle:Categoria',
            'label' => 'Categoría'));
    }

    public function getName() {
        return 'equipo_filter';
    }

    public function setDefaultOptions(OptionsResolverInterface $resolver) {
        $resolver->setDefaults(array(
            'csrf_protection'   => false,
            'validation_groups' => array('filtering') 
        ));
    }

public function indexAction() {
        $em = $this->getDoctrine()->getManager();

        $form = $this->get('form.factory')->create(new EquipoFilterType());

        if ($this->get('request')->query->has('submit-filter')) {
            $form->bind($this->get('request'));

            $filterBuilder = $this->get('doctrine.orm.entity_manager')
                ->getRepository('ProjectDeportivoBundle:Equipo')
                ->createQueryBuilder('e');

            $this->get('lexik_form_filter.query_builder_updater')->addFilterConditions($form, $filterBuilder);

            $query = $em->createQuery($filterBuilder->getDql());
        } 
...
}

    public function fleetManagerAction()
    {
        $fm=new FilterModel();
        $fm->setUser($this->getUser());

        $form = $this->get('form.factory')->create(new ContractFilterType(),$fm);

        if ($this->get('request')->query->has('submit-filter')) {
            // bind values from the request
            $form->bindRequest($this->get('request'));
            $em = $this->getDoctrine()->getManager('em_fol');

            // initialize a query builder
            $filterBuilder = $em->getRepository('AldFocusOnLineBundle:WebContract')->createQueryBuilder('c');

            // build the query from the given form object
            $this->get('lexik_form_filter.query_builder_updater')->addFilterConditions($form, $filterBuilder);

        }
     }

    class ContractFilterType extends AbstractType
    {

    /**
     * {@inheritdoc}
     */
    public function buildForm(FormBuilderInterface $builder, array $options)
    {

        $choices = array(
            '1' =>'Hierarchy Level 1',
            '2' =>'Hierarchy Level 2',
            '3' =>'Hierarchy Level 3',
        );

        $builder->addEventSubscriber(new HierarchySelectorSubscriber());
        $builder
            ->add('codPlate', 'filter_text',array('condition_pattern'=> FilterOperands::STRING_BOTH))
            ->add('dateBegin','filter_datetime_range')
            // NO MAPPED DB FIELD: ONLY FOR DATA TRANSPORT
            ->add('hierarchy_level',  'filter_choice', array(
                    'choices'   => $choices,
                    'multiple'  => false,
                    'expanded'  => true,
                    'apply_filter' => function(QueryInterface $filterQuery, $field, $values)
                    {  // Do nothing
                        return $filterQuery;
                    }))
        ;
    }

    /**
     * {@inheritdoc}
     */
    public function setDefaultOptions(OptionsResolverInterface $resolver)
    {
        $resolver->setDefaults(array(
            'data_class'        => 'Ald\CustomerArea\SecurityBundle\Model\FilterModel',
            'csrf_protection'   => false,
            'validation_groups' => array('filter'),
        ));
    }

    /**
     * {@inheritdoc}
     */
    public function getName()
    {
        return 'web_contract_filter';
    }

    class HierarchySelectorSubscriber implements EventSubscriberInterface
    {

    public static function getSubscribedEvents()
    {
        // Tells the dispatcher that you want to listen on the form.pre_set_data
        // event and that the preSetData method should be called.
        return array(FormEvents::PRE_SET_DATA => 'preSetData');
    }

    public function preSetData(FormEvent $event)
    {
        $data = $event->getData();
        $form = $event->getForm();

        // Always NULL !!!!
        var_dump($data->getHierarchyLevel());

        switch ($data->getHierarchyLevel())
        {
            case '1':
                $form->add('level1', 'filter_text',array('condition_pattern'=> FilterOperands::STRING_BOTH));
                break;
            case '2':
                $form->add('level2', 'filter_text',array('condition_pattern'=> FilterOperands::STRING_BOTH));
                break;
            case '3':
                $form->add('level3', 'filter_text',array('condition_pattern'=> FilterOperands::STRING_BOTH));
                break;
            default:
        }

    }

     class FilterModel extends WebContract
     {

    protected $hierarchy;

    protected $hierarchy_level;

    protected $user;

    public function setUser($user)
    {
        $this->user = $user;
    }

    public function getUser()
    {
        return $this->user;
    }

    public function setHierarchy($hierarchy)
    {
        $this->hierarchy = $hierarchy;
    }

    public function getHierarchy()
    {
        return $this->hierarchy;
    }

    public function setHierarchyLevel($hierarchy_level)
    {
        $this->hierarchy_level = $hierarchy_level;
    }

    public function getHierarchyLevel()
    {
        return $this->hierarchy_level;
    }

$builder->add('media', new MediaFilterForm());
$builder->add('contact', new ContactFilterForm());

array(
    0 => "foo",
    1 => "Bar"
);

/**
 * {@inheritdoc}
 */
protected function apply(QueryBuilder $filterBuilder, Expr $expr, $field, array $values)
{
    if ('' !== $values['value'] && null !== $values['value']) {
        // foo
    }
}

<?php

namespace Ecomm\Bundle\CatalogBundle\Entity;

use Doctrine\ORM\Mapping as ORM;

/**
 * ProductOption
 *
 * @ORM\Entity(repositoryClass="Ecomm\Bundle\CatalogBundle\Entity\Manager\ProductOptionManager")
 * @ORM\Table(name="products_options")
 * @ORM\HasLifecycleCallbacks
 */
class ProductOption
{
    /**
     * @var integer
     *
     * @ORM\Id
     * @ORM\Column(name="product_option_id", type="integer", nullable=false)
     * @ORM\GeneratedValue(strategy="IDENTITY")
     */
    protected $id;

    /**
     * @ORM\OneToMany(targetEntity="Ecomm\Bundle\CatalogBundle\Entity\Translation\ProductOptionTranslation", mappedBy="productOption", cascade={"persist", "remove"})
     * 
     */
    protected $translations;


    protected $name;


    /**
     * @ORM\OneToMany(targetEntity="Ecomm\Bundle\CatalogBundle\Entity\ProductOptionValue", mappedBy="productOption")
     **/
    protected $productOptionValues;


    /**
     * Constructor
     */
    public function __construct()
    {
        $this->resetTranslations();
        $this->productOptionValues = new \Doctrine\Common\Collections\ArrayCollection();
    }

    /**
     * Get id
     *
     * @return integer 
     */
    public function getId()
    {
        return $this->id;
    }

    /**
     * Add translations
     *
     * @param \Ecomm\Bundle\CatalogBundle\Entity\Translation\ProductOptionTranslation $translations
     * @return ProductOption
     */
    public function addTranslation(\Ecomm\Bundle\CatalogBundle\Entity\Translation\ProductOptionTranslation $translation)
    {
        $this->translations[] = $translation;
        $translation->setProductOption($this);
        return $this;
    }

    /**
     * Remove translations
     *
     * @param \Ecomm\Bundle\CatalogBundle\Entity\Translation\ProductOptionTranslation $translations
     */
    public function removeTranslation(\Ecomm\Bundle\CatalogBundle\Entity\Translation\ProductOptionTranslation $translations)
    {
        $this->translations->removeElement($translations);
    }

    /**
     * Get translations
     *
     * @return \Doctrine\Common\Collections\Collection 
     */
    public function getTranslations()
    {
        return $this->translations;
    }

    public function resetTranslations()
    {
        $this->translations = new \Doctrine\Common\Collections\ArrayCollection();
    }

    public function getName()
    {
        return $this->name;
    }

    /**
     * 
     *  @ORM\PostLoad
     *
     */
    public function onPostLoad()
    {
        $this->name = array();

        if ($this->translations)
        {    

            foreach($this->translations as $translation)
            { 
                $locale = $translation->getLocale();
                $this->name[$locale] = $translation->getName();
            }
        }     
    }

    /**
     * Add productOptionValue
     *
     * @param \Ecomm\Bundle\CatalogBundle\Entity\ProductOptionValue $productOptionValue
     * @return ProductOption
     */
    public function addProductOptionValue(\Ecomm\Bundle\CatalogBundle\Entity\ProductOptionValue $productOptionValue)
    {
        $this->productOptionValues[] = $productOptionValue;
        return $this;
    }

    /**
     * Remove productOptionValue
     *
     * @param \Ecomm\Bundle\CatalogBundle\Entity\ProductOptionValue $productOptionValue
     */
    public function removeProductOptionValue(\Ecomm\Bundle\CatalogBundle\Entity\ProductOptionValue $productOptionValue)
    {
        $this->productOptionValues->removeElement($productOptionValue);
    }

    /**
     * Get productOptionValue
     *
     * @return \Doctrine\Common\Collections\Collection 
     */
    public function getProductOptionValues()
    {
        return $this->productOptionValues;
    }

}






<?php

namespace Ecomm\Bundle\CatalogBundle\Entity;

use Doctrine\ORM\Mapping as ORM;

/**
 * ProductOptionValue
 *
 * @ORM\Entity(repositoryClass="Ecomm\Bundle\CatalogBundle\Entity\Manager\ProductOptionValueManager")
 * @ORM\Table(name="products_options_values")
 * @ORM\HasLifecycleCallbacks
 */
class ProductOptionValue
{
    /**
     * @var integer
     *
     * @ORM\Id
     * @ORM\Column(name="product_option_value_id", type="integer", nullable=false)
     * @ORM\GeneratedValue(strategy="IDENTITY")
     */
    protected $id;

    /**
     * @ORM\OneToMany(targetEntity="Ecomm\Bundle\CatalogBundle\Entity\Translation\ProductOptionValueTranslation", mappedBy="productOptionValue", cascade={"persist", "remove"})
     * 
     */
    protected $translations;

    /**
     * @var \ProductsOptions
     *
     * @ORM\ManyToOne(targetEntity="Ecomm\Bundle\CatalogBundle\Entity\ProductOption", inversedBy="productOptionValues")
     * @ORM\JoinColumn(name="product_option_id", referencedColumnName="product_option_id", onDelete="RESTRICT")
     */
    protected $productOption;


    protected $name;

    /**
     * Constructor
     */
    public function __construct()
    {
        $this->resetTranslations();
    }


    public function __toString()
    {
        return "" . $this->name;
    }

    /**
     * Get id
     *
     * @return integer 
     */
    public function getId()
    {
        return $this->id;
    }

    /**
     * Add translations
     *
     * @param \Ecomm\Bundle\CatalogBundle\Entity\Translation\ProductOptionValueTranslation $translations
     * @return ProductOptionValue
     */
    public function addTranslation(\Ecomm\Bundle\CatalogBundle\Entity\Translation\ProductOptionValueTranslation $translation)
    {
        $this->translations[] = $translation;
        $translation->setProductOptionValue($this);
        return $this;
    }

    /**
     * Remove translations
     *
     * @param \Ecomm\Bundle\CatalogBundle\Entity\Translation\ProductOptionValueTranslation $translations
     */
    public function removeTranslation(\Ecomm\Bundle\CatalogBundle\Entity\Translation\ProductOptionValueTranslation $translations)
    {
        $this->translations->removeElement($translations);
    }

    /**
     * Get translations
     *
     * @return \Doctrine\Common\Collections\Collection 
     */
    public function getTranslations()
    {
        return $this->translations;
    }

    public function resetTranslations()
    {
        $this->translations = new \Doctrine\Common\Collections\ArrayCollection();
    }

    public function getName()
    {
        return $this->name;
    }

    /**
     * 
     *  @ORM\PostLoad
     *
     */
    public function onPostLoad()
    {
        $this->name = array();

        if ($this->translations)
        {    

            foreach($this->translations as $translation)
            { 
                $locale = $translation->getLocale();
                $this->name[$locale] = $translation->getName();
            }
        }     
    }


    /**
     * Set productOption
     *
     * @param \Ecomm\Bundle\CatalogBundle\Entity\ProductOption $productOption
     * @return ProductOptionValue
     */
    public function setProductOption(\Ecomm\Bundle\CatalogBundle\Entity\ProductOption $productOption)
    {
        $this->productOption = $productOption;

        return $this;
    }

    /**
     * Get productOption
     *
     * @return \Ecomm\Bundle\CatalogBundle\Entity\ProductOption 
     */
    public function getProductOption()
    {
        return $this->productOption;
    }
}





<?php

namespace Ecomm\Bundle\CatalogBundle\Form;

use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\OptionsResolver\OptionsResolverInterface;
use Symfony\Component\Form\FormEvent;
use Symfony\Component\Form\FormEvents;
use Symfony\Component\Form\FormError;

use Lexik\Bundle\FormFilterBundle\Filter\ORM\Expr;
use Doctrine\ORM\QueryBuilder;

use Symfony\Component\DependencyInjection\ContainerInterface;
use Symfony\Component\Translation\Translator;

class ProductOptionValueFilterType extends AbstractType
{
    /**
     * @var ServiceContainer
     */
    private $sc;

    protected $translator;

    public function __construct(ContainerInterface $container = null)
    {        
        $this->sc = $container;
        $this->translator = $this->sc->get('translator');
    }

    public function buildForm(FormBuilderInterface $builder, array $options)
    {
        $builder
            ->add('name', 'filter_text', array(
                'label' => $this->translator->trans('form.filter.label.name'),
                'apply_filter' => function (QueryBuilder $queryBuilder, Expr $expr, $field, array $values)
                {
                    if (!empty($values['value']))
                    {
                    // add  the join if you need it and it not already added
                        $alias = $queryBuilder->getRootAliases();
                        $queryBuilder->innerJoin($alias[0].'.translations', 'at');
                        $queryBuilder->andWhere('at.name = :name')
                        ->setParameter('name', $values['value']);
                    }
                },
            ))

            /*
            ->add('productOption', 'filter_entity', array(
                  'label' => $this->translator->trans('form.filter.label.option'),
                  'class' => 'EcommCatalogBundle:ProductOption',
                  'empty_value' => 'Choose a Product Option'
            ))
            */

            ->add('productOption', $this->sc->get('ecomm.type.product_option_filter_field'));


        ;

        $listener = function(FormEvent $event)
        {
            // Is data empty?
            foreach ($event->getData() as $data) {
                if(is_array($data)) {
                    foreach ($data as $subData) {
                        if(!empty($subData)) return;
                    }
                }
                else {
                    if(!empty($data)) return;
                }
            }

            $event->getForm()->addError(new FormError('Filter empty'));
        };
        $builder->addEventListener(FormEvents::POST_BIND, $listener);
    }

    public function getName()
    {
        return 'ecomm_bundle_catalogbundle_productoptionvaluefiltertype';
    }
}




<?php

namespace Ecomm\Bundle\CatalogBundle\Form;

use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\OptionsResolver\OptionsResolverInterface;

use Ecomm\Bundle\CatalogBundle\Form\DataTransformer\ProductOptionFieldTransformer;

use Symfony\Component\DependencyInjection\ContainerAwareInterface;
use Symfony\Component\DependencyInjection\ContainerInterface;


use Doctrine\ORM\QueryBuilder;

use Lexik\Bundle\FormFilterBundle\Filter\FilterBuilderExecuterInterface;
use Lexik\Bundle\FormFilterBundle\Filter\ORM\Expr;
use Lexik\Bundle\FormFilterBundle\Filter\Extension\Type\FilterTypeSharedableInterface;



class ProductOptionFilterFieldType extends AbstractType implements FilterTypeSharedableInterface
{

    /**
     * @var ServiceContainer
     */
    private $sc;


    public function __construct(ContainerInterface $container = null)
    {        
        $this->sc = $container;
    }


    public function buildForm(FormBuilderInterface $builder, array $options)
    {

        $transformer = new ProductOptionFieldTransformer($this->sc);        
        $builder->addModelTransformer($transformer);

    }


    /**
     * This method aim to add all joins you need
     */
    public function addShared(FilterBuilderExecuterInterface $qbe)
    {
        $closure = function(QueryBuilder $filterBuilder, $alias, $joinAlias, Expr $expr)
        {
            // add the join clause to the doctrine query builder
            // the where clause for the label and color fields will be added automatically with the right alias later by the Lexik\Filter\QueryBuilderUpdater
            $filterBuilder->innerJoin($alias . '.productOption', 'po');

        };

        // then use the query builder executor to define the join, the join's alias and things to do on the doctrine query builder.
        $qbe->addOnce($qbe->getAlias().'.productOption', 'po', $closure);
    }



    public function setDefaultOptions(OptionsResolverInterface $resolver)
    {
        $resolver->setDefaults(array(
            'invalid_message' => 'The selected productOption does not exist',
            'empty_value' => 'Choose an option',
            'choices' => $this->buildData(),
        ));
    }

    private function buildData()
    {
        $em = $this->sc->get('doctrine')->getManager();
        $request = $this->sc->get('request');

        $choices = array();
        $productOptions = $em
            ->getRepository('EcommCatalogBundle:ProductOption')
            ->createQueryBuilder('c')
            ->select('c, ct')
            ->innerJoin('c.translations', 'ct')
            ->andWhere('ct.locale = :locale')
            ->setParameter('locale', $request->getLocale())
            ->orderBy('ct.name', 'ASC')
            ->getQuery()
            ->getResult();

        foreach ($productOptions as $productOption)
        {
            // I assume key is retrieved by getId
            $translation = $productOption->getTranslations();
            $choices[$productOption->getId()] = $translation[0]->getName();
        }

        return $choices;
    }

    public function getName()
    {
        return 'product_option_filter_field';
    }

    public function getParent()
    {
        return 'choice';
    }

}