Doctrine Behaviors Documentation

To use the Translatable behavior with API Platform, you must implement the TranslatableInterface and TranslationInterface on your entities. Instead of defining translatable properties directly on the main entity, you access them through the translate() method provided by the TranslatableTrait. This allows the API to return different values based on the current request locale.

1. Configure the Main Entity

Implement TranslatableInterface and use TranslatableTrait. Use the translate() method within your getters to fetch data from the translation entity.

2. Configure the Translation Entity

Implement TranslationInterface and use TranslationTrait. This entity holds the actual translatable fields (e.g., title).

3. Handle Locales via Request Headers

To make the API respond to different languages, implement a Symfony EventSubscriber that listens to the KernelEvents::REQUEST event. This subscriber should parse the Accept-Language header and set the request locale accordingly.

### Main Entity Example
```php
use Knp//... (see full example below)

To implement translatable behavior, you need two entities: a main entity and a translation entity. The TranslatableEventSubscriber handles the associations automatically based on naming conventions.

1. The Translation Entity: Contains the fields that need to be translated. It must implement TranslationInterface and use the TranslationTrait.
2. The Main Entity: Contains fields that do not need translation. It must implement TranslatableInterface and use the TranslatableTrait.

Example naming convention: App\Entity\Category and App\Entity\CategoryTranslation.

<?php

namespace App//Entity;

use Doctrine\ORM\Mapping as ORM;
use Knp\DoctrineBehaviors\Contract\Entity\TranslationInterface;
use Knp\DoctrineBehaviors\Model\Translatable\TranslationTrait;

#[ORM\Entity]
class CategoryTranslation implements TranslationInterface
{
    use TranslationTrait;

    #[ORM\Id]
    #[ORM\GeneratedValue]
    #[ORM\Column(type: 'integer')]
    private $id;

    #[ORM\Column(type: 'string', length: 255)]
    protected $description;

    public function getId(): ?int { return $this->id; }
    public function getDescription(): string { return $this->description; }
    public function setDescription(string $description): void { $this->description = $description; }
}

// --- Main Entity ---

namespace App\Entity;

use Doctrine\ORM\Mapping as ORM;
use Knp\DoctrineBehaviors\Contract\Entity\TranslatableInterface;
use Knp\DoctrineBehaviors\Model\Translatable\TranslatableTrait;

#[ORM\Entity]
class Category implements TranslatableInterface
{
    use TranslatableTrait;
    
    #[ORM\Id]
    #[ORM\GeneratedValue]
    #[ORM\Column(type: 'integer')]
    private $id;

    #[ORM\Column(type: 'string', length: 255)]
    protected $someFieldYouDoNotNeedToTranslate;

    public function getId(): ?int { return $this->id; }
}

Once the TreeNodeInterface is implemented, you can build hierarchies by using setChildNodeOf($parentNode) on a child entity. To retrieve the entire tree structure, use the getTree() method on the entity's repository.

The getTree() method returns a nested structure that allows for the following operations:

• getParentNode(): Returns the parent of the current node (or null for root nodes).
• getChildNodes(): Returns an ArrayCollection of child nodes.
• isLeafNode(): Returns true if the node has no children.
• isRootNode(): Returns true if the node has no parent.
• Nested access: You can traverse the tree using array-like syntax (e.g., $root[0][1]) to access specific nodes or null values in the hierarchy.

/** @var Knp\DoctrineBehaviors\Contract\Entity\TreeNodeInterface $category */
$category = new Category();
$category->setId(1);

$child = new Category();
$child->setId(2);

// Establish the hierarchy
$child->setChildNodeOf($category);

$entityManager->persist($child);
$entityManager->persist($category);
$entityManager->flush();

// Retrieve and traverse the tree
$categoryRepository = $entityManager->getRepository(Category::class);
$root = $categoryRepository->getTree();

$root->getParentNode(); // null
$root->getChildNodes(); // ArrayCollection
$root[0][1];           // node or null
$root->isLeafNode();    // boolean
$root->isRootNode();    // boolean