みんなの自動翻訳＠KI
ヘルプ

const fs = require('fs');

class Translator {
  #userName;
  #apiKey;
  #apiSecret;
  #tokenFilePath;
  #tokenEndpoint;
  #mtEndpoint;

  constructor(
    userName,
    apiKey,
    apiSecret,
    serverName,
    tokenFilePath,
  ) {
    this.#userName = userName;
    this.#apiKey = apiKey;
    this.#apiSecret = apiSecret;
    this.#tokenFilePath = tokenFilePath;
    this.#tokenEndpoint = `https://${serverName}/oauth2/token.php`;
    this.#mtEndpoint = `https://${serverName}/api/mt`;
  }

  async translate(
    sourceText,
    engineId,
    split,
    xml,
  ) {
    const accessToken = await this.#getAccessToken();
    const result = await this.#postData(`${this.#mtEndpoint}/${engineId}/`, {
      name: this.#userName,
      key: this.#apiKey,
      access_token: accessToken,
      type: 'json',
      text: sourceText,
      split: split,
      xml: xml,
    });
    const resultCode = result.resultset.code;
    if (resultCode !== 0)
      throw new Error(`Translation error ${resultCode}`);
    const targetText = result.resultset.result.text;
    return targetText;
  }

  async #getAccessToken() {
    let accessToken = this.#loadAccessToken();
    if (accessToken !== null) return accessToken;
    const token = await this.#postData(this.#tokenEndpoint, {
      grant_type: 'client_credentials',
      client_id: this.#apiKey,
      client_secret: this.#apiSecret,
    });
    accessToken = token.access_token;
    const expiresIn = token.expires_in;
    this.#saveToken(accessToken, expiresIn);
    return accessToken;
  }

  #loadAccessToken() {
    if (!fs.existsSync(this.#tokenFilePath)) return null;
    const now = Date.now() / 1000;
    const tokenJson = fs.readFileSync(this.#tokenFilePath, 'utf8');
    const token = JSON.parse(tokenJson);
    const accessToken = token.access_token;
    const expiresAt = token.expires_at;
    return (expiresAt > now) ? accessToken : null;
  }

  #saveToken(accessToken, expiresIn) {
    const now = Date.now() / 1000;
    const tokenJson = JSON.stringify({
      access_token: accessToken,
      expires_at: 0.9 * expiresIn + now,
    });
    fs.writeFileSync(this.#tokenFilePath, tokenJson);
  }

  async #postData(url, data) {
    const requestBody = JSON.stringify(data);
    const response = await fetch(url, {
      method: 'POST',
      headers: {'Content-Type': 'application/json'},
      body: requestBody,
    });
    if (!response.ok) throw new Error(`HTTP error ${response.status}`);
    return response.json();
  }
}

(async () => {
  try {
    let sourceText = '';
    process.stdin.setEncoding('utf8');
    for await (const chunk of process.stdin) { sourceText += chunk; }
    const translator = new Translator(...);
    const targetText = await translator.translate(sourceText, ...);
    process.stdout.write(`${targetText}\n`);
  } catch (error) {
    process.stderr.write(`${error}\n`);
    process.exitCode = 1;
  }
})();

<?php

class Translator {
  private $user_name;
  private $api_key;
  private $api_secret;
  private $token_file_path;
  private $token_endpoint;
  private $mt_endpoint;

  public function __construct(
    $user_name,
    $api_key,
    $api_secret,
    $server_name,
    $token_file_path,
  ) {
    $this->user_name = $user_name;
    $this->api_key = $api_key;
    $this->api_secret = $api_secret;
    $this->token_file_path = $token_file_path;
    $this->token_endpoint = "https://$server_name/oauth2/token.php";
    $this->mt_endpoint = "https://$server_name/api/mt";
  }

  public function translate(
    $source_text,
    $engine_id,
    $split,
    $xml
  ) {
    $access_token = $this->get_access_token();
    $result = $this->post_data("{$this->mt_endpoint}/{$engine_id}/", [
      'name' => $this->user_name,
      'key' => $this->api_key,
      'access_token' => $access_token,
      'type' => 'json',
      'text' => $source_text,
      'split' => $split,
      'xml' => $xml,
    ]);
    $result_code = $result->resultset->code;
    if ($result_code !== 0)
      throw new RuntimeException("Translation error $result_code");
    $target_text = $result->resultset->result->text;
    return $target_text;
  }

  private function get_access_token() {
    $access_token = $this->load_access_token();
    if (!is_null($access_token)) return $access_token;
    $token = $this->post_data($this->token_endpoint, [
      'grant_type' => 'client_credentials',
      'client_id' => $this->api_key,
      'client_secret' => $this->api_secret,
    ]);
    $access_token = $token->access_token;
    $expires_in = $token->expires_in;
    $this->save_token($access_token, $expires_in);
    return $access_token;
  }

  private function load_access_token() {
    if (!is_file($this->token_file_path)) return null;
    $token_json = file_get_contents($this->token_file_path);
    $token = json_decode($token_json);
    $access_token = $token->access_token;
    $expires_at = $token->expires_at;
    return ($expires_at > time()) ? $access_token : null;
  }

  private function save_token($access_token, $expires_in) {
    $token_json = json_encode([
      'access_token' => $access_token,
      'expires_at' => 0.9 * $expires_in + time(),
    ]);
    file_put_contents($this->token_file_path, $token_json);
  }

  private function post_data($url, $data) {
    $ch = curl_init($url);
    curl_setopt($ch, CURLOPT_POSTFIELDS, $data);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    $response_body = curl_exec($ch);
    $status_code = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);
    if ($status_code >= 400)
      throw new RuntimeException("HTTP error $status_code");
    return json_decode($response_body);
  }
}

try {
  $source_text = file_get_contents('php://stdin');
  $translator = new Translator(...);
  $target_text = $translator->translate($source_text, ...);
  file_put_contents('php://stdout', "$target_text\n");
} catch (Throwable $error) {
  file_put_contents('php://stderr', "$error\n");
  exit(1);
}