public async Task <QuestionResult> Pass(ChatRoom chat, UserWordModel word,
UserWordModel[] examList)
{
var translations = string.Join(", ", word.TextTranslations.Shuffle().Take(3));
var variants = examList
.Where(e => e.AllTranslationsAsSingleString != word.AllTranslationsAsSingleString)
.Select(e => string.Join(", ", e.TextTranslations.Shuffle().Take(3)))
.Shuffle()
.Take(5)
.Append(translations)
.ToList();
var msg = QuestionMarkups.TranslateTemplate(word.Word, chat.Texts.ChooseTheTranslation);
await chat.SendMarkdownMessageAsync(msg, InlineButtons.CreateVariants(variants));
var choice = await chat.TryWaitInlineIntKeyboardInput();
if (choice == null)
{
return(QuestionResult.RetryThisQuestion);
}
var answer = variants[choice.Value].Split(",")
.Select(e => e.Trim()).ToList();
return(!answer.Except(word.TextTranslations).Any()
? QuestionResult.Passed(chat.Texts)
: QuestionResult.Failed(chat.Texts));
}
public async Task <QuestionResult> Pass(ChatRoom chat, UserWordModel word,
UserWordModel[] examList)
{
var originTranslation = word.RuTranslations.ToList().GetRandomItemOrNull();
var variants = examList.SelectMany(e => e.TextTranslations)
.Where(e => !word.TextTranslations.Contains(e))
.Distinct()
.Shuffle()
.Take(5)
.Append(originTranslation.Word)
.Shuffle()
.ToList();
var msg = QuestionMarkups.TranslateTemplate(word.Word, chat.Texts.ChooseTheTranslation);
await chat.SendMarkdownMessageAsync(msg, InlineButtons.CreateVariants(variants));
var choice = await chat.TryWaitInlineIntKeyboardInput();
if (choice == null)
{
return(QuestionResult.RetryThisQuestion);
}
var selected = variants[choice.Value];
return(word.TextTranslations.Any(t => t.AreEqualIgnoreCase(selected))
? QuestionResult.Passed(chat.Texts)
: QuestionResult.Failed(chat.Texts));
}
public async Task <ExamResult> Pass(ChatIO chatIo, UsersWordsService service, UserWordModel word,
UserWordModel[] examList)
{
var variants = examList.Randomize().SelectMany(e => e.GetTranslations()).ToArray();
var msg = $"=====> {word.Word} <=====\r\n" +
$"Choose the translation";
await chatIo.SendMessageAsync(msg, InlineButtons.CreateVariants(variants));
var choice = await chatIo.TryWaitInlineIntKeyboardInput();
if (choice == null)
{
return(ExamResult.Retry);
}
if (word.GetTranslations().Contains(variants[choice.Value]))
{
await service.RegisterSuccess(word);
return(ExamResult.Passed);
}
await service.RegisterFailure(word);
return(ExamResult.Failed);
}
public async Task <QuestionResult> Pass(ChatRoom chat, UserWordModel word, UserWordModel[] examList)
{
var originTranslation = word.RuTranslations.GetRandomItemOrNull();
if (string.IsNullOrWhiteSpace(originTranslation.Transcription) || originTranslation.Transcription != "")
{
return(QuestionResult.Impossible);
}
var variants = examList.Where(e => e.RuTranslations.All(t => t.Transcription != originTranslation.Transcription))
.SelectMany(e => e.TextTranslations)
.Take(5)
.Append(originTranslation.Word)
.Shuffle()
.ToList();
var msg = QuestionMarkups.TranscriptionTemplate(originTranslation.Transcription, chat.Texts.ChooseWhichWordHasThisTranscription);
await chat.SendMarkdownMessageAsync(msg, InlineButtons.CreateVariants(variants));
var choice = await chat.TryWaitInlineIntKeyboardInput();
if (choice == null)
{
return(QuestionResult.RetryThisQuestion);
}
if (word.TextTranslations.Contains(variants[choice.Value]))
{
return(QuestionResult.Passed(chat.Texts));
}
return(QuestionResult.Failed(chat.Texts));
}
public async Task <QuestionResult> Pass(ChatRoom chat, UserWordModel word,
UserWordModel[] examList)
{
if (!word.Examples.Any())
{
return(QuestionResult.Impossible);
}
var phrase = word.GetRandomExample();
var replaced = phrase.OriginPhrase.Replace(phrase.OriginWord, "\\.\\.\\.");
if (replaced == phrase.OriginPhrase)
{
return(QuestionResult.Impossible);
}
var variants = examList
.Where(p => !p.Examples.Select(e => e.TranslatedPhrase)
.Any(t => t.AreEqualIgnoreCase(phrase.TranslatedPhrase)))
.Select(e => e.Word)
.Shuffle()
.Take(5)
.Append(phrase.OriginWord)
.Shuffle()
.ToArray();
var _ = await chat.SendMarkdownMessageAsync(
QuestionMarkups.TranslatesAsTemplate(
phrase.TranslatedPhrase,
chat.Texts.translatesAs,
replaced,
chat.Texts.ChooseMissingWord + ":")
, InlineButtons.CreateVariants(variants));
var choice = await chat.TryWaitInlineIntKeyboardInput();
if (choice == null)
{
return(QuestionResult.RetryThisQuestion);
}
if (variants[choice.Value].AreEqualIgnoreCase(word.Word))
{
return(QuestionResult.Passed(chat.Texts.Passed1Markdown,
chat.Texts));
}
return(QuestionResult.Failed($"{chat.Texts.OriginWas}:\r\n*\"{phrase.OriginPhrase}\"*",
chat.Texts));
}
public Task Execute(string argument, ChatRoom chat) =>
chat.SendMarkdownMessageAsync(
StatsRenderer.GetStatsText(_settings, chat).EscapeForMarkdown(),
new[] {
new[] {
InlineButtons.MainMenu($"{Emojis.MainMenu} {chat.Texts.MainMenuButton}"),
InlineButtons.Exam($"{chat.Texts.LearnButton} {Emojis.Learning}"),
},
new[] { InlineButtons.Translation($"{chat.Texts.TranslateButton} {Emojis.Translate}") },
new[] {
InlineButtons.WellLearnedWords(
$"{chat.Texts.ShowWellKnownWords} ({chat.User.CountOf((int)WordLeaningGlobalSettings.LearnedWordMinScore, 10)}) {Emojis.SoftMark}")
}
});
public async Task <ExamResult> Pass(
ChatIO chatIo,
UsersWordsService service,
UserWordModel word,
UserWordModel[] examList)
{
if (!word.HasAnyPhrases)
{
return(ExamResult.Impossible);
}
var targetPhrase = word.GetRandomExample();
var otherExamples = examList
.SelectMany(e => e.Phrases)
.Where(p => p != targetPhrase)
.Take(8).ToArray();
if (!otherExamples.Any())
{
return(ExamResult.Impossible);
}
var variants = otherExamples
.Append(targetPhrase)
.Randomize()
.Select(e => e.TranslatedPhrase)
.ToArray();
var msg = $"=====> {targetPhrase.OriginPhrase} <=====\r\n" +
$"Choose the translation";
await chatIo.SendMessageAsync(msg, InlineButtons.CreateVariants(variants));
var choice = await chatIo.TryWaitInlineIntKeyboardInput();
if (choice == null)
{
return(ExamResult.Retry);
}
if (variants[choice.Value] == targetPhrase.TranslatedPhrase)
{
await service.RegisterSuccess(word);
return(ExamResult.Passed);
}
await service.RegisterFailure(word);
return(ExamResult.Failed);
}
private IEnumerable <InlineKeyboardButton[]> CreateButtons()
{
var buttons = _translations.Select((t, i) => new[] { AddWordHelper.CreateButtonFor(t, _areSelected[i]) });
if (_isLastMessageInTheChat)
{
buttons = buttons
.Append(new[]
{
InlineButtons.MainMenu($"{Emojis.MainMenu} {Chat.Texts.MainMenuButton}"),
InlineButtons.Translation($"{Chat.Texts.ContinueTranslateButton} {Emojis.Translate}")
});
}
return(buttons);
}
public async Task <ExamResult> Pass(ChatIO chatIo, UsersWordsService service, UserWordModel word, UserWordModel[] examList)
{
if (!word.Phrases.Any())
{
return(ExamResult.Impossible);
}
var phrase = word.GetRandomExample();
var replaced = phrase.OriginPhrase.Replace(phrase.OriginWord, "...");
if (replaced == phrase.OriginPhrase)
{
return(ExamResult.Impossible);
}
var sb = new StringBuilder();
sb.AppendLine($"\"{phrase.TranslatedPhrase}\"");
sb.AppendLine();
sb.AppendLine($" translated as ");
sb.AppendLine();
sb.AppendLine($"\"{replaced}\"");
sb.AppendLine($"Choose missing word...");
var variants = examList.Randomize().Select(e => e.Word).ToArray();
var _ = chatIo.SendMessageAsync(sb.ToString(), InlineButtons.CreateVariants(variants));
var choice = await chatIo.TryWaitInlineIntKeyboardInput();
if (choice == null)
{
return(ExamResult.Retry);
}
if (variants[choice.Value] == word.Word)
{
await service.RegisterSuccess(word);
return(ExamResult.Passed);
}
await chatIo.SendMessageAsync($"Origin was: \"{phrase.OriginPhrase}\"");
await service.RegisterFailure(word);
return(ExamResult.Failed);
}
private InlineKeyboardButton[][] GetWordKeyboard() =>
new[] {
new[] {
new InlineKeyboardButton {
CallbackData = selectLearningSetData,
Text = $"{Emojis.HeavyPlus} {Chat.Texts.SelectWordInLearningSet}"
}
},
new[] {
new InlineKeyboardButton {
CallbackData = moveNextData,
Text = $"{Emojis.SoftNext} {Chat.Texts.Skip}"
},
},
new[] {
InlineButtons.MainMenu($"{Emojis.MainMenu} {Chat.Texts.MainMenuButton}"),
}
};
public async Task <QuestionResult> Pass(ChatRoom chat,
UserWordModel word,
UserWordModel[] examList)
{
if (!word.HasAnyExamples)
{
return(QuestionResult.Impossible);
}
var targetPhrase = word.GetRandomExample();
var otherExamples = examList
.SelectMany(e => e.Examples)
.Where(p => !p.TranslatedPhrase.AreEqualIgnoreCase(targetPhrase.TranslatedPhrase))
.Shuffle()
.Take(5)
.ToArray();
if (!otherExamples.Any())
{
return(QuestionResult.Impossible);
}
var variants = otherExamples
.Append(targetPhrase)
.Select(e => e.TranslatedPhrase)
.Shuffle()
.ToArray();
var msg = QuestionMarkups.TranslateTemplate(targetPhrase.OriginPhrase, chat.Texts.ChooseTheTranslation);
await chat.SendMarkdownMessageAsync(msg, InlineButtons.CreateVariants(variants));
var choice = await chat.TryWaitInlineIntKeyboardInput();
if (choice == null)
{
return(QuestionResult.RetryThisQuestion);
}
return(variants[choice.Value].AreEqualIgnoreCase(targetPhrase.TranslatedPhrase)
? QuestionResult.Passed(chat.Texts)
: QuestionResult.Failed(chat.Texts));
}
public async Task <QuestionResult> Pass(ChatRoom chat, UserWordModel word,
UserWordModel[] examList)
{
var originalTranslation = word.RuTranslations.GetRandomItemOrNull();
if (originalTranslation == null || !originalTranslation.HasTranscription)
{
return(QuestionResult.Impossible);
}
var variants = examList
.SelectMany(e => e.RuTranslations)
.Select(e => e.Transcription)
.Where(e => word.RuTranslations.All(t => t.Transcription != e))
.Distinct()
.Shuffle()
.Take(5)
.Append(originalTranslation.Transcription)
.Where(w => w != null)
.Shuffle()
.ToList();
if (variants.Count <= 1)
{
return(QuestionResult.Impossible);
}
var msg = QuestionMarkups.TranslateTemplate(word.Word, chat.Texts.ChooseTheTranscription);
await chat.SendMarkdownMessageAsync(msg, InlineButtons.CreateVariants(variants));
var choice = await chat.TryWaitInlineIntKeyboardInput();
if (choice == null)
{
return(QuestionResult.RetryThisQuestion);
}
return(word.RuTranslations.Any(t => t.Transcription == variants[choice.Value])
? QuestionResult.Passed(chat.Texts)
: QuestionResult.Failed(chat.Texts));
}
public async Task <ExamResult> Pass(Chat chat, NewWordsService service, PairModel word, PairModel[] examList)
{
var variants = examList.Randomize().Select(e => e.Translation).ToArray();
var msg = $"=====> {word.OriginWord} <=====\r\nChoose the translation";
await chat.SendMessage(msg, InlineButtons.CreateVariants(variants));
var choice = await chat.TryWaitInlineIntKeyboardInput();
if (choice == null)
{
return(ExamResult.Retry);
}
if (variants[choice.Value] == word.Translation)
{
service.RegistrateSuccess(word);
return(ExamResult.Passed);
}
service.RegistrateFailure(word);
return(ExamResult.Failed);
}
public async Task Handle(Update update)
{
if (_pages.Count == 0)
{
await Chat.ConfirmCallback(update.CallbackQuery.Id);
return;
}
if (update.CallbackQuery.Data == WellKnownWordsHelper.PrevData)
{
_pages.MovePrev();
}
else
{
_pages.MoveNext();
}
var msg = new StringBuilder();
foreach (var word in _pages.Current)
{
msg.Append($"{Emojis.SoftMark} *{word.Word}:* {word.AllTranslationsAsSingleString}\r\n");
}
msg.Append(Chat.Texts.PageXofYMarkdown(_pages.Page + 1, _pages.Count));
await Chat.EditMessageTextMarkdown(
update.CallbackQuery.Message.MessageId,
msg.ToString(),
new[] {
WellKnownWordsHelper.GetPagingKeys(),
new[] {
InlineButtons.MainMenu($"{Emojis.MainMenu} {Chat.Texts.MainMenuButton}"),
}
});
await Chat.ConfirmCallback(update.CallbackQuery.Id);
}
private async Task SendExamResultToUser(
UserWordModel[] distinctLearningWords, Dictionary <string, double> originWordsScore, int questionsPassed, int questionsCount,
UserWordModel[] learningWords, double gamingScoreBefore)
{
var doneMessage = CreateLearningResultsMessage(
distinctLearningWords,
originWordsScore,
questionsPassed,
questionsCount,
learningWords,
gamingScoreBefore);
await Chat.SendMarkdownMessageAsync(
doneMessage.EscapeForMarkdown(),
new[] {
new[] { InlineButtons.Exam($"🔁 {Chat.Texts.OneMoreLearnButton}") },
new[] {
InlineButtons.Stats(Chat.Texts),
InlineButtons.Translation(Chat.Texts.TranslateButton + " " + Emojis.Translate)
}
});
}
public async Task <QuestionResult> Pass(ChatRoom chat, UserWordModel word, UserWordModel[] examList)
{
var variants = examList.Where(e => e.AllTranslationsAsSingleString != word.AllTranslationsAsSingleString)
.Select(e => e.Word)
.Take(5)
.Append(word.Word)
.Shuffle()
.ToArray();
var msg = QuestionMarkups.TranslateTemplate(word.AllTranslationsAsSingleString, chat.Texts.ChooseTheTranslation);
await chat.SendMarkdownMessageAsync(msg, InlineButtons.CreateVariants(variants));
var choice = await chat.TryWaitInlineIntKeyboardInput();
if (choice == null)
{
return(QuestionResult.RetryThisQuestion);
}
return(variants[choice.Value].AreEqualIgnoreCase(word.Word)
? QuestionResult.Passed(chat.Texts)
: QuestionResult.Failed(chat.Texts));
}
public async Task <ExamResult> Pass(Chat chat, NewWordsService service, PairModel word, PairModel[] examList)
{
if (!word.Phrases.Any())
{
return(ExamResult.Impossible);
}
var targetPhrase = word.Phrases.GetRandomItem();
var other = examList.SelectMany(e => e.Phrases)
.Where(p => !string.IsNullOrWhiteSpace(p?.Origin) && p != targetPhrase)
.Take(8);
if (!other.Any())
{
return(ExamResult.Impossible);
}
var variants = other
.Append(targetPhrase)
.Randomize()
.Select(e => e.Translation)
.ToArray();
var msg = $"=====> {targetPhrase.Origin} <=====\r\nChoose the translation";
await chat.SendMessage(msg, InlineButtons.CreateVariants(variants));
var choice = await chat.TryWaitInlineIntKeyboardInput();
if (choice == null)
{
return(ExamResult.Retry);
}
if (variants[choice.Value] == targetPhrase.Translation)
{
service.RegistrateSuccess(word);
return(ExamResult.Passed);
}
service.RegistrateFailure(word);
return(ExamResult.Failed);
/*
* Console.WriteLine("=====> " + targetPhrase.Origin + " <=====");
*
* for (int i = 1; i <= variants.Length; i++)
* {
* Console.WriteLine($"{i}: " + variants[i - 1]);
* }
*
* Console.Write("Choose the translation: ");
*
* var selected = Console.ReadLine();
* if (selected.ToLower().StartsWith("e"))
* return ExamResult.Exit;
*
* if (!int.TryParse(selected, out var selectedIndex) || selectedIndex > variants.Length ||
* selectedIndex < 1)
* return ExamResult.Retry;
*
* if (variants[selectedIndex - 1] == targetPhrase.Translation)
* {
* service.RegistrateSuccess(word);
* return ExamResult.Passed;
* }
* service.RegistrateFailure(word);
* return ExamResult.Failed;*/
}
public async Task EnterAsync()
{
var wellKnownWords = (await _usersWordsService.GetAllWords(Chat.User))
.Where(u => u._absoluteScore >= 4)
.ToArray();
var paginationForWords = new List <List <UserWordModel> >();
var i = 0;
while (i < wellKnownWords.Length)
{
paginationForWords.Add(wellKnownWords.Skip(i).Take(10).ToList());
i += 10;
}
var msg = new StringBuilder();
msg.Append("*");
if (!wellKnownWords.Any())
{
msg.Append(Chat.Texts.NoWellKnownWords);
}
else if (wellKnownWords.Length == 1)
{
msg.Append(Chat.Texts.JustOneLearnedWord);
}
else if (wellKnownWords.Length <= 4)
{
msg.Append(Chat.Texts.LearnSomeWordsMarkdown(wellKnownWords.Length));
}
else
{
msg.Append(Chat.Texts.LearnMoreWordsMarkdown(wellKnownWords.Length));
}
msg.Append("*\r\n\r\n");
if (wellKnownWords.Length == 0)
{
return;
}
var msgWithWords = new StringBuilder();
foreach (var word in paginationForWords[0])
{
msgWithWords.Append(
$"{Emojis.SoftMark} *{word.Word}:* {word.AllTranslationsAsSingleString}\r\n");
}
if (paginationForWords.Count > 1)
{
msgWithWords.Append(Chat.Texts.PageXofYMarkdown(1, paginationForWords.Count));
}
InlineKeyboardButton[][] buttons = null;
if (paginationForWords.Count > 1)
{
_wellKnownWordsUpdateHook.SetWellKnownWords(paginationForWords);
_wellKnownWordsUpdateHook.SetNumberOfPaginate(0);
_wellKnownWordsUpdateHook.SetBeginningMessage(msg.ToString());
buttons = new[] {
WellKnownWordsHelper.GetPagingKeys(),
new[] {
InlineButtons.MainMenu($"{Emojis.MainMenu} {Chat.Texts.MainMenuButton}")
}
};
}
else
{
buttons = new[] {
new[] { InlineButtons.MainMenu($"{Chat.Texts.TranslateButton} {Emojis.Translate}") }
}
};
await Chat.ChatIo.SendMarkdownMessageAsync(msgWithWords.ToString(), buttons);
}
}
private async Task <bool> EnterSingleWordAsync(User user, string?word = null)
{
if (word == null)
{
await _chatIo.SendMessageAsync("Enter english word", new InlineKeyboardButton
{
CallbackData = "/start",
Text = "Cancel"
});
while (true)
{
var input = await _chatIo.WaitUserInputAsync();
if (input.CallbackQuery != null && input.CallbackQuery.Data == "/start")
{
throw new ProcessInterruptedWithMenuCommand("/start");
}
if (!string.IsNullOrEmpty(input.Message?.Text))
{
word = input.Message.Text;
break;
}
}
}
//find word in local dictionary(if not, find it in Ya dictionary)
var translations = await _addWordService.FindInDictionaryWithoutExamples(word);
if (!translations.Any())
{
translations = await _addWordService.TranslateAndAddToDictionary(word);
}
if (translations?.Any() != true)
{
await _chatIo.SendMessageAsync("No translations found. Check the word and try again");
return(true);
}
await _chatIo.SendMessageAsync($"Choose translation for '{word}'",
InlineButtons.CreateVariantsWithCancel(translations.Select(t => t.RuWord)));
await _addWordService.RegistrateTranslationRequest(user);
while (true)
{
var input = await _chatIo.TryWaitInlineIntKeyboardInput();
if (!input.HasValue)
{
return(false);
}
if (input !.Value < 0 || input.Value >= translations.Count)
{
continue;
}
var selected = translations[input.Value];
await _addWordService.AddWordsToUser(user, new[] { selected });
if (selected.Examples.Count > 0)
{
await _chatIo.SendMessageAsync($"Saved. Examples: {selected.Examples.Count}");
}
else
{
await _chatIo.SendMessageAsync($"Saved.");
}
return(true);
}
}
async Task <bool> EnterSingleWord(string?word = null)
{
if (word == null)
{
await _chat.SendMessage("Enter english word", new InlineKeyboardButton
{
CallbackData = "/exit",
Text = "Cancel"
});
while (true)
{
var input = await _chat.WaitUserInput();
if (input.CallbackQuery != null && input.CallbackQuery.Data == "/exit")
{
throw new ProcessInteruptedWithMenuCommand("/start");
}
if (!string.IsNullOrEmpty(input.Message.Text))
{
word = input.Message.Text;
break;
}
}
}
YaDefenition[]? definitions = null;
if (_yapiDicClient.IsOnline)
{
definitions = await _yapiDicClient.Translate(word);
}
var translations = new List <TranslationAndContext>();
if (definitions?.Any() == true)
{
var variants = definitions.SelectMany(r => r.Tr);
foreach (var yandexTranslation in variants)
{
var phrases = yandexTranslation.GetPhrases(word);
translations.Add(new TranslationAndContext(word, yandexTranslation.Text,
yandexTranslation.Pos, phrases.ToArray()));
}
}
else
{
var dictionaryMatch = _wordService.GetTranslations(word);
if (dictionaryMatch != null)
{
translations.AddRange(
dictionaryMatch.Translations.Select(t =>
new TranslationAndContext(dictionaryMatch.Origin, t, dictionaryMatch.Transcription,
new Phrase[0])));
}
}
if (!translations.Any())
{
try
{
var translateResponse = await _yapiTransClient.Translate(word);
if (string.IsNullOrWhiteSpace(translateResponse))
{
await _chat.SendMessage("No translations found. Check the word and try again");
}
else
{
translations.Add(new TranslationAndContext(word, translateResponse, null,
new Phrase[0]));
}
}
catch (Exception)
{
await _chat.SendMessage("No translations found. Check the word and try again");
}
}
if (!translations.Any())
{
return(true);
}
await _chat.SendMessage($"Choose translation for '{word}'",
InlineButtons.CreateVariants(translations.Select(t => t.Translation)));
while (true)
{
var input = await _chat.TryWaitInlineIntKeyboardInput();
if (!input.HasValue)
{
return(false);
}
if (input.Value >= 0 && input.Value < translations.Count)
{
var selected = translations[input.Value];
//var allTranslations = results.Select(t => t.Translation).ToArray();
var allPhrases = selected.Phrases; // results.SelectMany(t => t.Phrases).ToArray();
_wordService.SaveForExams(
word: word,
transcription: translations[0].Transcription,
translations: new[] { selected.Translation },
allMeanings: translations.Select(t => t.Translation.Trim().ToLower()).ToArray(),
phrases: allPhrases);
await _chat.SendMessage($"Saved. Translations: {1}, Phrases: {allPhrases.Length}");
return(true);
}
}
}
