DoctrineMongoDBBundle Documentation

If one fixture depends on data created by another (e.g., a Product needing a Category), implement the Doctrine\Common\DataFixtures\DependentFixtureInterface.

You must implement the getDependencies() method, which returns an array of class names that must be loaded before the current fixture.

// src/DataFixtures/ProductFixtures.php
namespace App\DataFixtures;

use App\Document\Product;
use Doctrine\Bundle\MongoDBBundle\Fixture\Fixture;
use Doctrine\Common\DataFixtures\DependentFixtureInterface;
use Doctrine\Persistence\ObjectManager;

class ProductFixtures extends Fixture implements DependentFixtureInterface
{
    public function load(ObjectManager $manager): void
    {
        $product = new Product();
        $product->setName('Laptop');
        $product->setPrice(999.99);
        // Retrieve reference from another fixture
        $product->setCategory($this->getReference('category-electronics'));

        $manager->persist($product);
        $manager->flush();
    }

    public function getDependencies(): array
    {
        return [CategoryFixtures::class];
    }
}

When a form requires extra fields that are not stored in the database (e.g., 'terms and conditions' checkbox), use a 'wrapper' or 'DTO' model. This model holds both the actual MongoDB Document and the extra fields.

1. Create the Wrapper Model: Define a plain class that contains the Document and the extra properties.
2. Create the Wrapper Form: In the buildForm method, add the Document form as a field. Use property_path if the extra field needs to map to a specific property in the wrapper.

Example Wrapper Model:

namespace App\Form\Model;

use App\Document\User;
use Symfony\Component\Validator\Constraints as Assert;

class Registration
{
    /**
     * @Assert\Type(type="App\Document\User")
     */
    protected $user;

    /**
     * @Assert\NotBlank()
     * @Assert\IsTrue()
     */
    protected $termsAccepted;

    // ... getters and setters
}

Example Wrapper Form:

namespace App\Form\Type;

use App\Form\Type\UserType;
use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\Extension\Core\Type\CheckboxType;
use Symfony\Component\Form\FormBuilderInterface;

class RegistrationType extends AbstractType
{
    public function buildForm(FormBuilderInterface $builder, array $options)
    {
        $builder->add('user', UserType::class);
        $builder->add('terms', CheckboxType::class, ['property_path' => 'termsAccepted']);
    }
}

If you are developing a bundle that contains Doctrine MongoDB documents, you must register your mappings so the application's DocumentManager can recognize them.

To simplify this, DoctrineMongoDBBundle provides the DoctrineMongoDBMappingsPass compiler pass. You should register this pass within your bundle's build() method.

When configuring the pass, you must provide:

1. An array of mappings where the key is the directory path to your mapping files and the value is the document namespace.
2. A parameter name that specifies which DocumentManager should use these mappings.
3. A parameter name (boolean) that acts as a feature flag; the mappings will only be enabled if this parameter is set to true.

namespace Awesome\AwesomeBundle;

use Doctrine\Bundle\MongoDBBundle\DependencyInjection\Compiler\DoctrineMongoDBMappingsPass;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\HttpKernel\Bundle\Bundle;

class AwesomeBundle extends Bundle
{
    public function build(ContainerBuilder $container): void
    {
        parent::build($container);

        // The path to your mapping files
        $mappings = [
            __DIR__.'/Resources/config/doctrine-mapping' => 'Awesome\AwesomeBundle\Model',
        ];

        $container->addCompilerPass(
            DoctrineMongoDBMappingsPass::createXmlMappingDriver(
                $mappings,
                ['awesome_bundle.model_manager_name'],
                'awesome_bundle.backend_type_mongodb'
            )
        );
    }
}