[NEW] Integrate DEEPL translation service to RC core

app/autotranslate/client/lib/autotranslate.js

@@ -64,6 +64,10 @@ export const AutoTranslate = {
 			this.supportedLanguages = languages || [];
 		});
 
+		Meteor.call('autoTranslate.getProviderUiMetadata', (err, metadata) => {
+			this.providersMetadata = metadata;
+		});
+
 		Tracker.autorun(() => {
 			Subscriptions.find().observeChanges({
 				changed: (id, fields) => {

app/autotranslate/client/stylesheets/autotranslate.css

@@ -58,6 +58,10 @@
 			left: 5px;
 
 			border-left: 0;
+
+			& .translation-provider {
+				display: none;
+			}
 		}
 	}
 }

app/autotranslate/server/autotranslate.js

@@ -1,29 +1,88 @@
 import { Meteor } from 'meteor/meteor';
-import { HTTP } from 'meteor/http';
 import _ from 'underscore';
 import s from 'underscore.string';
 
 import { settings } from '../../settings';
 import { callbacks } from '../../callbacks';
 import { Subscriptions, Messages } from '../../models';
 import { Markdown } from '../../markdown/server';
+import { Logger } from '../../logger';
+
+/**
+ * This class allows translation providers to
+ * register,load and also returns the active provider.
+ */
+export class TranslationProviderRegistry {
+	/**
+	 * Registers the translation provider into the registry.
+	 * @param {*} provider
+	 */
+	static registerProvider(provider) {
+		// get provider information
+		const metadata = provider._getProviderMetadata();
+		if (!TranslationProviderRegistry._providers) {
+			TranslationProviderRegistry._providers = {};
+		}
+		TranslationProviderRegistry._providers[metadata.name] = provider;
+	}
 
-class AutoTranslate {
+	/**
+	 * Return the active Translation provider
+	 */
+	static getActiveProvider() {
+		return TranslationProviderRegistry._providers[TranslationProviderRegistry._activeProvider];
+	}
+
+	/**
+	 * Make the activated provider by setting as the active.
+	 */
+	static loadActiveServiceProvider() {
+		settings.get('AutoTranslate_ServiceProvider', (key, value) => {
+			TranslationProviderRegistry._activeProvider = value;
+		});
+	}
+}
+
+/**
+ * Generic auto translate base implementation.
+ * This class provides generic parts of implementation for
+ * tokenization, detokenization, call back register and unregister.
+ * @abstract
+ * @class
+ */
+export class AutoTranslate {
+	/**
+	 * Encapsulate the api key and provider settings.
+	 * @constructor
+	 */
 	constructor() {
+		this.name = '';
 		this.languages = [];
-		this.enabled = settings.get('AutoTranslate_Enabled');
-		this.apiKey = settings.get('AutoTranslate_GoogleAPIKey');
 		this.supportedLanguages = {};
-		callbacks.add('afterSaveMessage', this.translateMessage.bind(this), callbacks.priority.MEDIUM, 'AutoTranslate');
 
+		// Get Auto Translate Active flag
 		settings.get('AutoTranslate_Enabled', (key, value) => {
-			this.enabled = value;
+			this.autoTranslateEnabled = value;
 		});
-		settings.get('AutoTranslate_GoogleAPIKey', (key, value) => {
-			this.apiKey = value;
+
+		/** Register the active service provider on the 'AfterSaveMessage' callback.
+		 *  So the registered provider will be invoked when a message is saved.
+		 *  All the other inactive service provider must be deactivated.
+		 */
+		settings.get('AutoTranslate_ServiceProvider', (key, value) => {
+			if (this.name === value) {
+				this.registerAfterSaveMsgCallBack(this.name);
+			} else {
+				this.unRegisterAfterSaveMsgCallBack(this.name);
+			}
 		});
 	}
 
+	/**
+	 * Extracts non-translatable parts of a message
+	 * @param {object} message
+	 * @return {object} message
+	 */
 	tokenize(message) {
 		if (!message.tokens || !Array.isArray(message.tokens)) {
 			message.tokens = [];
@@ -93,10 +152,12 @@ class AutoTranslate {
 
 	tokenizeCode(message) {
 		let count = message.tokens.length;
-
 		message.html = message.msg;
 		message = Markdown.parseMessageNotEscaped(message);
-		message.msg = message.html;
+
+		// Some parsers (e. g. Marked) wrap the complete message in a <p> - this is unnecessary and should be ignored with respect to translations
+		const regexWrappedParagraph = new RegExp('^\s*<p>|<\/p>\s*$', 'gm');
+		message.msg = message.msg.replace(regexWrappedParagraph, '');
 
 		for (const tokenIndex in message.tokens) {
 			if (message.tokens.hasOwnProperty(tokenIndex)) {
@@ -153,8 +214,17 @@ class AutoTranslate {
 		return message.msg;
 	}
 
+	/**
+	 * Triggers the translation of the prepared (tokenized) message
+	 * and persists the result
+	 * @public
+	 * @param {object} message
+	 * @param {object} room
+	 * @param {object} targetLanguage
+	 * @returns {object} unmodified message object.
+	 */
 	translateMessage(message, room, targetLanguage) {
-		if (this.enabled && this.apiKey) {
+		if (this.autoTranslateEnabled && this.apiKey) {
 			let targetLanguages;
 			if (targetLanguage) {
 				targetLanguages = [targetLanguage];
@@ -163,35 +233,13 @@ class AutoTranslate {
 			}
 			if (message.msg) {
 				Meteor.defer(() => {
-					const translations = {};
 					let targetMessage = Object.assign({}, message);
-
 					targetMessage.html = s.escapeHTML(String(targetMessage.msg));
 					targetMessage = this.tokenize(targetMessage);
 
-					let msgs = targetMessage.msg.split('\n');
-					msgs = msgs.map((msg) => encodeURIComponent(msg));
-					const query = `q=${ msgs.join('&q=') }`;
-
-					const supportedLanguages = this.getSupportedLanguages('en');
-					targetLanguages.forEach((language) => {
-						if (language.indexOf('-') !== -1 && !_.findWhere(supportedLanguages, { language })) {
-							language = language.substr(0, 2);
-						}
-						let result;
-						try {
-							result = HTTP.get('https://translation.googleapis.com/language/translate/v2', { params: { key: this.apiKey, target: language }, query });
-						} catch (e) {
-							console.log('Error translating message', e);
-							return message;
-						}
-						if (result.statusCode === 200 && result.data && result.data.data && result.data.data.translations && Array.isArray(result.data.data.translations) && result.data.data.translations.length > 0) {
-							const txt = result.data.data.translations.map((translation) => translation.translatedText).join('\n');
-							translations[language] = this.deTokenize(Object.assign({}, targetMessage, { msg: txt }));
-						}
-					});
+					const translations = this._translateMessage(targetMessage, targetLanguages);
 					if (!_.isEmpty(translations)) {
-						Messages.addTranslations(message._id, translations);
+						Messages.addTranslations(message._id, translations, TranslationProviderRegistry._activeProvider);
 					}
 				});
 			}
@@ -201,20 +249,8 @@ class AutoTranslate {
 					for (const index in message.attachments) {
 						if (message.attachments.hasOwnProperty(index)) {
 							const attachment = message.attachments[index];
-							const translations = {};
 							if (attachment.description || attachment.text) {
-								const query = `q=${ encodeURIComponent(attachment.description || attachment.text) }`;
-								const supportedLanguages = this.getSupportedLanguages('en');
-								targetLanguages.forEach((language) => {
-									if (language.indexOf('-') !== -1 && !_.findWhere(supportedLanguages, { language })) {
-										language = language.substr(0, 2);
-									}
-									const result = HTTP.get('https://translation.googleapis.com/language/translate/v2', { params: { key: this.apiKey, target: language }, query });
-									if (result.statusCode === 200 && result.data && result.data.data && result.data.data.translations && Array.isArray(result.data.data.translations) && result.data.data.translations.length > 0) {
-										const txt = result.data.data.translations.map((translation) => translation.translatedText).join('\n');
-										translations[language] = txt;
-									}
-								});
+								const translations = this._translateAttachmentDescriptions(attachment, targetLanguages);
 								if (!_.isEmpty(translations)) {
 									Messages.addAttachmentTranslations(message._id, index, translations);
 								}
@@ -227,37 +263,76 @@ class AutoTranslate {
 		return message;
 	}
 
-	getSupportedLanguages(target) {
-		if (this.enabled && this.apiKey) {
-			if (this.supportedLanguages[target]) {
-				return this.supportedLanguages[target];
-			}
+	/**
+	 * On changing the service provider, the callback in which the translation
+	 * is being requested needs to be switched to the new provider
+	 * @protected
+	 * @param {string} provider
+	 */
+	registerAfterSaveMsgCallBack(provider) {
+		callbacks.add('afterSaveMessage', this.translateMessage.bind(this), callbacks.priority.MEDIUM, provider);
+	}
 
-			let result;
-			const params = { key: this.apiKey };
-			if (target) {
-				params.target = target;
-			}
+	/**
+	 * On changing the service provider, the callback in which the translation
+	 * is being requested needs to be deactivated for the all other translation providers
+	 * @protected
+	 * @param {string} provider
+	 */
+	unRegisterAfterSaveMsgCallBack(provider) {
+		callbacks.remove('afterSaveMessage', provider);
+	}
 
-			if (this.supportedLanguages[target]) {
-				return this.supportedLanguages[target];
-			}
+	/**
+	 * Returns metadata information about the service provider which is used by
+	 * the generic implementation
+	 * @abstract
+	 * @protected
+	 * @returns { name, displayName, settings }
+		};
+	 */
+	_getProviderMetadata() {
+		Logger.warn('must be implemented by subclass!', '_getProviderMetadata');
+	}
 
-			try {
-				result = HTTP.get('https://translation.googleapis.com/language/translate/v2/languages', { params });
-			} catch (e) {
-				if (e.response && e.response.statusCode === 400 && e.response.data && e.response.data.error && e.response.data.error.status === 'INVALID_ARGUMENT') {
-					params.target = 'en';
-					target = 'en';
-					if (!this.supportedLanguages[target]) {
-						result = HTTP.get('https://translation.googleapis.com/language/translate/v2/languages', { params });
-					}
-				}
-			}
-			this.supportedLanguages[target || 'en'] = result && result.data && result.data.data && result.data.data.languages;
-			return this.supportedLanguages[target || 'en'];
-		}
+
+	/**
+	 * Provides the possible languages _from_ which a message can be translated into a target language
+	 * @abstract
+	 * @protected
+	 * @param {string} target - the language into which shall be translated
+	 * @returns [{ language, name }]
+	 */
+	getSupportedLanguages(target) {
+		Logger.warn('must be implemented by subclass!', 'getSupportedLanguages', target);
+	}
+
+	/**
+	 * Performs the actual translation of a message,
+	 * usually by sending a REST API call to the service provider.
+	 * @abstract
+	 * @protected
+	 * @param {object} message
+	 * @param {object} targetLanguages
+	 * @return {object}
+	 */
+	_translateMessage(message, targetLanguages) {
+		Logger.warn('must be implemented by subclass!', '_translateMessage', message, targetLanguages);
+	}
+
+	/**
+	 * Performs the actual translation of an attachment (precisely its description),
+	 * usually by sending a REST API call to the service provider.
+	 * @abstract
+	 * @param {object} attachment
+	 * @param {object} targetLanguages
+	 * @returns {object} translated messages for each target language
+	 */
+	_translateAttachmentDescriptions(attachment, targetLanguages) {
+		Logger.warn('must be implemented by subclass!', '_translateAttachmentDescriptions', attachment, targetLanguages);
 	}
 }
 
-export default new AutoTranslate();
+Meteor.startup(() => {
+	TranslationProviderRegistry.loadActiveServiceProvider();
+});