Symfony2以symfony形式获取Unmapped字段值

Question

工作在symfony2房地产项目上，我需要弄清楚如何将提交的数据以动态创建的形式存储在数据库中。

这是我到目前为止已完成的工作，我拥有一个带有一组预定义字段的不动产属性addListings表单，为此我在其中的options嵌入了一组其他字段。 这些“其他字段”由管理员动态决定，他可以添加x个字段，还可以在下拉菜单，复选框或文本类型之间进行选择。

这是选项和类别表单类型，它的所有优点都不错，不用担心，只需将常规表单值提交到数据库即可

/**
 * Inside OptionsType.php
 */
public function buildForm(FormBuilderInterface $builder, array $options)
{
    $builder
        ->add('value')
        ->add('submit', 'submit', ['label'=>'Create Option'])
    ;
}

/**
 * Inside CategoriesType.php
 */
public function buildForm(FormBuilderInterface $builder, array $options)
{
    $builder
        ->add('name')
        ->add('required')
        ->add('isMultiple')
        ->add('isText')
        ->add('submit', 'submit',['label'=>'Create Category'])
    ;
}

这是代表附加字段PropertyCategory.php的实体，它具有getter和setter方法，在此无需担心

<?php
 namespace path\to\Entity;

 use Doctrine\ORM\Mapping as ORM;

/**
 * @ORM\Table(name="property_category")
 * @ORM\Entity
 */
class PropertyCategory {

/**
 * @var type integer
 * 
 * @ORM\ID
 * @ORM\Column(name="id", type="integer")
 * @ORM\GeneratedValue(strategy="AUTO")
 */
private $id;

/**
 * @ORM\ManyToOne(targetEntity="University", inversedBy="propertyCategory")
 */
protected $university;

/**
 * @ORM\ManyToOne(targetEntity="Property", inversedBy="propertyCategory")
 */
protected $property;

/**
 * @ORM\ManyToOne(targetEntity="Category", inversedBy="propertyCategory")
 */
protected $category;

/**
 * @ORM\OneToOne(targetEntity="Options", inversedBy="propertyCategory")
 */
protected $options;

现在这是真正的东西，在PropertyCategoryType中，将Options对象作为数组传递给此表单，该数组的键成为标签，值成为表单字段的选项，忽略其中的大部分内容，只看一下这条线

$builder->add($value->getCategory()->getName(), $type, $options);

这将创建一个mapped=>false字段。 现在，如果您查看下面的控制器AdditionalDetailsController ，我有一个名为propertyCategoryFormAction的动作，这是我将用户选择的数据插入数据库的地方

所以问题是我如何像$form['fieldName']->getData()这样动态获取未映射的字段名称，以便可以使用它来查询数据库并获取options_id并将其持久化到propertyCategory表中

namespace path\to\Form;

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

class PropertyCategoryType extends AbstractType {

public function __construct($options) {
    $this->options = $options;
}

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

    foreach ($this->options as $key => $value) {
        if($value->getCategory()->getIsMultiple()){
            $checkbox[$value->getCategory()->getName()][] = $value->getValue();
            $type = 'choice';
            $options = array('choices'=>$checkbox[$value->getCategory()->getName()],'multiple'=>true, "mapped"=>false, 'expanded'  => true, 'required'=>$value->getCategory()->getRequired());


        }elseif($value->getCategory()->getIsText()){
            $type = 'text';
            $options = array( "mapped"=>false, 'required'=>$value->getCategory()->getRequired());


        }elseif($value->getCategory()->getIsText() == false && $value->getCategory()->getIsMultiple() == false){
            $ddl[$value->getCategory()->getName()][] = $value->getValue();
            $type = 'choice';
            $options = array('choices'=>$ddl[$value->getCategory()->getName()],'multiple'=>false, "mapped"=>false, 'required'=>$value->getCategory()->getRequired()); 

        }

        $builder
            ->add($value->getCategory()->getName(), $type, $options);
    }
        $builder
            ->add('submit', 'submit', array('label'=>'submit', 'attr'=>array('class'=>'btn btn-danger')));
  }


  /**
   * @param OptionsResolverInterface $resolver
   */
   public function setDefaultOptions(OptionsResolverInterface $resolver)
   {
      $resolver->setDefaults(array(
          'data_class' => path\to\PropertyCategory'
      ));
   }


  /**
   * @return string
   */
  public function getName()
  {
    return 'eduflats_bundle_eduflatsbundle_propertycategory';
  }
}

这是控制器AdditionalDetailsController.php

