Ao lidar com conteúdo multilíngue, geralmente é mais eficiente armazenar traduções em uma coluna JSON em vez de linhas individuais para cada atributo. Essa abordagem consolida as traduções em uma única coluna, simplificando o gerenciamento e a recuperação de dados.

Configurando o sistema de tradução

Aprimoraremos nosso modelo e tabela de tradução para usar uma coluna JSON para armazenar traduções. Isso envolverá a atualização do esquema da tabela e a modificação da característica Translatable para lidar com dados JSON.

Etapa 1: Criar migração de tabela de traduções

Se a tabela de traduções ainda não existir, crie uma nova migração:

php artisan make:migration create_translations_table

Etapa 2: Definir a estrutura da tabela

Abra o arquivo de migração gerado em database/migrations. Para uma nova tabela, defina-a da seguinte forma:

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

class CreateTranslationsTable extends Migration
{
    public function up()
    {
        Schema::create('translations', function (Blueprint $table) {
            $table->id();
            $table->string('locale'); // Stores the locale, e.g., 'en', 'fr'
            $table->string('translatable_type'); // Stores the related model type, e.g., 'Post', 'Product'
            $table->unsignedBigInteger('translatable_id'); // Stores the ID of the related model
            $table->json('translations'); // Stores all translations as a JSON object
            $table->timestamps();
        });
    }

    public function down()
    {
        Schema::dropIfExists('translations');
    }
}

Etapa 3: execute a migração
Aplique a migração ao seu banco de dados:

php artisan migrate

Etapa 4: Crie o modelo de tradução

Em seguida, crie o modelo de tradução para lidar com o relacionamento polimórfico:

php artisan make:model Translation

No modelo de Tradução, defina o relacionamento polimórfico:

class Translation extends Model
{
    protected $fillable = ['locale', 'translatable_type', 'translatable_id', 'translations'];

    protected $casts = [
        'translations' => 'array',
    ];

    public function translatable()
    {
        return $this->morphTo();
    }
}

Implementando a característica traduzível com armazenamento JSON

Para tornar o tratamento da tradução reutilizável em vários modelos, criaremos uma característica Traduzível que carregará automaticamente o conteúdo traduzido com base na localidade selecionada pelo usuário. Além disso, adicionaremos um mecanismo substituto para carregar o conteúdo da localidade padrão se nenhuma tradução estiver disponível para a localidade selecionada.

Etapa 1: Crie a característica traduzível com tratamento JSON

namespace App\Traits;

use App\Models\Translation;
use Illuminate\Support\Facades\App;

trait Translatable
{
    public static function bootTranslatable()
    {
        static::retrieved(function ($model) {
            $model->loadTranslations();
        });
    }

    public function translations()
    {
        return $this->morphMany(Translation::class, 'translatable');
    }

    public function loadTranslations()
    {
        $locale = App::getLocale();
        $defaultLocale = config('app.default_locale', 'en'); // Fallback to the default locale

        // Try to load translations for the current locale
        $translation = $this->translations()->where('locale', $locale)->first();

        if (!$translation && $locale !== $defaultLocale) {
            // If no translations are found for the current locale, fallback to the default locale
            $translation = $this->translations()->where('locale', $defaultLocale)->first();
        }

        if ($translation) {
            $translations = $translation->translations;
            foreach ($translations as $key => $value) {
                $this->{$key} = $value;
            }
        }
    }

    public function addTranslations(array $translations, $locale = null)
    {
        $locale = $locale ?? App::getLocale();
        return $this->translations()->updateOrCreate(
            ['locale' => $locale],
            ['translations' => $translations]
        );
    }
}

Etapa 2: aplique a característica traduzível ao seu modelo
Adicione a característica Traduzível a qualquer modelo que exija suporte de tradução.

namespace App\Models;

use App\Traits\Translatable;
use Illuminate\Database\Eloquent\Model;

class Post extends Model
{
    use Translatable;

    protected $fillable = ['title', 'content'];
}

Exemplo: Criando um Modelo Traduzido

Adicione traduções como um objeto JSON:

$post = Post::create(['title' => 'Default Title', 'content' => 'Default Content']);

// Adding translations
$post->addTranslations([
    'title' => 'Hello World',
    'content' => 'Welcome to our website'
], 'en');

$post->addTranslations([
    'title' => 'Bonjour le monde',
    'content' => 'Bienvenue sur notre site Web'
], 'fr');

Recuperando modelos traduzidos

Quando você recupera o modelo Post, ele carrega automaticamente o conteúdo traduzido com base na localidade atual ou volta para a localidade padrão, se necessário:

App::setLocale('fr');
$post = Post::find(1);
echo $post->title; // Displays "Bonjour le monde" if French translation exists

App::setLocale('es');
$post = Post::find(1);
echo $post->title; // Displays "Hello World" as it falls back to the English translation

Exibindo conteúdo traduzido em visualizações

Nas visualizações do Blade, você pode exibir o conteúdo traduzido como qualquer outro atributo do modelo:

{{ $post->title }}
{{ $post->content }}

Conclusão

Ao usar uma coluna JSON para armazenar traduções e implementar um mecanismo de fallback, você agiliza o gerenciamento de conteúdo multilíngue em sua aplicação Laravel. Essa abordagem consolida as traduções em uma única coluna, simplificando o manuseio de dados e tornando sua base de código mais fácil de manter. Esteja você criando um blog, um site de comércio eletrônico ou qualquer aplicativo multilíngue, esse método garante uma experiência de usuário tranquila e eficiente.

Aproveitar!