public static IEnumerable <EquivalentTermEntity> Map(this SynonymGroup synonymGroup)
{
return(from s in synonymGroup.Terms
select new EquivalentTermEntity {
equivalentGroupId = synonymGroup.Id, searchTerm = s
});
}
/// <summary>
/// Adds the given synonyms to the thesaurus.
/// </summary>
/// <param name="synonyms">The synonyms to add.</param>
public void AddSynonyms(IEnumerable <string> synonyms)
{
HashSet <int> foundSynonymGroupIDs = new HashSet <int>();
List <string> unrecognizedWords = new List <string>();
foreach (string word in synonyms)
{
var wordsQuery = dbContext.Words.Where(w => w.Characters == word);
if (wordsQuery.Any())
{
foundSynonymGroupIDs.Add(wordsQuery.Select(p => p.SynonymGroupID).First());
continue;
}
else
{
unrecognizedWords.Add(word);
}
}
SynonymGroup synonymGroup = GetSynonymGroup(foundSynonymGroupIDs);
foreach (string word in unrecognizedWords)
{
var newWord = new Word
{
Characters = word,
SynonymGroup = synonymGroup
};
dbContext.Words.Add(newWord);
}
dbContext.SaveChanges();
}
/// <summary>
/// Change <see cref="Word.SynonymGroupID"/>'s in <see cref="ThesaurusContext.Words"/> to point to the same
/// <see cref="SynonymGroup"/> in <see cref="ThesaurusContext.SynonymGroups"/> and deletes the unused
/// <see cref="SynonymGroup"/>'s from <see cref="ThesaurusContext.SynonymGroups"/>.
/// </summary>
/// <param name="synonymGroupIDsToMerge">The synonym group id's to merge</param>
/// <returns>A merged synonym group</returns>
private SynonymGroup GetMergedSynonymGroup(HashSet <int> synonymGroupIDsToMerge)
{
int targetID = synonymGroupIDsToMerge.Min();
SynonymGroup targetSynonymGroup = dbContext.SynonymGroups.Find(targetID);
synonymGroupIDsToMerge.Remove(targetID);
foreach (int groupId in synonymGroupIDsToMerge)
{
var words = dbContext.Words.Where(g => g.SynonymGroupID == groupId).ToList();
SynonymGroup mergingSynonymGroup = dbContext.SynonymGroups.Find(groupId);
foreach (Word word in words)
{
word.SynonymGroup = targetSynonymGroup;
dbContext.SaveChanges();
}
dbContext.SynonymGroups.Remove(mergingSynonymGroup);
dbContext.SaveChanges();
}
return(targetSynonymGroup);
}
void ISynonymsRepository.CreateSynonyms(SynonymGroup synonymGroup)
{
using (var dc = new SynonymsDataContext(_connectionFactory.CreateConnection()))
{
dc.EquivalentTermEntities.InsertAllOnSubmit(synonymGroup.Map());
dc.SubmitChanges();
}
}
public static SynonymWord SynWord(SynonymGroup synGroup, string word) // do I need to set the synonym group, or will id suffice?
{
return(new SynonymWord()
{
GroupId = synGroup.Id,
Word = word
});
}
public SynonymGroupDomain CreateSynonymGroup(SynonymGroup request)
{
try
{
Context.SynonymGroups.Add(request);
SaveChanges();
}
catch (Exception e)
{
LoggingHandler.LogError(e.Message);
LoggingHandler.LogError(e.StackTrace);
throw;
}
return(_mapper.ToDomain(request));
}
/// <summary>
/// Gets the <see cref="SynonymGroup"/> that the words should be added to.
/// </summary>
/// <param name="foundSynonymGroupIDs">the ids of possible groups</param>
/// <returns>The <see cref="SynonymGroup"/> that the words should be added to</returns>
private SynonymGroup GetSynonymGroup(HashSet <int> foundSynonymGroupIDs)
{
SynonymGroup synonymGroup;
if (foundSynonymGroupIDs.Count == 0)
{
// No synonyms was found for the words entered, create a new synonym group
synonymGroup = new SynonymGroup();
}
else if (foundSynonymGroupIDs.Count == 1)
{
// One synonym group was found.
synonymGroup = dbContext.SynonymGroups.Find(foundSynonymGroupIDs.First());
}
else
{
// The words was members of multiple synonymgroups.
synonymGroup = GetMergedSynonymGroup(foundSynonymGroupIDs);
}
return(synonymGroup);
}
IList <SynonymGroup> ISynonymsRepository.GetSynonyms()
{
using (var dc = new SynonymsDataContext(_connectionFactory.CreateConnection()).AsReadOnly())
{
var synonymGroupMap = new Dictionary <Guid, SynonymGroup>();
foreach (var entity in GetEquivalentTermEntities(dc))
{
SynonymGroup synonymGroup;
if (!synonymGroupMap.TryGetValue(entity.equivalentGroupId, out synonymGroup))
{
synonymGroup = new SynonymGroup {
Id = entity.equivalentGroupId, Terms = new List <string>()
};
synonymGroupMap.Add(entity.equivalentGroupId, synonymGroup);
}
synonymGroup.Terms.Add(entity.searchTerm);
}
return(synonymGroupMap.Values.ToList());
}
}
public SynonymGroupDomain ToDomain(SynonymGroup synonymGroup)
{
return(_mapper.Map <SynonymGroupDomain>(synonymGroup));
}
