Symfony контент в базе данных на нескольких языках?

Question

[Игорь]

Коллеги, здравствуйте!

Хочу выбрать оптимально подходящее решение, для текущей задачи.

Задача.
Контент в базе данных на трёх языках.
ru, cn, en

Нашёл несколько решений.

1. Translatable Extension
2. Doctrine behaviors

Оба имеют существенные недостатки, надеюсь что это не так.
Попробовал поработать с этими расширениями и понял, они далеки от идеала.
Некоторые из них, вообще устарели.
В документации последнее упоминание о Symfony 2

Попробовал повторно заюзать их же.
Не могу получить желаемый результат.

Сроки жмут.

Решил пойти на крайности

/**
     * @ORM\Column(name="name", length=64)
     */
    private $name_ru;

    /**
     * @ORM\Column(length=64, nullable=true)
     */
    private $name_cn;

    /**
     * @ORM\Column(length=64, nullable=true)
     */
    private $name_en;

/**
     * @param $name
     * @param string $lang
     */
    public function setName($name, $lang = "ru")
    {
        $this->{"name_$lang"} = $name;
    }

    /**
     * @param string $lang
     * @return mixed
     */
    public function getName($lang = "ru")
    {
        return $this->{"name_$lang"};
    }

На глаз видно, работать будет.
Особых проблем не вижу.

Недостатки:
Внедрение нового языка требует вмешательство во все сущности, это огромный минус.
Но на горизонте только 3 языка, испанский не планируем.

Посоветуйте рабочие стратегии.
Или если мой крайний вариант не имеет криминала.

Answer 1

[Denis]

Как вариант сделать таблицу языков, а в вашем варианте оставить name и добавить language_id, немного усложненный чем Ваш вариант но более расширяемый

Comments

[Игорь]

Denis, то есть, в сущностях, в которых требуется перевод, завести свойство langueage, а также создать саму сущность Language.

Связать их OneToOne.

При добавлении контента, выбираем нужный язык.

Вы это имеете в виду?

[Игорь]

Как вариант, по-моему, у меня был подобный подход, годом ранее.
Да, это работало для меня.
Это позволяет неограниченное количество языков внедрять.

Из недостатков выявил для себя.

Стороннему пользователю тяжело контролировать контент.

[Игорь]

Ещё один недостаток такого подхода.
Это разные идентификаторы для одной и той же записи, на разных языках.
В идеале, нужна отдельная таблица для переводов.

[Denis]

Игорь,
Отдельная таблица это отдельный джоин, и потом скорее всего будет неудобно делать выборку, если допустим в таблице много мультиязычных полей типа имя, описание, сео теги и тд и вот тут Вам возможно придется проверять есть ли перевод на текущем языке значение если оно пустое, то вывести дефолтное. В моем случае это будет запрос с одним джоином в Вашем, как реализуется одну общую таблицу для перевода, где помимо перевода будет храниться тип сущности(описание продукта, запись блога, описание категории, описание платежной системы), и тип перевода(заголовок, описание, краткое описание, мета-тайтл, мета-дескрипшен)
Таблицу переводов можно сделать для перевода сайта в целом, где в моем случае это language_id, key, value.

[Игорь]

Denis, Отдельные джоины меня немного напрягают, тем более если начнутся какие нибуть усложнения в поиске.

Я подумал, а зачем усложнять?
Компания чётко поставила задачу, нужно три языка.

Я выбрал примитивную стратегию (описал в своём ответе)
Работает быстро, полностью закрывает задачу.

