Wie zu verwenden der übersetzer-service innerhalb einer Entität?

Sollte man nicht und es ist im Allgemeinen nicht möglich. Nach der Prinzip Der Einzigen Verantwortung die Entität, die haben schon Ihren Zweck, die Repräsentation der Daten in einer Datenbank. Außerdem ist die übersetzung, ist eine Frage der Darstellung, so ist es unwahrscheinlich, dass Sie ansprechen möchten, wie ein problem in der entity-Schicht (es sei denn, Sie möchten Entitäten übersetzt in verschiedene Sprachen, die etwas ganz anderes problem und sollte auch nicht gelöst werden mit Hilfe der übersetzerin).

Überdenken, um Ihre Logik und versuchen, etwas anders. Sind Sie sicher, dass Sie nicht wollen, zu tun, diese übersetzung auf die view-Schicht? Das wäre das beste wahrscheinlich. Ansonsten (wenn deine Logik wirklich brauchen, um eine übersetzung zu einem Modell-Ebene) könnte man erstellen Sie eine wrapper-Klasse für die Personen und eine Fabrik zur Erstellung dieses "solide Unternehmen"; in diesem Werk könnten Sie injizieren die übersetzer-service.

Ich lief in dieses problem mehrere Male im Laufe der letzten Jahre und immer noch gut genug umgehen. Hier mal meine getIdentifyingName() Methoden, die Häufig verwendet im gesamten Projekt (wie eine explizite __toString()) übersetzen musste, einige Schlüsselwörter verwendet in der Daten-Ebene, so gab es keinen eleganten workaround.

Meine Lösung zu diesem Zeitpunkt ist ein TranslateObject und eine entsprechende helper-Dienst. Die TranslateObject ist ein einfaches Objekt holding übersetzung-Taste und eine Reihe von Platzhaltern, die auch TranslateObjects zu erlauben, multi-level-übersetzung (wie ein getIdentifyingNameTranslateObject() Aufruf einer anderen zugehörigen Objekts getIdentifyingNameTranslateObject() innerhalb der Platzhalter):

namespace App\Utils;

class TranslateObject
{
    /** @var string */
    protected $transKey;
    /** @var array */
    protected $placeholders;

    public function __construct(string $transKey, array $placeholders = [])
    {
        $this->transKey = $transKey;
        $this->placeholders = self::normalizePlaceholders($placeholders);
    }

    public static function normalizePlaceholders(array $placeholders): array
    {
        foreach ($placeholders as $key => &$placeholder) {
            if (substr($key, 0, 1) !== '%' || substr($key, -1, 1) !== '%') {
                throw new \InvalidArgumentException('The $placeholder attribute must only contain keys in format "%placeholder%".');
            }
            if ($placeholder instanceof TranslateObject) {
                continue;
            }
            if (is_scalar($placeholder)) {
                $placeholder = ['value' => $placeholder];
            }
            if (!isset($placeholder['value']) || !is_scalar($placeholder['value'])) {
                throw new \InvalidArgumentException('$placeholders[\'%placeholder%\'][\'value\'] must be present and a scalar value.');
            }
            if (!isset($placeholder['translate'])) {
                $placeholder['translate'] = false;
            }
            if (!is_bool($placeholder['translate'])) {
                throw new \InvalidArgumentException('$placeholders[\'%placeholder%\'][\'translate\'] must be a boolean.');
            }
        }
        return $placeholders;
    }

    public function getTransKey(): string
    {
        return $this->transKey;
    }

    public function getPlaceholders(): array
    {
        return $this->placeholders;
    }
}

Den Helfer sieht wie folgt aus und funktioniert:

namespace App\Services;

use App\Utils\TranslateObject;
use Symfony\Contracts\Translation\TranslatorInterface;

class TranslateObjectHelper
{
    /** @var TranslatorInterface */
    protected $translator;

    public function __construct(TranslatorInterface $translator)
    {
        $this->translator = $translator;
    }

    public function trans(TranslateObject $translateObject): string
    {
        $placeholders = $translateObject->getPlaceholders();
        foreach ($placeholders as $key => &$placeholder) {
            if ($placeholder instanceof TranslateObject) {
                $placeholder = $this->trans($placeholder);
            }
            elseif (true === $placeholder['translate']) {
                $placeholder = $this->translator->trans($placeholder['value']);
            }
            else {
                $placeholder = $placeholder['value'];
            }
        }

        return $this->translator->trans($translateObject->getTransKey(), $placeholders);
    }
}

Und dann innerhalb der Einheit gibt es eine getIdentifyingNameTranslateObject() Methode der Rückkehr eine TranslateObject.

/**
 * Get an identifying name as a TranslateObject (for use with TranslateObjectHelper)
 */
public function getIdentifyingNameTranslateObject(): TranslateObject
{
    return new TranslateObject('my.whatever.translation.key', [
        '%placeholder1%' => $this->myEntityProperty1,
        '%placeholderWithANeedOfTranslation%' => [
            'value' => 'my.whatever.translation.values.' . $this->myPropertyWithANeedOfTranslation,
            'translate' => true,
        ],
        '%placeholderWithCascadingTranslationNeeds%' => $this->getRelatedEntity()->getIdentifyingNameTranslateObject(),
    ]);
}

Wenn ich wieder so eine übersetzt Eigenschaft, die ich brauchen Zugang zu meinem injiziert TranslateObjectHelper service und nutzen Sie Ihre trans() Methode wie in einem controller oder jede andere Dienstleistung:

$this->translateObjectHelper->trans($myObject->getIdentifyingNameTranslateObject());

Dann erstellte ich einen Zweig filter als einfache Helfer wie diese:

namespace App\Twig;

use App\Services\TranslateObjectHelper;
use App\Utils\TranslateObject;

class TranslateObjectExtension extends \Twig_Extension
{
    /** @var TranslateObjectHelper */
    protected $translateObjectHelper;

    public function __construct(TranslateObjectHelper $translateObjectHelper)
    {
        $this->translateObjectHelper = $translateObjectHelper;
    }

    public function getFilters()
    {
        return array(
            new \Twig_SimpleFilter('translateObject', [$this, 'translateObject']),
        );
    }

    /**
    * sends a TranslateObject through a the translateObjectHelper->trans() method
    */
    public function translateObject(TranslateObject $translateObject): string
    {
        return $this->translateObjectHelper->trans($translateObject);
    }

    public function getName(): string
    {
        return 'translate_object_twig_extension';
    }
}

So, in Twig kann ich übersetzen wie diese:

{{ myObject.getIdentifyingNameTranslateObject()|translateObject }}

Bin ich am Ende "nur" benötigt, um zu finden, die alle getIdentifyingName() Anrufe (oder .identifyingName im Zweig) auf, dass Unternehmen, und ersetzen Sie Sie mit getIdentifyingNameTranslateObject() mit einem Aufruf an die trans() Methode der TranslateObjectHelper (oder die translateObject - filter in Twig).