Download the PHP package ck-developer/doctrine-behaviors without Composer

Doctrine2 Behaviors

This php 5.4+ library is a collection of traits that add behaviors to Doctrine2 entites and repositories.

It currently handles:

• tree
• translatable
• timestampable
• softDeletable
• blameable
• loggable
• geocodable
• filterable
• sluggable
• Tokenable

Notice:

Some behaviors (translatable, timestampable, softDeletable, blameable, geocodable) need Doctrine subscribers in order to work. Make sure to activate them by reading the Subscribers section.

Subscribers

If you use symfony2, you can easily register them by importing a service definition file:

You can also register them using doctrine2 api:

Usage

All you have to do is to define a Doctrine2 entity and use traits:

For some behaviors like tree, you can use repository traits:

Voila!

You now have a working Category that behaves like:

tree:

it is possible to use another identifier than id, simply override getNodeId and return your custom identifier (works great in combination with Sluggable)

translatable:

If you're working on a Category entity, the Translatable behavior expects a CategoryTranslation entity by default. If you prefer to use a different class name for the translation entity, you should override the trait method getTranslationEntityClass in the translatable entity and getTranslatableEntityClass in the translation entity. If you override one, you also need to override the other to return the inverse class.

The default naming convention (or its customization via trait methods) avoids you to handle manually entity associations. It is handled automatically by the TranslationSubscriber.

In order to use the Translatable trait, you will have to create this CategoryTranslation entity.

The corresponding Category entity needs to use ORMBehaviors\Translatable\Translatable; and should only contain fields that you do not need to translate.

After updating the database, ie. with ./console doctrine:schema:update --force, you can now work on translations using translate or getTranslations methods.

guess the current locale

You can configure the way the subscriber guesses the current locale, by giving a callable as its first argument. This library provides a callable object (Knp\DoctrineBehaviors\ORM\Translatable\CurrentLocaleCallable) that returns the current locale using Symfony2.

proxy translations

An extra feature allows you to proxy translated fields of a translatable entity.

You can use it in the magic __call method of you translatable entity so that when you try to call getName (for example) it will return you the translated value of the name for current locale:

soft-deletable

timestampable

blameable

Blameable is able to track creators and updators of a given entity. A blameable callable is used to get the current user from your application.

In the case you are using a Doctrine Entity to represent your users, you can configure the subscriber to manage automatically the association between this user entity and your entites.

Using symfony2, all you have to do is to configure the DI parameter named %knp.doctrine_behaviors.blameable_subscriber.user_entity% with a fully qualified namespace, for example:

# app/config/config.yml

parameters:
    knp.doctrine_behaviors.blameable_subscriber.user_entity: AppBundle\Entity\User

Then, you can use it like that:

loggable

Loggable is able to track lifecycle modifications and log them using any third party log system. A loggable callable is used to get the logger from anywhere you want.

These messages are then passed to the configured callable. You can define your own, by passing another callable to the LoggableSubscriber:

If you're using symfony, you can also configure which callable to use:

// app/config/config.yml
parameters:
    knp.doctrine_behaviors.loggable_subscriber.logger_callable.class: Your\InvokableClass

geocodable

Geocodable Provides extensions to PostgreSQL platform in order to work with cube and earthdistance extensions.

It allows you to query entities based on geographical coordinates. It also provides an easy entry point to use 3rd party libraries like the exellent geocoder to transform addresses into latitude and longitude.

sluggable

Sluggable generates slugs (uniqueness is not guaranteed) for an entity. Will automatically generate on update/persist (you can disable the on update generation by overriding getRegenerateSlugOnUpdate to return false. You can also override the slug delimiter from the default hyphen by overriding getSlugDelimiter. Slug generation algo can be changed by overriding generateSlugValue. Use cases include SEO (i.e. URLs like http://mysite.com/post/3/introduction-to-php)

tokenable

Tokenable generates token (uniqueness is not guaranteed) for an entity. Will automatically generate on update/persist (you can enable the on update generation by overriding getRegenerateTokenOnUpdate to return true. You can also override the token base from the default hyphen by overriding getTokenBase. Token generation algo can be changed by overriding generateTokenValue.

filterable:

Filterable can be used at the Repository level

It allows to simple filter our result

Joined filters example:

and repository:

Now we can filtering using:

callables

Callables are used by some subscribers like blameable and geocodable to fill information based on 3rd party system.

For example, the blameable callable can be any symfony2 service that implements __invoke method or any anonymous function, as soon as they return currently logged in user representation (which means everything, a User entity, a string, a username, ...). For an example of DI service that is invoked, look at the Knp\DoctrineBehaviors\ORM\Blameable\UserCallable class.

In the case of geocodable, you can set it as any service that implements __invoke or anonymous function that returns a Knp\DoctrineBehaviors\ORM\Geocodable\Type\Point object.

Testing

Read the documentation for testing