Но внутреннего удовлетворения нет ((

Answer 2

[Игорь]

Нашёл для себя решение.
Не уверен в том, что это адекватная практика.
Тем не менее, как мне показалось, это то что мне нужно.

Описываю логику.

<?php


namespace App\Classes\Entity;

/**
 * Class AbstractEntity
 * @package App\Classes\Entity
 */
abstract class AbstractEntity
{
    /** @var string  */
    protected $language = "ru";

    /**
     * @param string $language
     */
    public function setLanguage(string $language): void
    {
        $this->language = $language;
    }
}

<?php


namespace App\Entity;


use App\Classes\Entity\AbstractEntity;
use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\ORM\Mapping\JoinColumn;
use Doctrine\ORM\Mapping as ORM;
use Symfony\Component\Validator\Constraints\NotNull;
use Symfony\Component\Validator\Mapping\ClassMetadata;

/**
 * @ORM\Entity(repositoryClass="App\Repository\CategoryRepository")
 * @ORM\Table(name="categories")
 */
class Category extends AbstractEntity
{

    /**
     * @ORM\Column(type="integer")
     * @ORM\Id
     * @ORM\GeneratedValue
     */
    private $id;

    /**
     * @ORM\Column(name="name", length=64)
     */
    private $name_ru;

    /**
     * @ORM\Column(length=64, nullable=true)
     */
    private $name_cn;

    /**
     * @ORM\Column(length=64, nullable=true)
     */
    private $name_en;

    /**
     * @return mixed
     */
    public function getId()
    {
        return $this->id;
    }

    /**
     * @param $name
     * @param string $lang
     */
    public function setName($name, $lang)
    {
        $this->{"name_$lang"} = $name;
    }

    /**
     * @return string
     */
    public function getName()
    {
        return $this->{"name_$this->language"};
    }

}

Слушатель, для того что бы можно было переключать свойство language, которые мы будем наследовать от AbstractEntity, своего рода контракт.

<?php


namespace App\Listeners;

use App\Classes\Entity\AbstractEntity;
use Doctrine\Persistence\Event\LifecycleEventArgs;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\RequestStack;


/**
 * Class LanguageEntityListener
 * @package App\Listeners
 */
class LanguageEntityListener
{

    /** @var string  */
    private $language = "ru";
    /** @var Request */
    private $request;

    /**
     * LanguageEntityListener constructor.
     * @param RequestStack $requestStack
     */
    public function __construct(RequestStack $requestStack)
    {
        $this->request = $requestStack->getCurrentRequest();
        $this->language = $this->request->get("lang", "ru");
    }


    public function postLoad(LifecycleEventArgs $event)
    {
        $entity = $event->getObject();

        if (is_a($entity, AbstractEntity::class)) {
            $entity->setLanguage($this->language);
        }
    }
}

services.yaml

services:
   
    app.listeners.language_entity_listener:
        class: App\Listeners\LanguageEntityListener
        arguments: ['@request_stack']
        tags:
            - { name: doctrine.event_listener, event: postLoad, method: postLoad }

Понятное дело, что это решение тяжело масштабируется.

Comments

[BoShurik]

Я делал что-то вроде этого:

class Article
{
    private $id;

    private $publishedAt;

    private $slug;

    /**
     * @var Content[]
     */
    private $contents;

    public function getContentForLocale($locale)
    {
        foreach ($this->contents as $content) {
            if ($locale === $content->getLocale()) {
                return $content;
            }
        }

        return null;
    }
}

class Content
{
    private $id;

    private $article;

    private $locale;

    private $name;

    private $description;

    private $content;
}

[Игорь]

BoShurik, Да, это распространённая стратегия.
Я делал так же, но только без ORM.

Сейчас меня интересует производительность и скорость введения новой сущности.
Хотя последнее не так критично.

Ещё не мало важно, сами сущности отражают структуру ответа.
Например

{
    "code": 0,
    "count": 28,
    "items": [
        {
            "id": 1,
            "price": 469,
            "name": "黑果越橘桔子奇亚籽",
            "old_price": 0,
            "image": null,
            "description": "奇亚籽，椰子奶，香蕉，桔子，浆果糖浆。配花生和薄荷。"
        },
        {
            "id": 2,
            "price": 715,
            "name": "FRIDAYS™ 签名汉堡包",
            "old_price": 0,
            "image": null,
            "description": "\"主要由两片小圆面包夹一块牛肉饼，胡椒的培根，干酪组成，配\nFridays™ 特色酱\""
        },
        {
            "id": 4,
            "price": 640,
            "name": "FRIDAYS™ 芝士汉堡包",
            "old_price": 0,
            "image": null,
            "description": "传统的汉堡包"
        }
    ]
}

image это тоже сущность, но в данном примере нет ссылки на эту сущность, поэтому сериализация отразила данную структуру в таком виде.

О чём я, а что если в этой сущности нужно ввести поле alt на все тех же трёх языках?
Нам снова придётся "гондобить" 2 таблицы.

[Игорь]

В своём ответе, я отразил примитивную схему реализации мультиязычного контента.
С капелькой магии при переключении языка.

[BoShurik]

Ещё не мало важно, сами сущности отражают структуру ответа.

ИМХО, сущности должны быть в нормализованном виде, а их отображение - это уже другой вопрос. Это легко решается кастомным нормалайзером:

public function normalize($object, $format = null, array $context = [])
{
    $content = $object->getContentForLocale($this->locale);

    return [
        'id' => $object->getId(),
        'name' => $content->getName(),
        'description' => $content->getDescription(),
    ];
}

В целом, серебряной пули нет, подход зависит от задачи. К примеру, Image можно не локализовать, а перенести ее в Content, т.о. будет на каждый язык свое изображение. Как вариант, переводы можно хранить в json с помощью dunglas/doctrine-json-odm

[Игорь]

BoShurik,

В целом, серебряной пули нет

Понимаю...

Способ который вы привели, подходит если у нас 30 языков и более.
Хотя он мне тоже нравится.
Уже подумываю, пока не поздно переделать.
Пока взвешиваю за и против.

В своём решении, я переключаю язык в слушателе, по сути в контроллере я не выполняю это, а просто сереализую объект.

[Игорь]

BoShurik, Опробовал реализовать ранее упомянутую вами схему, она достаточно распространённая и если её сравнивать с остальными имеет меньшее количество минусов.

На коленке собрал, заработало.
Сейчас сил нет описать, чуть позже.

Кардинально нет нечего нового.
Некоторые детали подсмотрел здесь.

[Игорь]

Да, конечно сериализация по дефолту теперь не работает.
Нужно отдельно кастомизировать.

[Игорь]

Решение №2

AbstractTranslation.php

<?php

namespace App\Classes\Translatable;


use Doctrine\ORM\Mapping as ORM;

/**
 * Class AbstractTranslation
 * @package App\Entity
 */
abstract class AbstractTranslation
{

    /**
     * @ORM\Id()
     * @ORM\GeneratedValue()
     * @ORM\Column(type="integer")
     */
    protected $id;

    /**
     * @ORM\Column(type="string", length=10)
     */
    protected $lang;

    /**
     * @var string $field
     * @ORM\Column(length=255)
     */
    protected $field;


    /**
     * @var string $content
     *
     * @ORM\Column(type="text", nullable=true)
     */
    protected $content;

    /**
     * Get id
     *
     * @return integer $id
     */
    public function getId()
    {
        return $this->id;
    }

    /**
     * @param string $locale
     * @return static
     */
    public function setLang(string $locale)
    {
        $this->lang = $locale;
        return $this;
    }

    /**
     * @return string|null
     */
    public function getLang(): ?string
    {
        return $this->lang;
    }

    /**
     * Set field
     *
     * @param string $field
     *
     * @return static
     */
    public function setField(string $field)
    {
        $this->field = $field;
        return $this;
    }

    /**
     * Get field
     *
     * @return string
     */
    public function getField()
    {
        return $this->field;
    }

    /**
     * @param string $content
     * @return static
     */
    public function setContent($content)
    {
        $this->content = $content;
        return $this;
    }

    /**
     * Get content
     *
     * @return string
     */
    public function getContent()
    {
        return $this->content;
    }
}

AbstractTranslationEntity.php

<?php


namespace App\Classes\Translatable;


abstract class AbstractTranslationEntity
{
    use PropertyManager;
}

PropertyManager.php

<?php


namespace App\Classes\Translatable;

/**
 * Trait PropertyManager
 * @package App\Classes\Translatable
 */
trait PropertyManager
{
    /**
     * @param string $name
     * @param $value
     */
    public function setProperty(string $name, $value)
    {
        $this->{$name} = $value;
    }


    /**
     * @param string $name
     * @return
     */
    public function getProperty(string $name)
    {
        return $this->{$name};
    }

    /**
     * @param string $name
     * @return bool
     */
    public function hasOwnProperty(string $name)
    {
        return isset($this->{$name});
    }
}

TranslationEntityInterface.php

<?php


namespace App\Classes\Translatable;

/**
 * Interface TranslationEntity
 * @package App\Classes\Entity
 */
interface TranslationEntityInterface
{
    /**
     * @param $entity
     * @return mixed
     */
    public function addTranslation($entity);

    /**
     * @param string $lang
     * @return mixed
     */
    public function getTranslations(string $lang);
}

TranslationInterface.php

<?php


namespace App\Classes\Translatable;

/**
 * Interface TranslationInterface
 * @package App\Classes\Translatable
 */
interface TranslationInterface
{

    /**
     * @ORM\ManyToOne(targetEntity="Product", inversedBy="translations")
     * @ORM\JoinColumn(name="owner_id", referencedColumnName="id", onDelete="CASCADE")
     */

    /**
     * ProductTranslation constructor.
     * @param string $lang
     * @param string $field
     * @param $value
     */
    public function __construct(string $lang, string $field, $value);

    /**
     * @param $owner
     */
    public function setOwner($owner): void;

    /**
     * @return mixed
     */
    public function getOwner();
}

Сущности

<?php


namespace App\Entity;


use App\Classes\Translatable\AbstractTranslationEntity;
use App\Classes\Translatable\TranslationEntityInterface;
use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\ORM\Mapping as ORM;
use Symfony\Component\Validator\Constraints as Assert;

/**
 * @ORM\Entity(repositoryClass="App\Repository\CategoryProductRepository")
 * @ORM\Table(name="categories_products")
 */
class CategoryProduct extends AbstractTranslationEntity implements TranslationEntityInterface
{

    /**
     * @ORM\Column(type="integer")
     * @ORM\Id
     * @ORM\GeneratedValue
     */
    private $id;

    protected $name;

    protected $description;

    /**
     * @var Image|null
     * @ORM\ManyToOne(targetEntity="App\Entity\Image", fetch="EXTRA_LAZY")
     * @ORM\Column(nullable=true)
     */
    private $image;

    /**
     * @var Restaurant
     * @Assert\NotNull
     * @ORM\ManyToOne(targetEntity="Restaurant", fetch="EXTRA_LAZY")
     */
    private $restaurant;

    /**
     * @var ArrayCollection
     * @ORM\OneToMany(
     *     targetEntity="CategoryProductTranslation",
     *     mappedBy="owner",
     *     cascade={"persist", "remove"},
     *     fetch="EXTRA_LAZY"
     * )
     */
    private $translations;

    /**
     * CategoryProduct constructor.
     */
    public function __construct()
    {
        $this->translations = new ArrayCollection();
    }

    /**
     * @return mixed
     */
    public function getId()
    {
        return $this->id;
    }

    /**
     * @return string|null
     */
    public function getName(): ?string
    {
        return $this->name;
    }

    /**
     * @return Image|null
     */
    public function getImage(): ?Image
    {
        return $this->image;
    }

    /**
     * @param Image|null $image
     */
    public function setImage(?Image $image): void
    {
        $this->image = $image;
    }


    /**
     * @return Restaurant|null
     */
    public function getRestaurant(): ?Restaurant
    {
        return $this->restaurant;
    }

    /**
     * @param Restaurant $restaurant
     */
    public function setRestaurant(?Restaurant $restaurant): void
    {
        $this->restaurant = $restaurant;
    }

    /**
     * @param $entity
     * @return CategoryProduct
     */
    public function addTranslation($entity)
    {
        if (!$this->translations->contains($entity)) {
            $this->translations[] = $entity;
            $entity->setOwner($this);
        }
        return $this;
    }

    /**
     * @param string $lang
     * @return ArrayCollection
     */
    public function getTranslations(string $lang)
    {
        $translations = new ArrayCollection();
        /** @var ProductTranslation $item */
        foreach ($this->translations->toArray() as $item) {
            if ($item->getLang() == $lang) {
                $translations->add($item);
            }
        }
        return $translations;
    }

    /**
     * @return mixed
     */
    public function getDescription(): ?string
    {
        return $this->description;
    }
}

<?php


namespace App\Entity;


use App\Classes\Translatable\AbstractTranslation;
use App\Classes\Translatable\TranslationInterface;
use Doctrine\ORM\Mapping as ORM;

/**
 * @ORM\Entity
 * @ORM\Table(name="categories_products_translations")
 */
class CategoryProductTranslation extends AbstractTranslation implements TranslationInterface
{

    /**
     * ProductTranslation constructor.
     * @param string $lang
     * @param string $field
     * @param $value
     */
    public function __construct(string $lang, string $field, $value)
    {
        $this->setLang($lang);
        $this->setField($field);
        $this->setContent($value);
    }

    /**
     * @ORM\ManyToOne(targetEntity="CategoryProduct", inversedBy="translations")
     * @ORM\JoinColumn(name="owner_id", referencedColumnName="id", onDelete="CASCADE")
     */
    protected $owner;

    /**
     * @param $owner
     */
    public function setOwner($owner): void
    {
        $this->owner = $owner;
    }

    /**
     * @return mixed
     */
    public function getOwner()
    {
        return $this->owner;
    }
}

[Игорь]

Сервис для автоматического перевода свойств

<?php


namespace App\Service;

use App\Classes\Translatable\TranslationEntityInterface;
use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\ORM\PersistentCollection;

/**
 * Class EntityTranslation
 * @package App\Service
 */
class EntityTranslation
{
    /**
     * @param $entity
     * @param string $lang
     * @param array $properties
     * @return ArrayCollection
     */
    public function translate($entity, string $lang, $properties = [])
    {
        if (is_array($entity) or is_a($entity, PersistentCollection::class)) {
            return $this->translateCollection($entity, $lang, $properties);
        } elseif (is_a($entity, TranslationEntityInterface::class)) {
            $this->translateOneObject($entity, $lang, $properties);
        }
    }

    /**
     * @param $items
     * @param string $lang
     * @param array $properties
     * @return ArrayCollection
     */
    public function translateCollection($items, string $lang, $properties = [])
    {
        foreach ($items as $item) {
            foreach ($item->getTranslations($lang) as $translation) {
                $item->setProperty($translation->getField(), $translation->getContent());
            }

            foreach ($properties as $property_name) {
                if ($item->hasOwnProperty($property_name)) {
                    $this->translate($item->getProperty($property_name), $lang, []);
                }
            }
        }
        return $items;
    }

    /**
     * @param TranslationEntityInterface $entity
     * @param string $lang
     * @param array $properties
     * @return TranslationEntityInterface
     */
    public function translateOneObject(TranslationEntityInterface $entity, string $lang, $properties = [])
    {

        foreach ($entity->getTranslations($lang) as $translation) {
            $entity->setProperty($translation->getField(), $translation->getContent());
        }

        foreach ($properties as $property_name) {
            if ($entity->hasOwnProperty($property_name)) {
                $this->translate($entity->getProperty($property_name), $lang, []);
            }
        }

        return $entity;
    }
}

Как использовать?

/**
     * @Route(
     *     path="/products.getCategories",
     *     methods={"GET"}
     * )
     * @param Request $request
     * @param EntityManagerInterface $manager
     * @param NormalizerInterface $normalizer
     * @param EntityTranslation $et
     * @param Lang $lang
     * @return JsonResponse
     * @throws ExceptionInterface
     */
    public function getCategories(
        Request $request,
        EntityManagerInterface $manager,
        NormalizerInterface $normalizer,
        EntityTranslation $et,
        Lang $lang
    )
    {
        /** @var CategoryProductRepository $categories_repository */
        $categories_repository = $manager->getRepository("App:CategoryProduct");

        $rs = new ResponseSchemaItems();
        $rs->setCount($categories_repository->count(["restaurant" => $request->get("restaurant_id")]));

        $categories = $categories_repository->getAll(
            $request->get("restaurant_id", 0),
            $request->get("q", ""),
            $request->get("offset", 0),
            $request->get("count", 100)
        );

        $et->translate($categories, $lang->get());

        $rs->setItems($categories);

        $response_object = $normalizer->normalize($rs, "json", [
            "attributes" => [
                "code",
                "count",
                "items" => [
                    "id",
                    "name",
                    "description"
                ]
            ]
        ]);
        return $this->json($response_object);
    }

$et->translate($categories, $lang->get(), []);

Глубина перевода будет зависеть от третьего параметра (массива свойств)