So übersetzen Sie dynamische Inhalte in Rails mit der PTC API

Erfahren Sie, wie Sie die PTC API verwenden, um dynamische Inhalte in Ihrer Ruby on Rails (RoR)-Anwendung zu übersetzen. Dies umfasst Blog-Beiträge, Produktinformationen und alle in Ihrer Datenbank gespeicherten Texte.

Im Folgenden führen wir Sie in zwei Teilen durch den Prozess der Übersetzung dynamischer Inhalte in Rails-Anwendungen:

Zuerst lernen Sie die drei API-Endpunkte einzeln kennen – wie Sie Inhalte zur Übersetzung senden, den Status prüfen und fertige Übersetzungen abrufen.
Anschließend sehen Sie, wie Sie diese Endpunkte mithilfe von Callbacks oder Polling zu einem vollständigen Workflow verbinden.

Bevor Sie beginnen

Dieser Leitfaden setzt voraus, dass Sie eine Rails-Anwendung eingerichtet haben, die über eine Methode zum Speichern von Übersetzungen verfügt (wie Mobility, Globalize oder eine eigene Lösung).

Wenn Sie bei Null anfangen oder eine vollständige Implementierung sehen möchten, haben wir eine Demo-Rails-Anwendung erstellt, die die PTC-Integration von Anfang bis Ende zeigt. Die Demo verwendet:

Mobility zum Speichern von Übersetzungen
dotenv-rails für Umgebungsvariablen
delayed_job_active_record für die Hintergrundverarbeitung

PTC einrichten und API-Token abrufen

Um zu starten, benötigen Sie ein PTC-Konto und einen API-Token:

Registrieren Sie sich bei PTC. Die Erstellung eines Kontos ist kostenlos, und Sie können 20.000 Wörter in 2 Sprachen kostenlos übersetzen. Danach nutzen Sie die nutzungsbasierte Bezahlung für das, was Sie übersetzen.
Erstellen Sie ein neues Projekt und wählen Sie API integration.
Kopieren Sie den API-Token, den PTC am Ende der Projekteinrichtung generiert. Sie benötigen diesen Token, um alle Anfragen zu authentifizieren. Sie finden denselben Token in Ihrem Projekt-Dashboard unter Settings → Manage API tokens.

Ein neues Projekt in PTC erstellen — Ein neues Projekt erstellen

API-Integration im PTC-Setup auswählen — API-Integration auswählen

API-Token unter Settings → Manage API tokens

API-Endpunkte für die Übersetzung dynamischer Inhalte

Inhalte zur Übersetzung senden

Um Inhalte zu übersetzen, verwenden Sie den Create Content Translation-Endpunkt. Dies übermittelt Ihre Inhalte zur Übersetzung und gibt eine ID zurück, mit der Sie den Fortschritt verfolgen und Ergebnisse abrufen können.

Endpunkt:

POST https://app.ptc.wpml.org/api/v1/content_translation

Parameter:

data (erforderlich) – Der zu übersetzende Inhalt als Hash
name (erforderlich) – Eine Bezeichnung für diesen Übersetzungsauftrag (zum Beispiel "post-123-translation")
target_languages (optional) – Ein Array von Sprachcodes (zum Beispiel ["es", "fr", "de"])
callback_url (optional) – Eine URL, über die PTC Sie benachrichtigt, sobald die Übersetzungen bereit sind

Hier ist ein Beispiel-Service, der die Übersetzung startet:

Ruby

require 'net/http'
require 'uri'

module Ptc
  class TranslateService
    def initialize(data:, name:, target_languages:, callback_url: nil)
      @data = data
      @name = name
      @target_languages = target_languages
      @token = ENV.fetch("PTC_API_TOKEN")
      @callback_url = callback_url
    end

    def call
      translate
    end

    def self.call(**attributes)
      new(**attributes).call
    end

    private
    attr_reader :data, :name, :target_languages, :token, :callback_url

    def translate
      response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
        http.request(request)
      end
      JSON.parse(response.body)
    end

    def body
      {
        data:,
        name:,
        target_languages:,
        callback_url:,
      }.to_json
    end

    def request
      return @request if @request.present?

      @request ||= Net::HTTP::Post.new(uri)
      @request.content_type = "application/json"
      @request.body = body
      @request["Authorization"] = "Bearer #{token}"
      @request
    end

    def uri
      @uri ||= URI.parse("https://app.ptc.wpml.org/api/v1/content_translation")
    end
  end
end

Vollständige Details zur Antwort, Fehlercodes und zusätzliche Beispiele finden Sie in der Create Content Translation API-Dokumentation.

Übersetzungsstatus prüfen

Um zu prüfen, ob Ihre Übersetzung abgeschlossen ist, verwenden Sie den Get Content Translation Status-Endpunkt. Dieser gibt den aktuellen Status und den Übersetzungsfortschritt zurück.

Endpunkt:

GET https://app.ptc.wpml.org/api/v1/content_translation/{id}/status

Parameter:

id (erforderlich) – Die eindeutige Kennung des zu prüfenden Übersetzungsauftrags

Beispiel-Service in Rails:

Ruby

require 'net/http'
require 'uri'

