Evolution #28: Forms: Contraintes de validités personalisés

src/Muzich/CoreBundle/Controller/CoreController.php

 use Muzich\CoreBundle\ElementFactory\ElementManager;
 use Muzich\CoreBundle\Entity\Element;
 use Symfony\Component\HttpFoundation\RedirectResponse;
+use Muzich\CoreBundle\Form\Search\ElementSearchForm;
 
 class CoreController extends Controller
 {
       $form->bindRequest($this->getRequest());
       if ($form->isValid())
       {
-
         // On utilise le gestionnaire d'élément
         $factory = new ElementManager($element, $em, $this->container);
         $factory->proceedFill($user);
         else
         {
           $this->setFlash('error', 'element.add.error');
-          return $this->redirect($redirect_url);
+          
+          $search_object = $this->getElementSearcher();
+          $user = $this->getUser(true, array('join' => array(
+            'groups_owned'
+          )), true);
+
+          $search_form = $this->createForm(
+            new ElementSearchForm(), 
+            $search_object->getParams(),
+            array(
+              'tags' => $tags = $this->getTagsArray()
+            )
+          );
+
+          return $this->render('MuzichHomeBundle:Home:index.html.twig', array(
+            'user'        => $this->getUser(),
+            'add_form'    => $form->createView(),
+            'search_form' => $search_form->createView(),
+            'elements'    => $search_object->getElements($this->getDoctrine(), $this->getUserId())
+          ));
+          
         }
         
       }

src/Muzich/CoreBundle/Entity/Element.php

 use \Doctrine\Common\Collections\ArrayCollection;
 use Gedmo\Mapping\Annotation as Gedmo;
 use Doctrine\ORM\EntityManager;
+use Muzich\CoreBundle\Validator as MuzichAssert;
 
 /**
  * L'Element est l'Element central de l'application. C'est cet
    * 
    * @ORM\ManyToMany(targetEntity="Tag", inversedBy="elements")
    * @ORM\JoinTable(name="elements_tag")
+   * @MuzichAssert\Tags()
    */
   private $tags;
 
    * 
    * @ORM\ManyToOne(targetEntity="Group", inversedBy="elements")
    * @ORM\JoinColumn(name="group_id", referencedColumnName="id")
+   * @MuzichAssert\GroupOwnedOrPublic()
    */
   protected $group = null;
   

src/Muzich/CoreBundle/Validator/GroupOwnedOrPublic.php

+<?php
+// AlwaysFail.php
+namespace Muzich\CoreBundle\Validator;
+
+use Symfony\Component\Validator\Constraint;
+
+/**
+ * @Annotation
+ */
+class GroupOwnedOrPublic extends Constraint
+{
+  public $message = 'Le groupe est mal choisis';
+  public $entity;
+  public $property;
+
+  public function validatedBy()
+  {
+      return 'validator.groupownedorpublic';
+  }
+
+  public function requiredOptions()
+  {
+      return array('entity', 'property');
+  }
+  
+  public function getTargets()
+  {
+    return Constraint::PROPERTY_CONSTRAINT;
+  }
+}

src/Muzich/CoreBundle/Validator/GroupOwnedOrPublicValidator.php

+<?php
+
+namespace Muzich\CoreBundle\Validator;
+
+use Symfony\Component\Validator\ConstraintValidator;
+use Symfony\Component\Validator\Constraint;
+use Doctrine\ORM\EntityManager;
+use Symfony\Component\Security\Core\SecurityContext;
+
+class GroupOwnedOrPublicValidator extends ConstraintValidator
+{
+  
+  private $entityManager;
+  private $security_context;
+
+  public function __construct(EntityManager $entityManager, SecurityContext $security_context)
+  {
+    $this->entityManager = $entityManager;
+    $this->security_context = $security_context;
+  }
+  
+  /**
+   * Ce n'est valide que si
+   *  * Le groupe est open
+   *  * Le groupe appartient a l'user
+   *  * On a pas précisé de groupe
+   * 
+   * @param int $value
+   * @param Constraint $constraint
+   * @return boolean
+   */
+  public function isValid($value, Constraint $constraint)
+  {
+    if ($value)
+    {
+      $user = $user = $this->security_context->getToken()->getUser();
+      $group = $this->entityManager->getRepository('MuzichCoreBundle:Group')
+        ->findOneById($value)
+      ;
+      if (!$group)
+      {
+        $this->setMessage('Le groupe est invalide');
+        return false;
+      }
+      
+      if (!$group->userCanAddElement($user))
+      {
+        $this->setMessage('Le groupe est invalide');
+        return false;
+      }
+    }
+    return true;
+  }
+}

src/Muzich/CoreBundle/Validator/Tags.php

+<?php
+// AlwaysFail.php
+namespace Muzich\CoreBundle\Validator;
+
+use Symfony\Component\Validator\Constraint;
+
+/**
+ * @Annotation
+ */
+class Tags extends Constraint
+{
+  public $message = 'Les tags sont mal configurés';
+  public $entity;
+  public $property;
+
+  public function validatedBy()
+  {
+      return 'validator.tags';
+  }
+
+  public function requiredOptions()
+  {
+      return array('entity', 'property');
+  }
+  
+  public function getTargets()
+  {
+    return Constraint::PROPERTY_CONSTRAINT;
+  }
+}

src/Muzich/CoreBundle/Validator/TagsValidator.php

+<?php
+
+namespace Muzich\CoreBundle\Validator;
+
+use Symfony\Component\Validator\ConstraintValidator;
+use Symfony\Component\Validator\Constraint;
+use Doctrine\ORM\EntityManager;
+
+class TagsValidator extends ConstraintValidator
+{
+  
+  private $entityManager;
+
+  public function __construct(EntityManager $entityManager)
+  {
+    $this->entityManager = $entityManager;
+  }
+  
+  public function isValid($value, Constraint $constraint)
+  {
+    if (array_diff($value, array_unique($value)))
+    {
+      $this->setMessage('Tags saisies incorrects');
+      return false;
+    }
+    
+    $count = $this->entityManager
+      ->createQuery("SELECT COUNT(t)
+        FROM MuzichCoreBundle:Tag t
+        WHERE t IN (:tids)")
+      ->setParameter('tids', $value)
+    ->getSingleScalarResult();
+    
+    if ($count != count ($value))
+    {
+      $this->setMessage('Tags saisies incorrects');
+      return false;
+    }
+    
+    return true;
+  }
+}