Dans les parties 01 et 02, nous avons exploré les bases de l'internationalisation dans Laravel, en utilisant d'abord les fonctionnalités natives, puis en simplifiant le processus avec des packages comme Laravel Lang et Laravel Langman. Dans cette partie 03, nous allons aller plus loin en abordant des techniques avancées pour gérer les traductions, notamment :

1. Gestion des traductions dynamiques en base de données.
2. Intégration avec des services de traduction externes.
3. Optimisation des performances pour les applications multilingues.

#1. Gestion des Traductions Dynamiques en Base de Données

Dans certains cas, les fichiers de langue statiques ne suffisent pas, surtout si vous avez besoin de permettre aux administrateurs de modifier les traductions sans déployer de nouveau code. Pour cela, vous pouvez stocker les traductions en base de données.

#1.1. Création de la Structure de Base de Données

Créez une table translations pour stocker les traductions :

php artisan make:migration create_translations_table

Dans le fichier de migration :

public function up()
{
    Schema::create('translations', function (Blueprint $table) {
        $table->id();
        $table->string('locale'); // Langue (ex: 'en', 'fr')
        $table->string('group');  // Groupe (ex: 'messages', 'validation')
        $table->string('key');    // Clé de traduction (ex: 'welcome')
        $table->text('value');    // Valeur traduite
        $table->timestamps();
    });
}

Exécutez la migration :

php artisan migrate

#1.2. Modèle et Repository

Créez un modèle Translation et un repository pour interagir avec la table :

php artisan make:model Translation

Dans le modèle Translation :

namespace App\Models;
 
use Illuminate\Database\Eloquent\Model;
 
class Translation extends Model
{
    protected $fillable = ['locale', 'group', 'key', 'value'];
}

Dans un repository TranslationRepository :

namespace App\Repositories;
 
use App\Models\Translation;
 
class TranslationRepository
{
    public function getTranslation($locale, $group, $key)
    {
        return Translation::where('locale', $locale)
                          ->where('group', $group)
                          ->where('key', $key)
                          ->value('value');
    }
 
    public function updateOrCreateTranslation($locale, $group, $key, $value)
    {
        return Translation::updateOrCreate(
            ['locale' => $locale, 'group' => $group, 'key' => $key],
            ['value' => $value]
        );
    }
}

#1.3. Utilisation dans l'Application

Pour utiliser les traductions dynamiques, vous pouvez créer un helper personnalisé :

if (!function_exists('trans_db')) {
    function trans_db($key, $replace = [], $locale = null)
    {
        $locale = $locale ?? app()->getLocale();
        $group = 'messages'; // Par défaut
 
        // Récupérer la traduction depuis la base de données
        $translation = app(TranslationRepository::class)->getTranslation($locale, $group, $key);
 
        return $translation ?? $key; // Retourner la clé si la traduction n'existe pas
    }
}

Exemple d'utilisation :

echo trans_db('welcome'); // Affiche la traduction depuis la base de données

#2. Intégration avec des Services de Traduction Externes

Pour les applications nécessitant des traductions automatiques ou multilingues à grande échelle, vous pouvez intégrer des services de traduction externes comme Google Translate ou DeepL.

#2.1. Installation d'un Package d'Intégration

Utilisez un package comme google/cloud-translate pour intégrer Google Translate :

composer require google/cloud-translate

#2.2. Configuration

Ajoutez vos clés d'API dans le fichier .env :

GOOGLE_TRANSLATE_API_KEY=votre_clé_api

#2.3. Utilisation du Service

Créez un service pour gérer les traductions :

namespace App\Services;
 
use Google\Cloud\Translate\V2\TranslateClient;
 
class TranslationService
{
    protected $translate;
 
    public function __construct()
    {
        $this->translate = new TranslateClient([
            'key' => env('GOOGLE_TRANSLATE_API_KEY'),
        ]);
    }
 
    public function translateText($text, $targetLanguage)
    {
        $result = $this->translate->translate($text, [
            'target' => $targetLanguage,
        ]);
 
        return $result['text'];
    }
}

Exemple d'utilisation :

$translationService = new TranslationService();
$translatedText = $translationService->translateText('Welcome', 'fr');
echo $translatedText; // Affiche "Bienvenue"

#3. Optimisation des Performances pour les Applications Multilingues

#3.1. Cache des Traductions

Laravel propose un système de cache pour les traductions. Activez-le dans config/app.php :

'locale' => 'fr',
'fallback_locale' => 'en',
'cache_translations' => true, // Activer le cache des traductions

Utilisez la commande suivante pour vider le cache des traductions :

php artisan config:cache

#3.2. Chargement Différé des Fichiers de Langue

Pour les applications avec de nombreuses langues, chargez uniquement les fichiers de langue nécessaires :

if (!function_exists('load_locale')) {
    function load_locale($locale)
    {
        $path = resource_path("lang/{$locale}");
        if (file_exists($path)) {
            app('translator')->addNamespace('custom', $path);
        }
    }
}

#4. Conclusion

Dans cette partie 03, nous avons exploré des techniques avancées pour gérer les traductions dans Laravel :

• Traductions dynamiques en base de données pour une gestion flexible.
• Intégration avec des services externes comme Google Translate pour des traductions automatiques.
• Optimisation des performances avec le cache et le chargement différé.

Ces techniques vous permettent de créer des applications multilingues robustes et performantes, adaptées à des projets de grande envergure. Avec ces outils, vous êtes prêt à relever les défis de l'internationalisation dans Laravel ! 🌍