module Ptc
  class GetTranslationStatusService
    def initialize(id:)
      @id = id
      @token = ENV.fetch("PTC_API_TOKEN")
    end

    def call
      get
    end

    def self.call(**attributes)
      new(**attributes).call
    end

    private
    attr_reader :id, :token

    def get
      response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
        http.request(request)
      end
      JSON.parse(response.body)
    end

    def request
      return @request if @request.present?

      @request ||= Net::HTTP::Get.new(uri)
      @request.content_type = "application/json"
      @request["Authorization"] = "Bearer #{token}"
      @request
    end

    def uri
      @uri ||= URI.parse("https://app.ptc.wpml.org/api/v1/content_translation/#{id}/status")
    end
  end
end

Die Antwort enthält ein Status-Feld und eine Prozentangabe zum Übersetzungsfortschritt. Vollständige Details zur Antwort finden Sie in der Get Content Translation API-Dokumentation.

Übersetzungen abrufen

Sobald Ihre Übersetzung abgeschlossen ist, verwenden Sie den Get Content Translations-Endpunkt, um die Ergebnisse abzurufen. Dieser gibt Ihren Originalinhalt sowie die übersetzten Versionen für jede Zielsprache zurück.

Endpunkt:

GET https://app.ptc.wpml.org/api/v1/content_translation/{id}

Parameter:

id (erforderlich) – Die eindeutige Kennung des abzurufenden Übersetzungsauftrags

Beispiel in Rails:

Ruby

require 'net/http'
require 'uri'

module Ptc
  class GetTranslationService
    def initialize(id:)
      @id = id
      @token = ENV.fetch("PTC_API_TOKEN")
    end

    def call
      get
    end

    def self.call(**attributes)
      new(**attributes).call
    end

    private
    attr_reader :id, :token

    def get
      response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
        http.request(request)
      end
        JSON.parse(response.body)
    end

    def request
      return @request if @request.present?

      @request ||= Net::HTTP::Get.new(uri)
      @request.content_type = "application/json"
      @request["Authorization"] = "Bearer #{token}"
      @request
    end

    def uri
      @uri ||= URI.parse("https://app.ptc.wpml.org/api/v1/content_translation/#{id}")
    end
  end
end

Benachrichtigung erhalten, wenn Übersetzungen bereit sind

Sie haben gelernt, wie Sie Inhalte senden, den Status prüfen und Übersetzungen abrufen. Nun müssen Sie diese Schritte verbinden, damit Ihre App automatisch weiß, wann sie Übersetzungen abrufen muss.

Dies können Sie mithilfe von Callbacks (empfohlen) oder durch einen Job tun, der den Übersetzungsstatus per Polling abfragt.

Verwendung von Callbacks (Empfohlen)

Wenn Sie Inhalte zur Übersetzung senden, können Sie eine Callback-URL angeben. PTC ruft diese URL auf, wenn die Übersetzung abgeschlossen ist. Ihr Endpunkt ruft dann die Übersetzungen ab und speichert sie.

Dies ist effizient, da PTC Sie sofort benachrichtigt.

Ruby

module Api
  class CallbacksController < ActionController::API
    before_action :set_post

    def create
      id = callback_params[:id]

      translation_data = Ptc::GetTranslationService.call(id:)
      translation_data.except("source").each do |locale, data|
        @post.set_translation(locale:, title: data["title"], description: data["description"])
      end

      head :ok
    end

    private

    def set_post
      @post = Post.find(params[:post_id])
    end

    def callback_params
      params.permit([:post_id, :id, :status, :translations_url])
    end
  end
end

Polling des Übersetzungsstatus (Alternative)

Können Sie keine Callbacks verwenden? Nach dem Senden von Inhalten zur Übersetzung können Sie einen Hintergrund-Job in die Warteschlange stellen, der wiederholt den Übersetzungsstatus prüft. Der Job ruft die Übersetzungen ab, sobald sie fertig sind.

Dieser Ansatz wird nicht empfohlen, da er Ressourcen verschwendet und unnötige API-Aufrufe verursacht.

Ruby

class CheckTranslationJob < ApplicationJob

  MAX_ATTEMPTS = 3

  def perform(id:, post_id:, attempt: 0)
    translation = Ptc::GetTranslationStatusService.call(id:)
    if translation["status"] == "completed"
      translation = Ptc::GetTranslationService.call(id:)
      post = Post.find(post_id)
      translation.except("source").each do |locale, data|
        post.set_translation(locale:, title: data["title"], description: data["description"])
      end
    else
      raise "Failed to get translation after #{MAX_ATTEMPTS} attempts" if attempt > MAX_ATTEMPTS

      CheckTranslationJob.set(wait: 1.minute).perform_later(id:, post_id:, attempt: attempt + 1)
    end
  end
end

Starten Sie mit der Übersetzung Ihrer Rails-Anwendung

Sie haben nun alles, was Sie zur Integration der Übersetzungs-API von PTC benötigen. Erstellen Sie ein kostenloses Konto und übersetzen Sie 20.000 Wörter in 2 Sprachen kostenlos.

Auf dieser Seite

Bevor Sie beginnen

PTC einrichten und API-Token abrufen

API-Endpunkte für die Übersetzung dynamischer Inhalte

Inhalte zur Übersetzung senden

Übersetzungsstatus prüfen

Übersetzungen abrufen

Benachrichtigung erhalten, wenn Übersetzungen bereit sind

Verwendung von Callbacks (Empfohlen)

Polling des Übersetzungsstatus (Alternative)

Bereit für PTC? Registrieren Sie sich für eine kostenlose 30-Tage-Testphase.