class AdditionalDetailsController extends Controller
{
   /**
    * @Route("/AddCategory", name="addCategory")
    * @Template()
    */
 public function addCategoryAction(Request $request) {

    $em = $this->getDoctrine()->getEntityManager();
    $category = new Category();
    $form = $this->createForm(new CategoryType(), $category);
    $form->handleRequest($request);

    if($form->isValid()){
        $em->persist($category);
        $em->flush();

        return $this->redirect($this->generateUrl('addOption', array('id'=>$category->getId())));
    }
    return array('form'=>$form->createView());
}

/**
 * @Route("/AddOption/{id}", name="addOption")
 * @Template()
 */
public function addOptionAction(Request $request, $id){

    $em = $this->getDoctrine()->getEntityManager();
    $options = new Options();
    $form = $this->createForm(new OptionsType(), $options);
    $form->handleRequest($request);

    if($form->isValid()){
        $category = $this->getDoctrine()->getRepository('EduflatsBundle:Category')->findOneById($id);
        $university = $this->getDoctrine()->getRepository('EduflatsBundle:University')->findOneById(siteConfig::$university_id);
        $options->setCategory($category);
        $options->setUniversity($university);
        $em->persist($options);
        $em->flush();

        $this->get('session')->getFlashBag()->set('success', 'Your options have been saved Successfully');
        return $this->redirect($this->generateUrl('addOption',array('id'=>$id)));
    }
    return array('form'=>$form->createView());

}

/**
 * @Route("/form", name="form")
 * @Template()
 */
public function propertyCategoryFormAction(Request $request) {

    $options = $this->getDoctrine()->getRepository('EduflatsBundle:Options')->findAll();

    $em = $this->getDoctrine()->getEntityManager();
    $propertyCategory = new PropertyCategory();
    $form = $this->createForm(new PropertyCategoryType($options), $propertyCategory);
    $form->handleRequest($request);

    if($form->isValid()){
        $property = $this->getDoctrine()->getRepository('EduflatsBundle:Property')->findOneById(1);
        $propertyCategory = new PropertyCategory();

        $propertyCategory->setProperty($property);
        $propertyCategory->setOptions();

        $em->persist($propertyCategory);
        $em->flush();
    }
    return array('form'=>$form->createView());
}
}

我希望我足够清楚，我可以在评论中澄清一些内容。

Answer 1

这是我的想法。 我实际上有一份工作想要做类似的事情，但由于当时这是一件很难管理的事情，我们最终放弃了它。 但是，这是我的计划。

从主实体开始

class Listing
{
    protected $name;
    protected $price;

    //Your custom options (One-to-Many)
    protected $options;

    public function __construct()
    {
        $this->options = new ArrayCollection();
    }

    // Getters and Setters ...
}

然后，我们有两个实体负责处理自定义选项。 与清单相关的选项本身。

class Option
{
    protected $name;
    protected $fieldType;
    protected $required;
    // Other form options you may want...

    //Related Values (One-to-many)
    protected $optionValues;

    // Many-to-one
    protected $listings;

    public function __construct()
    {
        $this->optionValues = new ArrayCollection();
    }

    // Getters and Setters ...
}

以及该选项的值存储在数据库中。

class OptionValues
{
    protected $value;


    // Many-to-one
    protected $option;
}

然后，我们为清单建立From。

class ListingType extends AbstractType
{
    public function buildForm(FormBuilderInterface $builder, array $options)
    {
        $builder->add('name' , 'text')
            ->add('price', 'text');
            //Your other standard fields...
            foreach($options['extraFields'] as $field)
            {
                $builder->add($field->getName() , new OptionValueType(), array('mapped' => false, 'options' => array('field' => $field));
            }
    }

    public function setDefaultOptions(OptionsResolverInterface $resolver)
    {
        $resolver->setRequired('extraFields');

        $resolver->addAllowedTypes(array(
            'extraFields' => '\Doctrine\Common\Collections\Collection'
        ));

        $resolver->setDefaults(array(
            'data_class' => 'AppBundle\Entity\Listing',
            'cascade_validation' => true
        ));
    }

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

我们要求您传递$option['extraFields'] ，它应该是您从控制器中的$yourListing->getOptions()获得的AppBundle\\Entity\\Option的集合。 然后，我们可以遍历这些字段并创建一个新的未映射字段，然后将该字段的其余部分传递给AppBundle\\Entity\\OptionValue的表单。

class OptionValueType extends AbstractType
{
    public function buildForm(FormBuilderInterface $builder, array $options)
    {
        //Obviously do whatever other settings you need.  The important part is remembering that this belongs in the $value
        //of our OptionValue entity.
        $builder->add('value' , $field->fieldType, array('required' => $field->getIsRequired()));
    }

    public function setDefaultOptions(OptionsResolverInterface $resolver)
    {
        $resolver->setRequired('field');

        $resolver->addAllowedTypes(array(
            'field' => '\AppBundle\Entity\Option'
        ));

        $resolver->setDefaults(array(
            'data_class' => 'AppBundle\Entity\OptionValue',
            'cascade_validation' => true
        ));
    }

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

一些重要的事情要注意。 在这两种形式中，我们都使用$resolver->setRequired()和$resolver->setAddAllowedTypes()定义额外的选项字段，否则Symfony会抛出错误。 同样，在清单表单中，如果您要的是，我们将'cascade_validation' => true为确保我们的子表单也得到验证。 您可能还需要进行一些疯狂的自定义验证，这是另外一些技巧。

这最终允许我们在控制器中使用的方法是限制疯狂的自定义表单操作，而相反，如果您正确设置了持久性以在Listing和Option实体中级联，则您应该能够持久Listing并将其确保所有Option和OptionValue实体也都持久保存到数据库中。 只要您做对了一切。 我遗漏了很多细节，因为要写很多东西，但是希望这可以给您一些想法。