DoctrineExtensions's features¶

• Tree - this extension automates the tree handling process and adds some tree specific functions on repository. (closure, nestedset or materialized path)
• Translatable - gives you a very handy solution for translating records into different languages. Easy to setup, easier to use.
• Sluggable - urlizes your specified fields into single unique slug.
• Timestampable - updates date fields on create, update and even property change.
• Blameable - updates string or association fields on create, update and even property change with a user name resp. reference.
• Loggable - helps tracking changes and history of objects, also supports version management.
• Sortable - makes any document or entity sortable
• Translator - explicit way to handle translations
• Softdeleteable - allows to implicitly remove records
• Uploadable - provides file upload handling in entity fields
• Reference Integrity - provides reference integrity for MongoDB, supports nullify and restrict.

All these extensions can be nested together. And most already use only annotations without interface requirement to not to aggregate the entity itself and has implemented proper caching for metadata.

See the official DoctrineExtensions documentation for more details.

Step 1: Download the Bundle¶

Open a command console, enter your project directory and execute the following command to download the latest stable version of this bundle:

1

$ composer require stof/doctrine-extensions-bundle

This command requires you to have Composer installed globally, as explained in the installation chapter of the Composer documentation.

Step 2: Enable the Bundle¶

Then, enable the bundle by adding the following line in the app/AppKernel.php file of your project:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

// app/AppKernel.php

class AppKernel extends Kernel
{
    public function registerBundles()
    {
        $bundles = array(
            // ...

            new Stof\DoctrineExtensionsBundle\StofDoctrineExtensionsBundle(),
        );

        // ...
    }

    // ...
}

Step 3: Add the extensions to your mapping¶

Some of the extensions uses their own entities to do their work. You need to register their mapping in Doctrine when you want to use them.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

# app/config/config.yml
doctrine:
    orm:
        entity_managers:
            default:
                mappings:
                    gedmo_translatable:
                        type: annotation
                        prefix: Gedmo\Translatable\Entity
                        dir: "%kernel.root_dir%/../vendor/gedmo/doctrine-extensions/lib/Gedmo/Translatable/Entity"
                        alias: GedmoTranslatable # (optional) it will default to the name set for the mapping
                        is_bundle: false
                    gedmo_translator:
                        type: annotation
                        prefix: Gedmo\Translator\Entity
                        dir: "%kernel.root_dir%/../vendor/gedmo/doctrine-extensions/lib/Gedmo/Translator/Entity"
                        alias: GedmoTranslator # (optional) it will default to the name set for the mapping
                        is_bundle: false
                    gedmo_loggable:
                        type: annotation
                        prefix: Gedmo\Loggable\Entity
                        dir: "%kernel.root_dir%/../vendor/gedmo/doctrine-extensions/lib/Gedmo/Loggable/Entity"
                        alias: GedmoLoggable # (optional) it will default to the name set for the mappingmapping
                        is_bundle: false
                    gedmo_tree:
                        type: annotation
                        prefix: Gedmo\Tree\Entity
                        dir: "%kernel.root_dir%/../vendor/gedmo/doctrine-extensions/lib/Gedmo/Tree/Entity"
                        alias: GedmoTree # (optional) it will default to the name set for the mapping
                        is_bundle: false

Enable the softdeleteable filter¶

If you want to use the SoftDeleteable behavior, you have to enable the Doctrine filter.

1
2
3
4
5
6
7
8
9

# app/config/config.yml
doctrine:
    orm:
        entity_managers:
            default:
                filters:
                    softdeleteable:
                        class: Gedmo\SoftDeleteable\Filter\SoftDeleteableFilter
                        enabled: true

To disable the behavior, e.g. for admin users who may see deleted items, disable the filter. Here is an example:

1
2

$filters = $em->getFilters();
$filters->disable('softdeleteable');

Using Uploadable extension¶

If you want to use the Uploadable extension, first read the documentation in DoctrineExtensions. Once everything is ready, use the form component as usual. Then, after you verify the form is valid, do the following:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

$document = new Document();
$form = $this->createFormBuilder($document)
    ->add('name')
    ->add('myFile')
    ->getForm()
;

if ($this->getRequest()->getMethod() === 'POST') {
    $form->bind($this->getRequest());

    if ($form->isValid()) {
        $em = $this->getDoctrine()->getManager();
        $em->persist($document);

        $uploadableManager = $this->get('stof_doctrine_extensions.uploadable.manager');

        // Here, "getMyFile" returns the "UploadedFile" instance that the form bound in your $myFile property
        $uploadableManager->markEntityToUpload($document, $document->getMyFile());

        $em->flush();

        $this->redirect($this->generateUrl(...));
    }
}

return array('form' => $form->createView());

And that's it. The Uploadable extension handles the rest of the stuff. Remember to read its documentation!

Overriding the listeners¶

You can change the listeners used by extending the Gedmo listeners (or the listeners of the bundle for translations) and giving the class name in the configuration.