/// <summary>
/// Processes an incoming activity.
/// </summary>
/// <param name="turnContext">Context object containing information for a single turn of conversation with a user.</param>
/// <param name="next">The delegate to call to continue the bot middleware pipeline.</param>
/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
public async Task OnTurnAsync(ITurnContext turnContext, NextDelegate next, CancellationToken cancellationToken = default(CancellationToken))
{
if (turnContext == null)
{
throw new ArgumentNullException(nameof(turnContext));
}
var shouldTranslate = await ShouldTranslateAsync(turnContext, cancellationToken);
if (shouldTranslate)
{
if (turnContext.Activity.Type == ActivityTypes.Message)
{
string previousLanguage = await _previousLanguage.GetAsync(turnContext, () => TranslationSettings.DefaultLanguage, cancellationToken) ?? TranslationSettings.DefaultLanguage;
string currentLanguage = await _translator.DetectLanguageAsync(turnContext.Activity.Text);
await _previousLanguage.SetAsync(turnContext, currentLanguage, cancellationToken);
await _userState.SaveChangesAsync(turnContext, false, cancellationToken);
string translatedText = await _translator.TranslateAsync(turnContext.Activity.Text, previousLanguage, cancellationToken : cancellationToken);
string inTranslation = await _translator.TranslateAsync("in", previousLanguage, "en-us", cancellationToken : cancellationToken);
string meansTranslation = await _translator.TranslateAsync("means", previousLanguage, "en-us", cancellationToken : cancellationToken);
turnContext.Activity.Text = $"'{turnContext.Activity.Text}' {meansTranslation.ToLower()} '{translatedText}' {inTranslation.ToLower()} '{currentLanguage}'";
}
}
await next(cancellationToken).ConfigureAwait(false);
}
/// <summary>
/// Processes an incoming activity.
/// </summary>
/// <param name="turnContext">Context object containing information for a single turn of conversation with a user.</param>
/// <param name="next">The delegate to call to continue the bot middleware pipeline.</param>
/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
public async Task OnTurnAsync(ITurnContext turnContext, NextDelegate next, CancellationToken cancellationToken = default(CancellationToken))
{
if (turnContext == null)
{
throw new ArgumentNullException(nameof(turnContext));
}
var translate = await ShouldTranslateAsync(turnContext, cancellationToken);
if (translate)
{
if (turnContext.Activity.Type == ActivityTypes.Message)
{
turnContext.Activity.Text = await _translator.TranslateAsync(turnContext.Activity.Text, TranslationSettings.DefaultLanguage, cancellationToken);
}
}
turnContext.OnSendActivities(async(newContext, activities, nextSend) =>
{
string userLanguage = await _languageStateProperty.GetAsync(turnContext, () => TranslationSettings.DefaultLanguage) ?? TranslationSettings.DefaultLanguage;
bool shouldTranslate = userLanguage != TranslationSettings.DefaultLanguage;
// Translate messages sent to the user to user language
if (shouldTranslate)
{
List <Task> tasks = new List <Task>();
foreach (Activity currentActivity in activities.Where(a => a.Type == ActivityTypes.Message))
{
tasks.Add(TranslateMessageActivityAsync(currentActivity.AsMessageActivity(), userLanguage));
}
if (tasks.Any())
{
await Task.WhenAll(tasks).ConfigureAwait(false);
}
}
return(await nextSend());
});
turnContext.OnUpdateActivity(async(newContext, activity, nextUpdate) =>
{
string userLanguage = await _languageStateProperty.GetAsync(turnContext, () => TranslationSettings.DefaultLanguage) ?? TranslationSettings.DefaultLanguage;
bool shouldTranslate = userLanguage != TranslationSettings.DefaultLanguage;
// Translate messages sent to the user to user language
if (activity.Type == ActivityTypes.Message)
{
if (shouldTranslate)
{
await TranslateMessageActivityAsync(activity.AsMessageActivity(), userLanguage);
}
}
return(await nextUpdate());
});
await next(cancellationToken).ConfigureAwait(false);
}
public async Task <string> TranslateTextAsync(string text, string targetLocale, CancellationToken cancellationToken = default(CancellationToken)) => await _translator.TranslateAsync(text, targetLocale, cancellationToken);
/// <summary>
/// Processes an incoming activity.
/// </summary>
/// <param name="turnContext">Context object containing information for a single turn of conversation with a user.</param>
/// <param name="next">The delegate to call to continue the bot middleware pipeline.</param>
/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
public async Task OnTurnAsync(ITurnContext turnContext, NextDelegate next, CancellationToken cancellationToken = default(CancellationToken))
{
// Grab the conversation data
var conversationStateAccessors = _conversationState.CreateProperty <ConversationData>(nameof(ConversationData));
var conversationData = await conversationStateAccessors.GetAsync(turnContext, () => new ConversationData());
string utterance = null;
string detectedLanguage = null;
if (turnContext == null)
{
throw new ArgumentNullException(nameof(turnContext));
}
if (turnContext.Activity.Type == ActivityTypes.Message)
{
utterance = ConvertToUtterance(turnContext);
if (!String.IsNullOrEmpty(utterance))
{
// Detect language
if (_configuration["SkipLanguageDetectionAfterInitialChoice"].ToLower() == "false")
{
detectedLanguage = await _translator.DetectTextRequestAsync(utterance, Consts.SupportedLanguages);
if (detectedLanguage != null)
{
if (detectedLanguage != conversationData.LanguagePreference)
{
conversationData.LanguageChangeDetected = true;
conversationData.LanguagePreference = detectedLanguage;
}
}
}
conversationData.UserQuestion = turnContext.Activity.Text;
var translate = ShouldTranslateAsync(turnContext, conversationData.LanguagePreference, cancellationToken);
if (translate)
{
if (turnContext.Activity.Type == ActivityTypes.Message)
{
var specifiedTranslation = Util.GetTranslation(turnContext.Activity.Text, conversationData.LanguagePreference);
if (!String.IsNullOrEmpty(specifiedTranslation))
{
turnContext.Activity.Text = specifiedTranslation;
}
else
{
turnContext.Activity.Text = await _translator.TranslateAsync(turnContext.Activity.Text, _configuration["TranslateTo"], cancellationToken);
}
conversationData.TranslatedQuestion = turnContext.Activity.Text;
}
}
}
turnContext.OnSendActivities(async(newContext, activities, nextSend) =>
{
// Grab the conversation data
var conversationStateAccessors = _conversationState.CreateProperty <ConversationData>(nameof(ConversationData));
var conversationData = await conversationStateAccessors.GetAsync(turnContext, () => new ConversationData());
string userLanguage = conversationData.LanguagePreference;
bool shouldTranslate = (userLanguage != _configuration["TranslateTo"]);
// Translate messages sent to the user to user language
if (shouldTranslate)
{
List <Task> tasks = new List <Task>();
foreach (Activity currentActivity in activities.Where(a => a.Type == ActivityTypes.Message))
{
var storedAnswer = currentActivity.Text;
conversationData.TranslatedAnswer = storedAnswer;
if (!Util.ShouldSkipTranslation(storedAnswer, userLanguage)) // Do not translated the stored non-English answer.
{
// Always return traditional Chinese to be consistent.
var langTranslateTo = (userLanguage == "zh-Hans") ? "zh-Hant" : userLanguage;
tasks.Add(TranslateMessageActivityAsync(conversationData, currentActivity.AsMessageActivity(), langTranslateTo, true));
}
}
if (tasks.Any())
{
await Task.WhenAll(tasks).ConfigureAwait(false);
}
// Log the questions (There are trace activities that pass through and we do not want to log.)
if ((conversationData.TranslatedAnswer != null) && !Util.IsDefaultFeedbackMessage(conversationData.TranslatedAnswer, userLanguage))
{
if (!String.IsNullOrEmpty(conversationData.UserQuestion))
{
await Util.Log(conversationData.UserQuestion, conversationData.UserAnswer, conversationData.TranslatedQuestion, conversationData.TranslatedAnswer, userLanguage);
}
}
}
return(await nextSend());
});
turnContext.OnUpdateActivity(async(newContext, activity, nextUpdate) =>
{
// Grab the conversation data
var conversationStateAccessors = _conversationState.CreateProperty <ConversationData>(nameof(ConversationData));
var conversationData = await conversationStateAccessors.GetAsync(turnContext, () => new ConversationData());
string userLanguage = conversationData.LanguagePreference;
bool shouldTranslate = userLanguage != _configuration["TranslateTo"];
// Translate messages sent to the user to user language
if (activity.Type == ActivityTypes.Message)
{
if (shouldTranslate)
{
await TranslateMessageActivityAsync(conversationData, activity.AsMessageActivity(), userLanguage, false);
}
}
return(await nextUpdate());
});
}
await next(cancellationToken).ConfigureAwait(false);
}
/// <summary>
/// Processes an incoming activity.
/// </summary>
/// <param name="turnContext">Context object containing information for a single turn of conversation with a user.</param>
/// <param name="next">The delegate to call to continue the bot middleware pipeline.</param>
/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
public async Task OnTurnAsync(ITurnContext turnContext, NextDelegate next, CancellationToken cancellationToken = default(CancellationToken))
{
// Grab the conversation data
var conversationStateAccessors = _conversationState.CreateProperty <ConversationData>(nameof(ConversationData));
var conversationData = await conversationStateAccessors.GetAsync(turnContext, () => new ConversationData());
string utterance = null;
string detectedLanguage = null;
if (turnContext == null)
{
throw new ArgumentNullException(nameof(turnContext));
}
if (turnContext.Activity.Type == ActivityTypes.Message)
{
utterance = ConvertToUtterance(turnContext);
if (IsLanguageChangeRequested(utterance))
{
conversationData.LanguageChangeRequested = true;
conversationData.LanguagePreference = utterance;
}
else
{
// Detect language unless its been optimized out after initial language choice
if (_configuration["SkipLanguageDetectionAfterInitialChoice"].ToLower() == "false" ||
conversationData.LanguagePreference.ToLower() == _configuration["TranslateTo"].ToLower())
{
detectedLanguage = await GetDetectedLanguageAsync(utterance, conversationData.LanguagePreference);
if (detectedLanguage != null)
{
if (detectedLanguage != conversationData.LanguagePreference)
{
conversationData.LanguageChangeDetected = true;
conversationData.LanguagePreference = detectedLanguage;
}
}
}
}
var translate = ShouldTranslateAsync(turnContext, conversationData.LanguagePreference, cancellationToken);
if (!conversationData.LanguageChangeRequested && translate)
{
if (turnContext.Activity.Type == ActivityTypes.Message)
{
turnContext.Activity.Text = await _translator.TranslateAsync(turnContext.Activity.Text, _configuration["TranslateTo"], cancellationToken);
}
}
turnContext.OnSendActivities(async(newContext, activities, nextSend) =>
{
// Grab the conversation data
var conversationStateAccessors = _conversationState.CreateProperty <ConversationData>(nameof(ConversationData));
var conversationData = await conversationStateAccessors.GetAsync(turnContext, () => new ConversationData());
string userLanguage = conversationData.LanguagePreference;
bool shouldTranslate = userLanguage != _configuration["TranslateTo"];
// Translate messages sent to the user to user language
if (shouldTranslate)
{
List <Task> tasks = new List <Task>();
foreach (Activity currentActivity in activities.Where(a => a.Type == ActivityTypes.Message))
{
tasks.Add(TranslateMessageActivityAsync(currentActivity.AsMessageActivity(), userLanguage));
}
if (tasks.Any())
{
await Task.WhenAll(tasks).ConfigureAwait(false);
}
}
return(await nextSend());
});
turnContext.OnUpdateActivity(async(newContext, activity, nextUpdate) =>
{
// Grab the conversation data
var conversationStateAccessors = _conversationState.CreateProperty <ConversationData>(nameof(ConversationData));
var conversationData = await conversationStateAccessors.GetAsync(turnContext, () => new ConversationData());
string userLanguage = conversationData.LanguagePreference;
bool shouldTranslate = userLanguage != _configuration["TranslateTo"];
// Translate messages sent to the user to user language
if (activity.Type == ActivityTypes.Message)
{
if (shouldTranslate)
{
await TranslateMessageActivityAsync(activity.AsMessageActivity(), userLanguage);
}
}
return(await nextUpdate());
});
}
await next(cancellationToken).ConfigureAwait(false);
}
