private async Task AfterLessonFinished(IDialogContext context, IAwaitable <string> result)
{
// TODO: inject dependency
var badgeRepository = new Gamification.BadgeRepository();
var updatedProfile = GetUserGamerProfile(context);
var user = context.GetUserData();
updatedProfile.Points += _pointsPerLesson;
var newBadges = badgeRepository.GetEligibleBadges(updatedProfile, _userPointsBeforeLessonPlan);
updatedProfile.Badges.AddRange(newBadges);
if (newBadges != null && newBadges.Any())
{
var tasks = newBadges.Select(async badge =>
{
AdaptiveCard adaptiveCard = new AdaptiveCard()
{
Body = new List <CardElement>()
{
new Image()
{
Size = ImageSize.Medium,
Url = "https://www.kastatic.org/images/badges/meteorite/thumbs-up-512x512.png"
},
new TextBlock()
{
Text = await MessageTranslator.TranslateTextAsync($"You unlocked {badge}", user?.NativeLanguageIsoCode),
Size = TextSize.Large,
Wrap = true
}
}
};
Attachment attachment = new Attachment()
{
ContentType = AdaptiveCard.ContentType,
Content = adaptiveCard
};
var reply = context.MakeMessage();
reply.Attachments.Add(attachment);
await context.PostAsync(reply, CancellationToken.None);
});
await Task.WhenAll(tasks);
}
// The current lesson finished. Plug in Analytics.
var finalMessage = await result;
await context.PostAsync(finalMessage);
// Refactor
var updatedUserData = context.GetUserData();
updatedUserData.GamerProfile = updatedProfile;
context.UpdateUserData(updatedUserData);
context.Done(string.Empty);
}
private async Task AskToStartLessonPlan(IDialogContext context)
{
var possibleResponses = new List <string>()
{
BotPersonality.GetStartLessonPlanQuestion(),
BotPersonality.BotResponseToGibberish
};
IReadOnlyCollection <string> translatedResponses;
string language;
if (context.UserData.TryGetValue(Constants.Shared.UserLanguageCodeKey, out language) && language != MessageTranslator.DEFAULT_LANGUAGE)
{
translatedResponses = await MessageTranslator.TranslateTextAsync(possibleResponses, language);
}
else
{
translatedResponses = possibleResponses;
}
PromptDialog.Confirm(
context,
TryStartLessonPlan,
translatedResponses.ElementAtOrDefault(0) ?? string.Empty,
translatedResponses.ElementAtOrDefault(1) ?? string.Empty);
}
public async Task StartAsync(IDialogContext context)
{
var _oldGamerProfile = GetUserGamerProfile(context);
_userPointsBeforeLessonPlan = _oldGamerProfile.Points;
var user = context.GetUserData();
string friendlyUserName = user?.UserName;
ICollection <string> lessonTitle = new List <string>();
// get up to 5 lessons
int i = 0;
foreach (Lesson lesson in LessonPlanModule.LessonPlan.Lessons)
{
if (i >= 7)
{
break;
}
//var lessonInNativaLanguage = await MessageTranslator.TranslateTextAsync(lesson.LessonTitle, user?.NativeLanguageIsoCode);
lessonTitle.Add(lesson.LessonTitle);
i++;
}
var questionInNativeLanguage = await MessageTranslator.TranslateTextAsync($"Which lesson would you like to start?", user?.NativeLanguageIsoCode);
PromptDialog.Choice(
context,
this.AfterLessonSelected,
lessonTitle,
$"{questionInNativeLanguage}",
Shared.DoNotUnderstand,
attempts: Shared.MaxPromptAttempts);
}
public static async Task PostTranslatedAsync(this IDialogContext context, string message, bool sendTyping = true, int delay = 0)
{
if (sendTyping)
{
if (delay == 0)
{
//generate random delay from 1 second to 4 seconds...
delay = rnd.Next(1, 4) * 1000;
}
await PostTypingAsync(context, delay);
}
string language;
if (context.UserData.TryGetValue(Constants.Shared.UserLanguageCodeKey, out language) && language != MessageTranslator.DEFAULT_LANGUAGE)
{
var translatedMessage = await MessageTranslator.TranslateTextAsync(message, language);
await context.PostAsync(translatedMessage);
return;
}
else
{
await context.PostAsync(message);
return;
}
}
private async Task UserNameReceivedInNativeLanguageAsync(IDialogContext context, IAwaitable <IMessageActivity> result)
{
IMessageActivity userText = await result;
string userTextInEnglish = await MessageTranslator.TranslateTextAsync(userText.Text);
userText.Text = userTextInEnglish;
await context.Forward(_chitChatDialog, this.AfterChitChatComplete, userText, CancellationToken.None);
}
private async Task AfterChoosingLanguageSwitch(IDialogContext context, IAwaitable <object> result)
{
var response = await result as string;
if (response == null)
{
await this.StartAsync(context);
return;
}
try
{
UserData userData = _userDataRepository.GetUserData(context.Activity.From.Id);
var translatedResponse = await MessageTranslator.TranslateTextAsync(response);
if (translatedResponse.Equals(Shared.Yes, StringComparison.InvariantCultureIgnoreCase))
{
string translatedSelfIntroduction =
await MessageTranslator.TranslateTextAsync(BotPersonality.BotSelfIntroduction,
userData.NativeLanguageIsoCode);
var introductionResponseTask = context.PostTranslatedAsync($"{translatedSelfIntroduction}");
var translatedUserNameQuestionTask =
MessageTranslator.TranslateTextAsync(BotPersonality.UserNameQuestion,
userData.NativeLanguageIsoCode);
await Task.WhenAll(introductionResponseTask, translatedUserNameQuestionTask);
await context.PostTranslatedAsync(translatedUserNameQuestionTask.Result);
context.Wait(this.UserNameReceivedInNativeLanguageAsync);
}
else
{
context.UserData.SetValue(Constants.Shared.UserLanguageCodeKey, MessageTranslator.DEFAULT_LANGUAGE);
await context.PostTranslatedAsync($"{BotPersonality.UserNameQuestion}");
context.Wait(this.UserNameReceivedAsync);
}
}
catch (TooManyAttemptsException)
{
UserData userData = _userDataRepository.GetUserData(context.Activity.From.Id);
string translatedTooManyAttemptMessage = await MessageTranslator.TranslateTextAsync(Shared.TooManyAttemptMessage, userData.NativeLanguageIsoCode);
await Task.WhenAll(context.PostTranslatedAsync($"{translatedTooManyAttemptMessage}"),
this.StartAsync(context));
}
}
private async Task AfterChoosingLanguageSwitch(IDialogContext context, IAwaitable <object> result)
{
var response = await result as string;
if (response == null)
{
await this.StartAsync(context);
return;
}
try
{
var detectedLanguage = context.UserData.GetValue <string>(Constants.Shared.UserLanguageCodeKey);
UserData userData = context.GetUserData();
var translatedResponse = await MessageTranslator.TranslateTextAsync(response);
if (translatedResponse.Equals(Shared.Yes, StringComparison.InvariantCultureIgnoreCase))
{
userData.NativeLanguageIsoCode = detectedLanguage;
var englishName = CultureInfo.GetCultureInfo(userData.NativeLanguageIsoCode).EnglishName;
string translatedSelfIntroduction =
await MessageTranslator.TranslateTextAsync(string.Format(BotPersonality.BotLanguageIntroduction, englishName), userData.NativeLanguageIsoCode);
var introductionResponseTask = context.PostTranslatedAsync($"{translatedSelfIntroduction}");
var translatedUserNameQuestionTask =
MessageTranslator.TranslateTextAsync(BotPersonality.UserNameQuestion,
userData.NativeLanguageIsoCode);
await Task.WhenAll(introductionResponseTask, translatedUserNameQuestionTask);
await context.PostTranslatedAsync(translatedUserNameQuestionTask.Result);
context.UpdateUserData(userData);
await EngageWithUser(context);
}
}
catch (TooManyAttemptsException)
{
UserData userData = context.GetUserData();
string translatedTooManyAttemptMessage = await MessageTranslator.TranslateTextAsync(Shared.TooManyAttemptMessage, userData.NativeLanguageIsoCode);
await Task.WhenAll(context.PostTranslatedAsync($"{translatedTooManyAttemptMessage}"),
this.StartAsync(context));
}
}
private async Task AfterChoosingLanguageSwitch(IDialogContext context, IAwaitable <object> result)
{
var response = await result as string;
try
{
UserData userData = _userDataRepository.GetUserData(context.Activity.From.Id);
string translatedYes = await MessageTranslator.TranslateTextAsync(Shared.Yes.ToString(), userData.NativeLanguageIsoCode);
string translatedNo = await MessageTranslator.TranslateTextAsync(Shared.No, userData.NativeLanguageIsoCode);
if (translatedYes.Equals(response, StringComparison.OrdinalIgnoreCase))
{
string translatedSelfIntroduction =
await MessageTranslator.TranslateTextAsync(BotPersonality.BotSelfIntroduction,
userData.NativeLanguageIsoCode);
await context.PostAsync($"{translatedSelfIntroduction}");
string translatedUserNameQuestion =
await MessageTranslator.TranslateTextAsync(BotPersonality.UserNameQuestion,
userData.NativeLanguageIsoCode);
await context.PostAsync($"{translatedUserNameQuestion}");
context.Wait(this.UserNameReceivedInNativeLanguageAsync);
}
else if (translatedNo.Equals(response, StringComparison.OrdinalIgnoreCase))
{
await context.PostAsync($"{BotPersonality.UserNameQuestion}");
context.Wait(this.UserNameReceivedAsync);
}
}
catch (TooManyAttemptsException)
{
UserData userData = _userDataRepository.GetUserData(context.Activity.From.Id);
string translatedTooManyAttemptMessage = await MessageTranslator.TranslateTextAsync(Shared.TooManyAttemptMessage, userData.NativeLanguageIsoCode);
await context.PostAsync($"{translatedTooManyAttemptMessage}");
await this.StartAsync(context);
}
}
public static async Task PostTranslatedAsync(this IDialogContext context, string message)
{
string language;
if (context.UserData.TryGetValue(Constants.Shared.UserLanguageCodeKey, out language) && language != MessageTranslator.DEFAULT_LANGUAGE)
{
var translatedMessage = await MessageTranslator.TranslateTextAsync(message, language);
await context.PostAsync(translatedMessage);
return;
}
else
{
await context.PostAsync(message);
return;
}
}
private async Task SwitchLanguage(IDialogContext context, UserData userData, string locale)
{
var detectedLanguage = context.UserData.GetValue <string>(Constants.Shared.UserLanguageCodeKey);
CultureInfo[] allCultures = CultureInfo.GetCultures(CultureTypes.AllCultures);
CultureInfo detectedCulture =
allCultures
.FirstOrDefault(cultureInfo => (detectedLanguage.Contains(cultureInfo.TwoLetterISOLanguageName)));
string detectedLanguageName = CultureInfo.GetCultureInfo(MessageTranslator.DEFAULT_LANGUAGE).DisplayName;
if (detectedCulture != null)
{
detectedLanguageName = detectedCulture.DisplayName;
}
var translationInputTextlist = new List <string>(capacity: 4);
translationInputTextlist.AddRange(YesNoChoices);
translationInputTextlist.AddRange(new string[] { $"Do you want to switch to {detectedLanguageName}", Shared.DoNotUnderstand });
var translatedList = await MessageTranslator.TranslateTextAsync(translationInputTextlist, locale);
var translatedSwitchQuestion = translatedList.ElementAt(2);
var translatedDontUnderstand = translatedList.ElementAt(3);
var translatedChoices = translatedList.Take(2);
PromptDialog.Choice(
context,
this.AfterChoosingLanguageSwitch,
translatedChoices,
translatedSwitchQuestion,
translatedDontUnderstand,
attempts: Shared.MaxPromptAttempts
);
}
private async Task MessageReceivedAsync(IDialogContext context, IAwaitable <IMessageActivity> result)
{
var userText = context.Activity.From.Name;
try
{
userText = (await result).Text;
}
catch (Exception)
{
// Swallow exception for the demo purpose
// TODO log the exception
}
string detectedLanguageIsoCode = await MessageTranslator.IdentifyLangAsync(userText);
var userData = _userDataRepository.GetUserData(context.Activity.From.Id);
if (userData == null)
{
userData = new UserData();
userData.UserId = context.Activity.From.Id;
userData.NativeLanguageIsoCode = detectedLanguageIsoCode;
}
_userDataRepository.UpdateUserData(userData);
if (MessageTranslator.DEFAULT_LANGUAGE.Equals(detectedLanguageIsoCode))
{
await context.PostAsync(BotPersonality.UserNameQuestion);
// detected it's english language
context.Wait(this.UserNameReceivedAsync);
}
else
{
// detected user language
CultureInfo[] allCultures = CultureInfo.GetCultures(CultureTypes.AllCultures);
CultureInfo detectedCulture =
allCultures
.Where(cultureInfo => (detectedLanguageIsoCode.Contains(cultureInfo.TwoLetterISOLanguageName)))
.FirstOrDefault();
string detectedLanguageName = CultureInfo.GetCultureInfo(MessageTranslator.DEFAULT_LANGUAGE).DisplayName;
if (detectedCulture != null)
{
detectedLanguageName = detectedCulture.DisplayName;
}
string translatedSwitchQuestion = await MessageTranslator.TranslateTextAsync($"Do you want to switch to {detectedLanguageName}", detectedLanguageIsoCode);
string translatedDontUnderstand = await MessageTranslator.TranslateTextAsync(Shared.DoNotUnderstand, detectedLanguageIsoCode);
PromptDialog.Choice(
context,
this.AfterChoosingLanguageSwitch,
await MessageTranslator.TranslatedChoices(YesNoChoices, detectedLanguageIsoCode),
translatedSwitchQuestion,
translatedDontUnderstand,
attempts: Shared.MaxAttempt
);
}
}
