public async Task TranslateAsync([Remainder][Summary("The sentence")] string sentence)
{
var translator = new GoogleTranslator();
Language from = Language.Auto;
Language to = Language.English;
TranslationResult result = await translator.TranslateAsync(sentence, from, to).ConfigureAwait(false);
double confidence = Math.Round(double.Parse(result.LanguageDetections[0].Confidence.ToString()) * 100, 2);
EmbedBuilder eb = new EmbedBuilder
{
Title = "Translation",
Description = $"Sentence: {result.OriginalText}\nLanguage detected: {result.LanguageDetections[0].Language.FullName} ({confidence}% confident)",
Color = Color.Green
};
eb.AddField("In English", result.MergedTranslation);
if (result.OriginalTextTranscription != null)
{
eb.AddField("Transcription", result.OriginalTextTranscription);
}
if (result.Synonyms != null)
{
eb.AddField("Synonyms", result.Synonyms.ToString());
}
eb.WithFooter(footer =>
{
footer.Text = "Google Translate";
});
await RankaReplyAsync(eb).ConfigureAwait(false);
}
public async Task <IActionResult> Post(ApiVersion apiVersion, [FromBody] dynamic body)
{
var text = body.text.Value as string;
Language english = Language.English; // or even this way
Language vietnamese = Language.Vietnamese; // or even this way
TranslationResult result = await Translator.TranslateAsync(text, english, vietnamese);
var response = new
{
ok = true,
result = new
{
result.OriginalText,
result.OriginalTextTranscription,
result.FragmentedTranslation,
result.MergedTranslation,
result.ExtraTranslations,
result.Synonyms,
result.Examples,
result.SeeAlso,
}
};
return(new OkObjectResult(response));
}
public async Task <string> TranslateTextAsync(string input)
{
var translator = new GoogleTranslator();
int selection = comboBox1.SelectedIndex;
GoogleTranslateFreeApi.Language from;
if (selection == 0)
{
from = GoogleTranslateFreeApi.Language.Auto;
}
else
{
from = GoogleTranslator.GetLanguageByName(languages[comboBox1.SelectedIndex].name);
}
GoogleTranslateFreeApi.Language to = GoogleTranslator.GetLanguageByName(languages[comboBox2.SelectedIndex].name);
TranslationResult result = await translator.TranslateAsync(input, from, to);
//The result is separated by the suggestions and the '\n' symbols
string[] resultSeparated = result.FragmentedTranslation;
//You can get all text using MergedTranslation property
string resultMerged = result.MergedTranslation;
//There is also original text transcription
string transcription = result.TranslatedTextTranscription; // Kon'nichiwa! Ogenkidesuka?
Console.WriteLine(resultSeparated.Length);
//Console.WriteLine(result.SeeAlso.Length);
//Console.WriteLine(result.Synonyms.Conjunction.Length);
return(result.MergedTranslation);
}
private async void Translate(string currentlyTranslating, StreamWriter writer)
{
Language cn = Language.ChineseTraditional;
Language en = Language.English;
TranslationResult result = await m_translator.TranslateAsync(currentlyTranslating, cn, en);
foreach (string res in result.MergedTranslation.Split(new string[] { "|||" },
StringSplitOptions.RemoveEmptyEntries))
{
uint idAction = uint.Parse(res.Split('►')[0].Trim());
string param = res.Split(new char[] { '►' }, 2, StringSplitOptions.RemoveEmptyEntries)[1]
.Trim();
param = BackCommand(param);
GameActionEntity old = m_entities.FirstOrDefault(x => x.Identity == idAction);
GameActionEntity newAction = new GameActionEntity
{
Identity = old.Identity,
IdNext = old.IdNext,
IdNextfail = old.IdNextfail,
Type = old.Type,
Data = old.Data,
Param = param
};
m_newEntities.Add(newAction);
dgvNew.Rows.Add(newAction.Identity, newAction.IdNext, newAction.IdNextfail, newAction.Type,
newAction.Data, newAction.Param);
pbProgressAction.Value++;
dgvNew.FirstDisplayedScrollingRowIndex = dgvNew.RowCount - 1;
await writer.WriteLineAsync(
$"INSERT INTO cq_action VALUES ('{newAction.Identity}','{newAction.IdNext}','{newAction.IdNextfail}'," +
$"'{newAction.Type}','{newAction.Data}','{newAction.Param}');");
}
}
static void Main(string[] args)
{
Console.WriteLine("Please type your sentence in Italian: ");
var text = Console.ReadLine();
TranslationResult result = Translator.TranslateAsync(text, Language.Auto, Language.English).GetAwaiter().GetResult();
Console.WriteLine($"Sentence in Italian: {text}");
Console.WriteLine($"Sentence in English: {result.MergedTranslation}");
}
public async Task TranslateAsync_WithNoValidPhrase_ShouldTranslate()
{
HttpClient httpClient = new HttpClient();
var translator = new GoogleTranslator(httpClient);
var returnedString = await translator.TranslateAsync("", "pl", "en");
Console.WriteLine(returnedString);
StringAssert.Contains(returnedString, "");
}
public async Task TranslateAsync_NoHttpClient_ShouldTranslate()
{
HttpClient httpClient = null;
var translator = new GoogleTranslator(httpClient);
var returnedString = await translator.TranslateAsync("ja", "pl", "en");
Console.WriteLine(returnedString);
StringAssert.Contains(returnedString, "I");
}
public async Task TranslateAsync_WithValidData_Translates()
{
var httpClient = new HttpClient();
var translator = new GoogleTranslator(httpClient);
var returnedString = await translator.TranslateAsync("ja", "pl", "en");
Console.WriteLine(returnedString);
StringAssert.Contains(returnedString, "I");
}
public async Task <string> Translate(string textToTranslate)
{
GoogleTranslator googleTranslator = new GoogleTranslator();
TranslationResult result = await googleTranslator.TranslateAsync(textToTranslate, Language.Auto, Language.English);
string translatedText = result.MergedTranslation;
SaveTranslation(textToTranslate, translatedText);
return(translatedText);
}
public static async Task <TranslationResult> TranslateAsync(
this string forTranslate,
string toLang
)
{
var translator = new GoogleTranslator();
var from = Language.Auto;
var to = GoogleTranslator.GetLanguageByISO(toLang);
var result = await translator.TranslateAsync(forTranslate, from, to);
return(result);
}
private async Task Translate()
{
if (_vm == null)
{
return;
}
if (string.IsNullOrWhiteSpace(_vm.Text))
{
return;
}
try
{
_cts?.Cancel();
_cts = new CancellationTokenSource();
ITranslator translator = new GoogleTranslator();
var sequence = new TranslationSequence(_vm.Text);
_vm.IsLoading = true;
SavedTranslationSequence saved = await ReadCache(sequence);
TranslationSequence result;
if (saved == null)
{
result = await translator.TranslateAsync(sequence, _vm.Language, _cts.Token);
saved = new SavedTranslationSequence
{
SourceTranslationSequence = sequence,
TranslationSequence = result,
Language = _vm.Language
};
}
else
{
result = saved.TranslationSequence;
}
_vm.Result = result.Sequence;
_vm.Suggestions = await GetSuggestions(result);
saved.LastTimeUsed = DateTime.Now;
_jsonParser.Cache.Add(saved);
}
catch (TranslationFailedException)
{
}
_vm.IsLoading = false;
}
private async Task <string> TranslateWordAsync(string str)
{
GoogleTranslator translator = new GoogleTranslator();
var result = await translator.TranslateAsync(str, Language.English, Language.Russian);
if (result.ExtraTranslations != null)
{
Console.WriteLine(result.ExtraTranslations.ToString());
richTextBox1.Text = result.ExtraTranslations.ToString();
}
return("");
}
public async Task <string> Get(string text)
{
var translator = new GoogleTranslator();
TranslationResult result = await translator.TranslateAsync(text, Language.Auto, Language.English);
string synonyms;
if (result.Synonyms != null)
{
synonyms = result.Synonyms.ToString();
}
else
{
synonyms = "There are no available synonyms";
}
return(synonyms);
}
private async Task DoActions(Model.Messages.Message action)
{
switch (action.MessageIntent)
{
case Model.Messages.IntentEnum.Weather:
var weatherAction = action as Model.Messages.MessageWeather;
var weatherString = await _weatherApi.GetForecastAsync(weatherAction.Location, weatherAction.When);
logger.Info(weatherString);
if (!string.IsNullOrEmpty(weatherString))
{
logger.Debug("");
}
// _microsoftSpeech.Speak(weatherString);
return;
case Model.Messages.IntentEnum.Time:
return;
case Model.Messages.IntentEnum.Alarm:
return;
case Model.Messages.IntentEnum.Note:
return;
case Model.Messages.IntentEnum.Translate:
var translation = await _googleTranslator.TranslateAsync("jak sie masz", "pl", "en");
logger.Debug(translation);
TextToSpeech.Speak(translation);
return;
default:
return;
}
}
static void ShowAllEnglishTranslation(string english, int indent)
{
string prefix = indent > 0 ? RepeatString(" ", indent) : "";
Console.WriteLine(prefix + english + ":");
ArrayList translations = BingDictionary.Translate(english);
if (translations != null)
{
foreach (string translation in translations)
{
Console.WriteLine(prefix + " " + translation);
}
}
else
{
var translate_result = translator.TranslateAsync(english, Language.Auto, GoogleTranslator.GetLanguageByName("Chinese Simplified"));
if (translate_result.Result.ExtraTranslations == null)
{
foreach (string translation in translate_result.Result.FragmentedTranslation)
{
Console.WriteLine(prefix + " " + translation);
}
return;
}
if (translate_result.Result.ExtraTranslations.Abbreviation != null)
{
Console.WriteLine(prefix + " Abbreviation:");
foreach (var translation in translate_result.Result.ExtraTranslations.Abbreviation)
{
Console.WriteLine(prefix + " " + translation.Phrase);
}
}
if (translate_result.Result.ExtraTranslations.Adjective != null)
{
Console.WriteLine(prefix + " Adjective:");
foreach (var translation in translate_result.Result.ExtraTranslations.Adjective)
{
Console.WriteLine(prefix + " " + translation.Phrase);
}
}
if (translate_result.Result.ExtraTranslations.Adverb != null)
{
Console.WriteLine(prefix + " Adverb:");
foreach (var translation in translate_result.Result.ExtraTranslations.Adverb)
{
Console.WriteLine(prefix + " " + translation.Phrase);
}
}
if (translate_result.Result.ExtraTranslations.AuxiliaryVerb != null)
{
Console.WriteLine(prefix + " AuxiliaryVerb:");
foreach (var translation in translate_result.Result.ExtraTranslations.AuxiliaryVerb)
{
Console.WriteLine(prefix + " " + translation.Phrase);
}
}
if (translate_result.Result.ExtraTranslations.Conjunction != null)
{
Console.WriteLine(prefix + " Conjunction:");
foreach (var translation in translate_result.Result.ExtraTranslations.Conjunction)
{
Console.WriteLine(prefix + " " + translation.Phrase);
}
}
if (translate_result.Result.ExtraTranslations.Interjection != null)
{
Console.WriteLine(prefix + " Interjection:");
foreach (var translation in translate_result.Result.ExtraTranslations.Interjection)
{
Console.WriteLine(prefix + " " + translation.Phrase);
}
}
if (translate_result.Result.ExtraTranslations.Noun != null)
{
Console.WriteLine(prefix + " Noun:");
foreach (var translation in translate_result.Result.ExtraTranslations.Noun)
{
Console.WriteLine(prefix + " " + translation.Phrase);
}
}
if (translate_result.Result.ExtraTranslations.Phrase != null)
{
Console.WriteLine(prefix + " Phrase:");
foreach (var translation in translate_result.Result.ExtraTranslations.Phrase)
{
Console.WriteLine(prefix + " " + translation.Phrase);
}
}
if (translate_result.Result.ExtraTranslations.Prefix != null)
{
Console.WriteLine(prefix + " Prefix:");
foreach (var translation in translate_result.Result.ExtraTranslations.Prefix)
{
Console.WriteLine(prefix + " " + translation.Phrase);
}
}
if (translate_result.Result.ExtraTranslations.Preposition != null)
{
Console.WriteLine(prefix + " Preposition:");
foreach (var translation in translate_result.Result.ExtraTranslations.Preposition)
{
Console.WriteLine(prefix + " " + translation.Phrase);
}
}
if (translate_result.Result.ExtraTranslations.Pronoun != null)
{
Console.WriteLine(prefix + " Pronoun:");
foreach (var translation in translate_result.Result.ExtraTranslations.Pronoun)
{
Console.WriteLine(prefix + " " + translation.Phrase);
}
}
if (translate_result.Result.ExtraTranslations.Suffix != null)
{
Console.WriteLine(prefix + " Suffix:");
foreach (var translation in translate_result.Result.ExtraTranslations.Suffix)
{
Console.WriteLine(prefix + " " + translation.Phrase);
}
}
if (translate_result.Result.ExtraTranslations.Verb != null)
{
Console.WriteLine(prefix + " Verb:");
foreach (var translation in translate_result.Result.ExtraTranslations.Verb)
{
Console.WriteLine(prefix + " " + translation.Phrase);
}
}
}
}
public TranslationResult Translate(string text, Language from, Language to)
{
return(_translator.TranslateAsync(text, from, to).GetAwaiter().GetResult());
}
public string Translate(string input)
{
var result = _translator.TranslateAsync(input, rus, eng);
return(result.Result.MergedTranslation);
}
public static void Build(Options options)
{
var parser = new FileParser();
var collection = parser.Import(options.InputProto, options.FixComments);
Console.WriteLine(collection);
//Interpret and reformat
try
{
var pp = new ProtoPrepare(options);
pp.Prepare(collection);
}
catch (ProtoFormatException pfe)
{
Console.WriteLine();
Console.WriteLine(pfe.SourcePath.Path + "(" + pfe.SourcePath.Line + "," + pfe.SourcePath.Column + "): error CS001: " + pfe.Message);
throw;
}
if (options.TranslateComments)
{
var translator = new GoogleTranslator();
if (!string.IsNullOrWhiteSpace(collection.Comments))
{
collection.Comments = translator.TranslateAsync(collection.Comments, options.FromLanguage, options.ToLanguage).GetAwaiter().GetResult().MergedTranslation;
//Console.WriteLine(collection.Comments);
}
foreach (var message in collection.Messages)
{
message.Value.Comments = translator.TranslateAsync(message.Value.Comments, options.FromLanguage, options.ToLanguage).GetAwaiter().GetResult().MergedTranslation;
Console.WriteLine(message.Value.Comments);
foreach (var valueField in message.Value.Fields)
{
valueField.Value.Comments = translator.TranslateAsync(valueField.Value.Comments, options.FromLanguage, options.ToLanguage).GetAwaiter().GetResult().MergedTranslation;
Console.WriteLine(valueField.Value.Comments);
}
}
}
//Generate code
if (options.OneClassOneFile)
{
var classes = collection.Messages;
var path = options.OutputPath;
foreach (var protoMessage in classes)
{
collection.Messages = new Dictionary <string, ProtoMessage>()
{
{ protoMessage.Key, protoMessage.Value }
};
options.OutputPath = Path.Combine(path, protoMessage.Value.CsType + ".cs");
ProtoCode.Save(collection, options);
}
}
else
{
ProtoCode.Save(collection, options);
Console.WriteLine("Saved: " + options.OutputPath);
}
}
public static async Task <string> TranslateToChinese(string text)
{
TranslationResult result = await Translator.TranslateAsync(text, Language.Auto, Language.ChineseSimplified);
return(result.MergedTranslation);
}
public static Task <TranslationResult> Translate(Language sourceLanguage, Language targetLanguage, string input)
{
var translator = new GoogleTranslator();
return(translator.TranslateAsync(input, sourceLanguage, targetLanguage));
}