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)
{
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 <QuestionResult> Pass(ChatRoom chat, UserWordModel word, UserWordModel[] examList)
{
var(phrase, translation) = word.GetExamplesThatLoadedAndFits().GetRandomItemOrNull();
if (phrase == null)
{
return(QuestionResult.Impossible);
}
var(enPhrase, ruPhrase) = phrase.Deconstruct();
var allWordsWithPhraseOfSimilarTranslate = examList
.SelectMany(e => e.Examples)
.Where(p => p.TranslatedPhrase.AreEqualIgnoreCase(ruPhrase))
.Select(e => e.OriginWord)
.ToList();
var enReplaced = enPhrase.Replace(phrase.OriginWord, "\\.\\.\\.");
if (enReplaced == enPhrase)
{
return(QuestionResult.Impossible);
}
await chat.SendMarkdownMessageAsync(
QuestionMarkups.TranslatesAsTemplate(
ruPhrase,
chat.Texts.translatesAs,
enReplaced,
chat.Texts.EnterMissingWord + ":"));
var enter = await chat.WaitNonEmptyUserTextInputAsync();
if (enter.IsRussian())
{
await chat.SendMessageAsync(chat.Texts.EnglishInputExpected);
return(QuestionResult.RetryThisQuestion);
}
var(closestWord, comparation) = allWordsWithPhraseOfSimilarTranslate.GetClosestTo(enter.Trim());
if (comparation == StringsCompareResult.Equal)
{
return(QuestionResult.Passed(chat.Texts));
}
if (enter.Contains(word.Word, StringComparison.InvariantCultureIgnoreCase) && enPhrase.Contains(enter))
{
//if user enters whole world (as it is in phrase) - it is ok
return(QuestionResult.Passed(chat.Texts));
}
if (comparation == StringsCompareResult.SmallMistakes)
{
await chat.SendMessageAsync(chat.Texts.TypoAlmostRight);
return(QuestionResult.RetryThisQuestion);
}
return(QuestionResult.Failed(
$"{chat.Texts.FailedOriginExampleWasMarkdown}\r\n*\"{phrase.OriginPhrase}\"*",
chat.Texts));
}
public async Task <QuestionResult> Pass(
ChatRoom chat, UserWordModel word,
UserWordModel[] examList)
{
var(phrase, translation) = word.GetExamplesThatLoadedAndFits().GetRandomItemOrNull();
if (phrase == null)
{
return(QuestionResult.Impossible);
}
var(enPhrase, ruPhrase) = phrase.Deconstruct();
var replacedRuPhrase = ruPhrase.Replace(phrase.TranslatedWord, "\\.\\.\\.");
if (replacedRuPhrase == ruPhrase)
{
return(QuestionResult.Impossible);
}
await chat.SendMarkdownMessageAsync(
QuestionMarkups.TranslatesAsTemplate(
enPhrase,
chat.Texts.translatesAs,
replacedRuPhrase,
chat.Texts.EnterMissingWord + ":"));
var enter = await chat.WaitNonEmptyUserTextInputAsync();
if (!enter.IsRussian())
{
await chat.SendMessageAsync(chat.Texts.RussianInputExpected);
return(QuestionResult.RetryThisQuestion);
}
var comparation = translation.Word.CheckCloseness(enter.Trim());
if (comparation == StringsCompareResult.Equal)
{
return(QuestionResult.Passed(chat.Texts));
}
//if user enters whole word in phrase- it is ok!
if (enter.Contains(translation.Word, StringComparison.InvariantCultureIgnoreCase) &&
phrase.OriginPhrase.Contains(enter, StringComparison.InvariantCultureIgnoreCase))
{
return(QuestionResult.Passed(chat.Texts));
}
if (comparation == StringsCompareResult.SmallMistakes)
{
await chat.SendMessageAsync(chat.Texts.RetryAlmostRightWithTypo);
return(QuestionResult.RetryThisQuestion);
}
return(QuestionResult.Failed($"{chat.Texts.FailedOriginExampleWas2} *\"{phrase.TranslatedPhrase}\"*",
chat.Texts));
}
public async Task <QuestionResult> Pass(ChatRoom chat, UserWordModel word, UserWordModel[] examList)
{
var msg = QuestionMarkups.TranslateTemplate(word.AllTranslationsAsSingleString, chat.Texts.DoYouKnowTranslationMarkdown);
var id = Rand.Next();
await chat.SendMarkdownMessageAsync(msg,
new InlineKeyboardButton()
{
CallbackData = id.ToString(),
Text = chat.Texts.ShowTheTranslationButton
});
while (true)
{
var update = await chat.WaitUserInputAsync();
if (update.CallbackQuery?.Data == id.ToString())
{
break;
}
var input = update.Message?.Text;
if (!string.IsNullOrWhiteSpace(input))
{
if (word.Word.AreEqualIgnoreCase(input))
{
return(QuestionResult.Passed(chat.Texts));
}
await chat.SendMessageAsync(chat.Texts.ItIsNotRightTryAgain);
}
}
await chat.SendMarkdownMessageAsync($"_{chat.Texts.TranslationIs} _\r\n" +
$"*\"{word.Word}\"*\r\n\r\n" +
$"{chat.Texts.DidYouGuess}",
new[] {
new[] {
new InlineKeyboardButton {
CallbackData = "1",
Text = chat.Texts.YesButton
},
new InlineKeyboardButton {
CallbackData = "0",
Text = chat.Texts.NoButton
}
}
}
);
var choice = await chat.WaitInlineIntKeyboardInput();
return(choice == 1
? QuestionResult.Passed(
chat.Texts.PassedOpenIHopeYouWereHonestMarkdown,
chat.Texts.PassedHideousWell2)
: QuestionResult.Failed(
chat.Texts.FailedOpenButYouWereHonestMarkdown,
chat.Texts.FailedHideousHonestyIsGoldMarkdown));
}
public async Task <QuestionResult> Pass(ChatRoom chat, UserWordModel word, UserWordModel[] examList)
{
if (!word.HasAnyExamples)
{
return(QuestionResult.Impossible);
}
var targetPhrase = word.GetRandomExample();
string shuffled;
while (true)
{
var wordsInExample = targetPhrase.SplitWordsOfPhrase;
if (wordsInExample.Length < 2)
{
return(QuestionResult.Impossible);
}
shuffled = string.Join(" ", wordsInExample.Shuffle());
if (shuffled != targetPhrase.OriginPhrase)
{
break;
}
}
await chat.SendMarkdownMessageAsync(
QuestionMarkups.FreeTemplate($"{chat.Texts.WordsInPhraseAreShuffledWriteThemInOrderMarkdown}:\r\n*\"{shuffled}\"*"));
var entry = await chat.WaitUserTextInputAsync();
if (entry.IsRussian())
{
await chat.SendMessageAsync(chat.Texts.EnglishInputExpected);
return(QuestionResult.RetryThisQuestion);
}
var closeness = targetPhrase.OriginPhrase.CheckCloseness(entry.Trim());
if (closeness == StringsCompareResult.Equal)
{
return(QuestionResult.Passed(chat.Texts));
}
if (closeness == StringsCompareResult.BigMistakes)
{
await chat.SendMessageAsync(chat.Texts.RetryAlmostRightWithTypo);
return(QuestionResult.RetryThisQuestion);
}
return(QuestionResult.Failed(
$"{chat.Texts.FailedOriginExampleWas2Markdown}:\r\n*\"{targetPhrase.OriginPhrase}\"*",
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 async Task <QuestionResult> Pass(ChatRoom chat, UserWordModel word,
UserWordModel[] examList)
{
var translation = examList.SelectMany(e => e.TextTranslations)
.Where(e => word.RuTranslations.All(t => t.Word != e))
.Shuffle()
.Take(1)
.Union(word.TextTranslations)
.ToList()
.GetRandomItemOrNull();
var msg = QuestionMarkups.TranslatesAsTemplate(
word.Word,
chat.Texts.translatesAs,
translation,
chat.Texts.IsItRightTranslation);
await chat.SendMarkdownMessageAsync(msg,
new[] {
new[] {
new InlineKeyboardButton {
CallbackData = "1",
Text = chat.Texts.YesButton
},
new InlineKeyboardButton {
CallbackData = "0",
Text = chat.Texts.NoButton
}
}
});
var choice = await chat.WaitInlineIntKeyboardInput();
if (
choice == 1 && word.TextTranslations.Contains(translation) ||
choice == 0 && !word.TextTranslations.Contains(translation)
)
{
return(QuestionResult.Passed(chat.Texts));
}
else
{
return(QuestionResult.Failed(
$"{chat.Texts.Mistaken}\\.\r\n\"{word.Word}\" {chat.Texts.translatesAs} " +
$"*\"{word.TextTranslations.FirstOrDefault()}\"* ",
chat.Texts));
}
}
public async Task <QuestionResult> Pass(ChatRoom chat, UserWordModel word, UserWordModel[] examList)
{
if (!word.Examples.Any())
{
return(QuestionResult.Impossible);
}
var targetPhrase = word.GetRandomExample();
var other = examList.SelectMany(e => e.Examples)
.Where(p => !string.IsNullOrWhiteSpace(p?.OriginPhrase) && p.TranslatedPhrase != targetPhrase.TranslatedPhrase)
.Shuffle()
.Take(5)
.ToArray();
if (!other.Any())
{
return(QuestionResult.Impossible);
}
var variants = other
.Append(targetPhrase)
.Shuffle()
.Select(e => e.OriginPhrase)
.ToArray();
var msg = QuestionMarkups.TranslateTemplate(targetPhrase.TranslatedPhrase, chat.Texts.ChooseTheTranslation);
await chat.SendMarkdownMessageAsync(msg,
variants.Select((v, i) => new InlineKeyboardButton
{
CallbackData = i.ToString(),
Text = v
}).ToArray());
var choice = await chat.TryWaitInlineIntKeyboardInput();
if (choice == null)
{
return(QuestionResult.RetryThisQuestion);
}
return(variants[choice.Value].AreEqualIgnoreCase(targetPhrase.OriginPhrase)
? QuestionResult.Passed(chat.Texts)
: QuestionResult.Failed(chat.Texts));
}
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 <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 <QuestionResult> Pass(ChatRoom chat, UserWordModel word,
UserWordModel[] examList)
{
var translations = word.TextTranslations.ToArray();
var minCount = translations.Min(t => t.Count(c => c == ' '));
if (minCount > 0 && word.AbsoluteScore < minCount * WordLeaningGlobalSettings.FamiliarWordMinScore)
{
return(QuestionResult.Impossible);
}
await chat.SendMarkdownMessageAsync(QuestionMarkups.TranslateTemplate(word.Word, chat.Texts.WriteTheTranslationMarkdown));
var entry = await chat.WaitUserTextInputAsync();
if (string.IsNullOrEmpty(entry))
{
return(QuestionResult.RetryThisQuestion);
}
if (!entry.IsRussian())
{
await chat.SendMessageAsync(chat.Texts.RussianInputExpected);
return(QuestionResult.RetryThisQuestion);
}
var(text, comparation) = translations.GetClosestTo(entry.Trim());
switch (comparation)
{
case StringsCompareResult.Equal:
return(QuestionResult.Passed(chat.Texts));
case StringsCompareResult.SmallMistakes:
await chat.SendMarkdownMessageAsync(chat.Texts.YouHaveATypoLetsTryAgainMarkdown(text));
return(QuestionResult.RetryThisQuestion);
case StringsCompareResult.BigMistakes:
return(QuestionResult.Failed(chat.Texts.FailedMistakenMarkdown(text),
chat.Texts));
}
var allMeaningsOfWord = await _localDictionaryService.GetAllTranslationWords(word.Word);
var(otherMeaning, otherComparation) = allMeaningsOfWord.GetClosestTo(entry);
if (otherComparation == StringsCompareResult.Equal)
{
await chat.SendMarkdownMessageAsync(
$"{chat.Texts.OutOfScopeTranslationMarkdown}: " +
$"*{word.AllTranslationsAsSingleString}*");
return(QuestionResult.RetryThisQuestion);
}
if (otherComparation == StringsCompareResult.SmallMistakes)
{
await chat.SendMarkdownMessageAsync(
chat.Texts.OutOfScopeWithCandidateMarkdown(otherMeaning) + ": " +
"*\"" + word.AllTranslationsAsSingleString + "\"*");
return(QuestionResult.RetryThisQuestion);
}
return(QuestionResult.Failed(
chat.Texts.FailedTranslationWasMarkdown + $"\r\n*\"{word.AllTranslationsAsSingleString}\"*",
chat.Texts));
}
public static async Task <QuestionResult> PassRuWriteQuestion(
ChatRoom chat,
UserWordModel word,
string ruTranslationCaption,
LocalDictionaryService localDictionaryService)
{
var wordsInPhraseCount = word.Word.Count(c => c == ' ');
if (wordsInPhraseCount > 0 &&
word.AbsoluteScore < wordsInPhraseCount * WordLeaningGlobalSettings.FamiliarWordMinScore)
{
return(QuestionResult.Impossible);
}
await chat.SendMarkdownMessageAsync(
QuestionMarkups.TranslateTemplate(ruTranslationCaption, chat.Texts.WriteTheTranslationMarkdown));
var enUserEntry = await chat.WaitUserTextInputAsync();
if (string.IsNullOrEmpty(enUserEntry))
{
return(QuestionResult.RetryThisQuestion);
}
if (enUserEntry.IsRussian())
{
await chat.SendMessageAsync(chat.Texts.EnglishInputExpected);
return(QuestionResult.RetryThisQuestion);
}
var comparation = word.Word.CheckCloseness(enUserEntry);
if (comparation == StringsCompareResult.Equal)
{
return(QuestionResult.Passed(chat.Texts));
}
if (comparation == StringsCompareResult.SmallMistakes)
{
await chat.SendMarkdownMessageAsync(chat.Texts.YouHaveATypoLetsTryAgainMarkdown(word.Word));
return(QuestionResult.RetryThisQuestion);
}
if (comparation == StringsCompareResult.BigMistakes)
{
return(QuestionResult.Failed(chat.Texts.FailedMistakenMarkdown(word.Word), chat.Texts.Mistaken));
}
// ## Other translation case ##
// example:
// Coefficient - коэффициент
// Rate - коэффициент
// Question is about 'коэффициент' (Coefficient)
// User answers 'Rate'
// Search for 'Rate' translations
var otherRuTranslationsOfUserInput = await localDictionaryService.GetAllTranslationWords(enUserEntry.ToLower());
// if otherRuTranslationsOfUserInput contains 'коэффициент' or something like it
// then retry question
var russianTranslations = word.TextTranslations;
if (russianTranslations.Any(
t1 =>
otherRuTranslationsOfUserInput.Any(t1.AreEqualIgnoreSmallMistakes)))
{
//translation is correct, but for other word
await chat.SendMessageAsync(
$"{chat.Texts.CorrectTranslationButQuestionWasAbout} \"{word.Word}\" - *{word.AllTranslationsAsSingleString}*'\r\n" +
chat.Texts.LetsTryAgain);
return(QuestionResult.RetryThisQuestion);
}
var translates = string.Join(",", otherRuTranslationsOfUserInput);
string failedMessage = "";
if (!string.IsNullOrWhiteSpace(translates))
{
failedMessage = $"{enUserEntry} {chat.Texts.translatesAs} {translates}\r\n";
}
failedMessage += $"{chat.Texts.RightTranslationWas}: *\"{word.Word}\"*";
return(QuestionResult.Failed(
failedMessage,
chat.Texts));
}
