/// <summary>
/// Adds the term model to the lexicon
/// </summary>
/// <param name="termModel">The term model.</param>
public void addTermModelToLexicon(termExploreModel termModel)
{
//var tlt = manager.lexiconContext.TermLemmas.Where<ITermLemma>(x => x.name.Equals(termModel.lemma.inputForm)&& x.type.Equals(termModel.lemma.gramSet.getPosType().toString()));
ITermLemma tl = manager.lexiconContext.TermLemmas.Where(x => x.name.Equals(termModel.lemmaForm)).FirstOrDefault();
//IQueryable<ITermLemma> tlt = manager.lexiconContext.TermLemmas.Where(x => x.name.Equals(termModel.lemma.inputForm));
//List<ITermLemma> tlt_l = tlt.ToList();
//ITermLemma tl = null;
if (tl != null)
{
// nista nije uradjeno
}
else
{
tl = manager.lexiconContext.TermLemmas.Create();
tl.name = termModel.lemmaForm.or(termModel.inputForm);
tl.gramSet = termModel.getGramSet();
tl.type = termModel.getPosType().toStringSafe("TEMP");
//if (termModel tl.type = termModel.gramSet.getPosType().toString();
foreach (termExploreItem item in termModel.instances)
{
ITermInstance ti = manager.lexiconContext.TermInstances.Where(x => x.name.Equals(item.inputForm)).FirstOrDefault();
if (ti == null)
{
ti = manager.lexiconContext.TermInstances.Create();
ti.name = item.inputForm;
//
ti.gramSet = item.getGramSet(); //.gramSet.GetAll();
ti.type = item.getPosType().toStringSafe(); //.// .gramSet.getPosType().toString();
ti.lemma = tl;
}
else
{
if (manager.settings.doResolveWordsInDebugMode)
{
output.AppendLine("Item [" + item.inputForm + "] of lemma [" + tl.name + "] was already defined.");
//foreach (var lm in ti.)
// output.AppendLine("[" + item.inputForm + "]->lemma [" + tl.name + "] was already defined.");
}
}
manager.lexiconContext.TermInstances.Add(ti);
}
}
manager.lexiconContext.SaveChanges();
}
/// <summary>
/// Expands the once.
/// </summary>
/// <param name="lexItem">The lex item to expand from</param>
/// <param name="type">The type of expansion</param>
/// <param name="exclude">Items not to expand to</param>
/// <returns></returns>
public static List <ILexiconItem> expandOnce(this ILexiconItem lexItem, lexiconItemExpandEnum type = lexiconItemExpandEnum.upBelowLateral, List <ILexiconItem> exclude = null)
{
string itemType = lexItem.getItemTypeName();
List <ILexiconItem> output = new List <ILexiconItem>();
if (exclude == null)
{
exclude = new List <ILexiconItem>();
}
if (type.HasFlag(lexiconItemExpandEnum.includeStart))
{
output.Add(lexItem);
}
switch (itemType)
{
case nameof(semanticLexicon.Concept):
IConcept concept = lexItem as IConcept;
if (type.HasFlag(lexiconItemExpandEnum.below))
{
output.AddRange(concept.lemmas);
output.AddRange(concept.hypoConcepts);
}
if (type.HasFlag(lexiconItemExpandEnum.lateral))
{
output.AddRange(concept.relatedTo);
output.AddRange(concept.relatedFrom, true);
}
if (type.HasFlag(lexiconItemExpandEnum.conceptUp))
{
output.AddUnique(concept.hyperConcept);
}
break;
case nameof(TermLemma):
ITermLemma lemma = lexItem as ITermLemma;
if (lemma == null)
{
return(output);
}
if (type.HasFlag(lexiconItemExpandEnum.below))
{
if (lemma.instances != null)
{
output.AddRange(lemma.instances);
}
}
if (type.HasFlag(lexiconItemExpandEnum.lateral))
{
if (lemma.relatedFrom != null)
{
output.AddRange(lemma.relatedFrom);
}
if (lemma.relatedTo != null)
{
output.AddRange(lemma.relatedTo);
}
}
if (type.HasFlag(lexiconItemExpandEnum.up))
{
if (lemma.concepts != null)
{
output.AddRange(lemma.concepts);
}
}
if (type.HasFlag(lexiconItemExpandEnum.compounds))
{
if (lemma.compounds != null)
{
output.AddRange(lemma.compounds);
}
}
break;
case nameof(TermInstance):
ITermInstance instance = lexItem as ITermInstance;
if (type.HasFlag(lexiconItemExpandEnum.up))
{
output.AddUnique(instance.lemma);
}
break;
}
output.RemoveAll(x => exclude.Contains(x));
return(output);
}
