MicrosoftWebService.php

<?php
declare( strict_types = 1 );
 
namespace MediaWiki\Extension\Translate\WebService;
 
use MediaWiki\Http\HttpRequestFactory;
 
class MicrosoftWebService extends TranslationWebService {
    private $httpRequestFactory;
 
    public function __construct(
        HttpRequestFactory $httpRequestFactory,
        string $serviceName,
        array $config
    ) {
        parent::__construct( $serviceName, $config );
        $this->httpRequestFactory = $httpRequestFactory;
    }
 
    public function getType(): string {
        return 'mt';
    }
 
    protected function mapCode( string $code ): string {
        $map = [
            'tl' => 'fil',
            'zh-hant' => 'zh-Hant',
            'zh-hans' => 'zh-Hans',
            'sr-ec' => 'sr-Cyrl',
            'sr-el' => 'sr-Latn',
            'pt-br' => 'pt',
        ];
 
        return $map[$code] ?? $code;
    }
 
    protected function doPairs(): array {
        if ( !isset( $this->config['key'] ) ) {
            throw new TranslationWebServiceConfigurationException( 'key is not set' );
        }
 
        $key = $this->config['key'];
 
        $options = [];
        $options['method'] = 'GET';
        $options['timeout'] = $this->config['timeout'];
 
        $url = $this->config['url'] . '/languages?api-version=3.0';
 
        $req = $this->httpRequestFactory->create( $url, $options, __METHOD__ );
        $req->setHeader( 'Ocp-Apim-Subscription-Key', $key );
 
        $status = $req->execute();
        if ( !$status->isOK() ) {
            $error = $req->getContent();
            // Most likely a timeout or other general error
            throw new TranslationWebServiceException(
                'Http::get failed:' . serialize( $error ) . serialize( $status )
            );
        }
 
        $json = $req->getContent();
        $response = json_decode( $json, true );
        if ( !isset( $response[ 'translation' ] ) ) {
            throw new TranslationWebServiceException(
                'Unable to fetch list of available languages: ' . $json
            );
        }
 
        $languages = array_keys( $response[ 'translation' ] );
 
        // Let's make a cartesian product, assuming we can translate from any language to any language
        $pairs = [];
        foreach ( $languages as $from ) {
            foreach ( $languages as $to ) {
                $pairs[$from][$to] = true;
            }
        }
 
        return $pairs;
    }
 
    protected function getQuery( string $text, string $sourceLanguage, string $targetLanguage ): TranslationQuery {
        if ( !isset( $this->config['key'] ) ) {
            throw new TranslationWebServiceConfigurationException( 'key is not set' );
        }
 
        $key = $this->config['key'];
        $text = trim( $text );
        $text = $this->wrapUntranslatable( $text );
 
        $url = $this->config['url'] . '/translate';
        $params = [
            'api-version' => '3.0',
            'from' => $sourceLanguage,
            'to' => $targetLanguage,
            'textType' => 'html',
        ];
        $headers = [
            'Ocp-Apim-Subscription-Key' => $key,
            'Content-Type' => 'application/json',
        ];
        $body = json_encode( [ [ 'Text' => $text ] ] );
 
        if ( $body === false ) {
            throw new TranslationWebServiceInvalidInputException( 'Could not JSON encode source text' );
        }
 
        if ( strlen( $body ) > 5000 ) {
            throw new TranslationWebServiceInvalidInputException( 'Source text too long' );
        }
 
        return TranslationQuery::factory( $url )
            ->timeout( intval( $this->config['timeout'] ) )
            ->queryParameters( $params )
            ->queryHeaders( $headers )
            ->postWithData( $body );
    }
 
    protected function parseResponse( TranslationQueryResponse $reply ): string {
        $body = $reply->getBody();
 
        $response = json_decode( $body, true );
        if ( !isset( $response[ 0 ][ 'translations' ][ 0 ][ 'text' ] ) ) {
            throw new TranslationWebServiceException(
                'Unable to parse translation response: ' . $body
            );
        }
 
        $text = $response[ 0 ][ 'translations' ][ 0 ][ 'text' ];
        $text = $this->unwrapUntranslatable( $text );
 
        return $text;
    }
 
    protected function wrapUntranslatable( string $text ): string {
        $pattern = '~%[^% ]+%|\$\d|{VAR:[^}]+}|{?{(PLURAL|GRAMMAR|GENDER):[^|]+\||%(\d\$)?[sd]~';
        $wrap = '<span class="notranslate">\0</span>';
        return preg_replace( $pattern, $wrap, $text );
    }
 
    protected function unwrapUntranslatable( string $text ): string {
        $pattern = '~<span class="notranslate">\s*(.*?)\s*</span>~';
        return preg_replace( $pattern, '\1', $text );
    }
}