private async Task <DictionaryResult> Search(string word, LanguagePair languagePair, CultureInfo culture)
{
word = word.ToLower(culture);
DictionaryEntry entry = SearchOffline(word, languagePair);
if (entry != null)
{
return(entry.Result);
}
DictionaryResult result = await SearchOnline(word, languagePair, culture).ConfigureAwait(false);
if (result?.Definitions?.Length > 0)
{
return(result);
}
string correction = await YandexService.Correct(word, languagePair.InputLanguage).ConfigureAwait(false);
if (!String.IsNullOrWhiteSpace(correction) && String.Compare(word, correction, true, culture) != 0)
{
return(await Search(correction, languagePair, culture).ConfigureAwait(false));
}
return(null);
}
public async Task <SearchResult[]> Search(string word, CultureInfo inputCulture, CultureInfo outputCulture)
{
if (word.IsNonAlpha())
{
return(null);
}
word = word.SingleWhiteSpace();
if (word.Length < 2 || word.Length > 25)
{
return(null);
}
LanguagePair languagePair = CreateLangPair(inputCulture, outputCulture);
DictionaryResult dictionaryResult = await Search(word, languagePair, inputCulture).ConfigureAwait(false);
return(dictionaryResult?.Definitions?.Select(x => new SearchResult
{
Word = x.Word,
WordClass = x.WordClass,
Inflections = x.Inflections,
Definition = x.GetTranslations()
}).ToArray());
}
private async Task <DictionaryResult> SearchOnline(string word, LanguagePair languagePair, CultureInfo culture)
{
DictionaryResult result = await YandexService.Lookup(word, languagePair).ConfigureAwait(false);
if (result?.Definitions?.Length > 0)
{
string returnedWord = result.Definitions[0].Word.ToLower(culture);
DictionaryEntry entry = SearchOffline(returnedWord, languagePair);
if (entry != null)
{
entry.Variations += word + "|";
Dictionary.Update(entry);
}
else
{
entry = new DictionaryEntry();
entry.Word = returnedWord;
entry.Result = result;
entry.Language = languagePair.ToString();
if (String.Compare(word, returnedWord, true, culture) != 0)
{
entry.Variations += word + "|";
}
Dictionary.Insert(entry);
}
}
return(result);
}
private async Task <DictionaryResult> SearchOnline(string word, LanguagePair languagePair, CultureInfo culture)
{
DictionaryResult result = await YandexService.Lookup(word, languagePair).ConfigureAwait(false);
if (result != null && result.Definitions != null && result.Definitions.Length > 0)
{
string returnedWord = result.Definitions[0].Word.ToLower(culture);
DictionaryEntity entity = SearchOffline(returnedWord, languagePair);
if (entity != null)
{
entity.Variations += word + "|";
entity.Save();
}
else
{
entity = new DictionaryEntity(UnitOfWork);
entity.Word = returnedWord;
entity.Definition = result.ToJson();
entity.Language = languagePair.ToString();
if (String.Compare(word, returnedWord, true, culture) != 0)
{
entity.Variations += word + "|";
}
entity.Save();
}
UnitOfWork.CommitChanges();
}
return(result);
}
public static DictionaryResult <TValue> TryGet <TKey, TValue>(this IDictionary <TKey, TValue> dict, TKey key)
{
if (dict.TryGetValue(key, out var val))
{
return(DictionaryResult <TValue> .Found(val));
}
return(DictionaryResult <TValue> .NotFound());
}
protected void SendDictionaryResult(Dictionary <string, string> dict)
{
var result = new DictionaryResult()
{
Id = this.Id,
Results = dict
};
Send(result);
}
private void GenerateWords(IDictionaryRequest request, PartitionInfo partitionInfo)
{
var partitionedWords = new ConcurrentQueue <IDictionary <int, IGeneratedWord> >();
var useNoise = dictionaryConfiguration.UseNoise;
var startTime = DateTime.Now;
maxValue = dictionary.WordList.Count;
FireGenerateChanged(new ProgressChangedEventArgs(10, String.Empty));
// Multi-Threaded block
var tasks = new Task[partitionInfo.NumberOfPartitions];
var index = 0;
for (; index < partitionInfo.NumberOfPartitions; index++)
{
tasks[index] = Task.Run(() =>
{
var iterations = index == partitionInfo.NumberOfPartitions - 1 ?
partitionInfo.LastPartitionSize :
partitionInfo.FullPartitionSize;
var wordsPartition = useNoise ?
GeneratePartitionedWordsWithNoise(iterations) :
GeneratePartitionedWords(iterations);
partitionedWords.Enqueue(wordsPartition);
});
}
try
{
Task.WaitAll(tasks);
var words = new WordContainer(dictionaryConfiguration.UseNoise)
{
PartitionedWords = partitionedWords
};
var endTime = DateTime.Now;
var duration = endTime - startTime;
var result = new DictionaryResult(request, duration, words)
{
Words = words
};
FireGenerateChanged(new ProgressChangedEventArgs(100, null));
FireGenerateCompleted(new DictionaryEventArgs(null, false, null, result));
}
catch (AggregateException ae)
{
FireGenerateCompleted(new DictionaryEventArgs(ae.Flatten(), false, ae, null));
}
}
/// <summary>
/// Adds the dictionary node.
/// </summary>
/// <param name="keyValuePair">The key value pair.</param>
/// <param name="nodesSource">The nodes source.</param>
/// <param name="nodesDestionation">The nodes destionation.</param>
private void AddDictionaryNode(KeyValuePair <string, DictionaryResult> keyValuePair, TreeNodeCollection nodesSource, TreeNodeCollection nodesDestionation)
{
DictionaryResult dictionaryResult = keyValuePair.Value;
TreeNode destionationNode = AddDictionaryNode(keyValuePair.Key, dictionaryResult.IsEquals, nodesDestionation);
TreeNode sourceNode = AddDictionaryNode(keyValuePair.Key, dictionaryResult.IsEquals, nodesSource);
foreach (string key in dictionaryResult.Keys)
{
DictionaryEntryResult dictionaryEntryResult = dictionaryResult[key];
AddObjectResult(dictionaryEntryResult.ResultType, dictionaryEntryResult.ObjectResult, sourceNode.Nodes, destionationNode.Nodes);
}
}
public void DictionaryNotEqualItemTest()
{
CompareObject destination = GetObject();
destination.NestedObjects["Nested2"].IntValue = 444;
ObjectResult result = (ObjectResult)conf.Compare(typeof(CompareObject), GetObject(), destination);
Assert.IsNotNull(result);
Assert.IsFalse(result.IsEquals);
Assert.IsTrue(result.Results["Name"].IsEquals);
Assert.IsTrue(result.Results["LinkedObject"].IsEquals);
Assert.IsFalse(result.Results["NestedObjects"].IsEquals);
DictionaryResult dictionaryResult = result.Results["NestedObjects"] as DictionaryResult;
Assert.AreEqual(dictionaryResult["Nested1"].ResultType, ResultType.Equal);
Assert.AreEqual(dictionaryResult["Nested2"].ResultType, ResultType.NotEqual);
}
public void EqualTest()
{
var result = (ObjectResult)conf.Compare(typeof(CompareObject), GetObject(), GetObject());
Assert.IsNotNull(result);
Assert.IsTrue(result.IsEquals);
Assert.IsTrue(result.Results["Name"].IsEquals);
Assert.IsTrue(result.Results["LinkedObject"].IsEquals);
Assert.IsTrue(result.Results["NestedObjects"].IsEquals);
DictionaryResult dictionaryResult = result.Results["NestedObjects"] as DictionaryResult;
Assert.AreEqual(dictionaryResult["Nested1"].ResultType, ResultType.Equal);
Assert.AreEqual(dictionaryResult["Nested2"].ResultType, ResultType.Equal);
KeyEnumerableResult enumerableResult = result.Results["KeyObjects"] as KeyEnumerableResult;
Assert.AreEqual(enumerableResult["1"].ResultType, ResultType.Equal);
Assert.AreEqual(enumerableResult["2"].ResultType, ResultType.Equal);
}
public void DictionaryNewItemTest()
{
CompareObject source = GetObject();
source.NestedObjects.Add("New object", new NestedObject("New object", 3));
ObjectResult result = (ObjectResult)conf.Compare(typeof(CompareObject), source, GetObject());
Assert.IsNotNull(result);
Assert.IsFalse(result.IsEquals);
Assert.IsTrue(result.Results["Name"].IsEquals);
Assert.IsTrue(result.Results["LinkedObject"].IsEquals);
Assert.IsFalse(result.Results["NestedObjects"].IsEquals);
DictionaryResult dictionaryResult = result.Results["NestedObjects"] as DictionaryResult;
Assert.AreEqual(dictionaryResult["Nested1"].ResultType, ResultType.Equal);
Assert.AreEqual(dictionaryResult["Nested2"].ResultType, ResultType.Equal);
Assert.AreEqual(dictionaryResult["New object"].ResultType, ResultType.New);
}
public void DictionaryDeleteItemTest()
{
var source = GetObject();
var destination = GetObject();
destination.NestedObjects.Add("New object", new NestedObject("New object", 3));
var result = (ObjectResult)conf.Compare(typeof(CompareObject), source, destination);
Assert.IsNotNull(result);
Assert.IsFalse(result.IsEquals);
Assert.IsTrue(result.Results["Name"].IsEquals);
Assert.IsTrue(result.Results["LinkedObject"].IsEquals);
Assert.IsFalse(result.Results["NestedObjects"].IsEquals);
DictionaryResult dictionaryResult = result.Results["NestedObjects"] as DictionaryResult;
Assert.AreEqual(dictionaryResult["Nested1"].ResultType, ResultType.Equal);
Assert.AreEqual(dictionaryResult["Nested2"].ResultType, ResultType.Equal);
Assert.AreEqual(dictionaryResult["New object"].ResultType, ResultType.Delete);
}
public static DictionaryResult <T> Found(T value)
{
var result = new DictionaryResult <T>(value);
return(result);
}
private void APICallSucceed(DictionaryResult entry)
{
Debug.Log(entry.outputs[0].output);
question.text = entry.outputs[0].output;
}
protected void SendDictionaryResult(Dictionary<string, string> dict)
{
var result = new DictionaryResult()
{
Id = this.Id,
Results = dict
};
Send(result);
}
public async Task Dictionary(string word)
{
string url = $"https://od-api.oxforddictionaries.com:443/api/v1/entries/en/{word.ToLower ()}";
string json = await FetchJson(url);
if (string.IsNullOrEmpty(json))
{
return;
}
DictionaryData data = DictionaryData.FromJson(json);
string finalMessage = string.Empty;
bool hasData = false;
DictionaryResult result = data.Results [0];
finalMessage += $"**{result.Word.ToUpper ()}**\n";
if (result.LexicalEntries [0].Pronunciations != null)
{
finalMessage += $"/{result.LexicalEntries [0].Pronunciations [0].PhoneticSpelling}/\n\n";
hasData = true;
}
foreach (DictionaryLexicalEntry lexicalEntry in result.LexicalEntries ?? Enumerable.Empty <DictionaryLexicalEntry> ())
{
finalMessage += $"**{lexicalEntry.LexicalCategory.UppercaseFirst ()}**\n";
foreach (DictionaryEntry entry in lexicalEntry.Entries ?? Enumerable.Empty <DictionaryEntry> ())
{
for (int j = 0; j < entry.Senses.Length; j++)
{
DictionarySense sense = entry.Senses [j];
foreach (string definition in sense.Definitions ?? Enumerable.Empty <string> ())
{
finalMessage += $"{j + 1}. {definition.UppercaseFirst ()}\n";
hasData = true;
}
foreach (DictionaryExample example in sense.Examples ?? Enumerable.Empty <DictionaryExample> ())
{
finalMessage += $" {example.Text.UppercaseFirst ()}\n";
hasData = true;
}
finalMessage += "\n";
}
}
}
if (finalMessage.Length >= 2000 && hasData)
{
IEnumerable <string> messages = finalMessage.SplitEveryNth(2000);
foreach (string message in messages)
{
await ReplyAsync(message);
}
return;
}
else if (hasData)
{
await ReplyAsync(finalMessage);
}
else
{
await ReplyAsync($"No data found for: {word}.");
}
}