// ********************************************************************************
/// <summary>
///
/// </summary>
/// <param name="items"></param>
/// <param name="abort"></param>
/// <returns></returns>
/// <created>UPh,01.11.2015</created>
/// <changed>UPh,01.11.2015</changed>
// ********************************************************************************
internal override void GetTermList(TermListItems items, IAbortTermQuery abort, bool bTargetLanguage)
{
if (_DataBase == null)
{
return;
}
if (string.IsNullOrEmpty(_LangAttribute1))
{
return;
}
try
{
string langattribute;
if (bTargetLanguage)
{
langattribute = _LangAttribute2;
}
else
{
langattribute = _LangAttribute1;
}
string sql = string.Format("SELECT origterm,conceptid FROM {0}", "I_" + langattribute);
using (OleDbCommand cmd = new OleDbCommand(sql, _DataBase))
{
//cmd.Parameters.AddWithValue("@langtable", "I_" + _LangAttribute1);
using (OleDbDataReader reader = cmd.ExecuteReader())
{
while (reader.Read())
{
try
{
string term = reader[0].ToString();
int termID = reader.GetInt32(1);
items.Add(File.ID, term, termID);
}
catch (Exception)
{
continue;
}
}
}
}
// Get statuses
foreach (TermListItem item in items)
{
GetTermStatus(item, abort);
}
}
catch (Exception)
{
items.Clear();
}
}
// ********************************************************************************
/// <summary>
///
/// </summary>
/// <param name="items"></param>
/// <returns></returns>
/// <created>UPh,29.10.2015</created>
/// <changed>UPh,29.10.2015</changed>
// ********************************************************************************
internal override void GetTermList(TermListItems items, IAbortTermQuery abort, bool bTargetLanguage)
{
if (_Doc == null)
{
return;
}
if (bTargetLanguage)
{
return; // TODO
}
for (int iLangset = 0; iLangset < _Langset1.Count; iLangset++)
{
XmlNode langSet = _Langset1[iLangset];
foreach (XmlNode node in langSet.SelectNodes(".//term"))
{
items.Add(File.ID, node.InnerText, iLangset);
}
//XmlNode node = langSet.SelectSingleNode(".//term");
//if (node == null)
// node = langSet.SelectSingleNode(".//ntig/termGrp/term");
//if (node != null)
// items.Add(File.ID, node.InnerText, items.Count);
}
}
// ********************************************************************************
/// <summary>
/// From worker
/// </summary>
/// <param name="requestid"></param>
/// <param name="items"></param>
/// <returns></returns>
/// <created>UPh,31.10.2015</created>
/// <changed>UPh,31.10.2015</changed>
// ********************************************************************************
internal void FireTermListResult(long requestid, TermListItems items)
{
if (TermListResult == null)
{
return;
}
TermListResultArgs args = new TermListResultArgs();
args.RequestID = requestid;
args.Items = items;
TermListResult(this, args);
}
// ********************************************************************************
/// <summary>
///
/// </summary>
/// <param name="request"></param>
/// <param name="result"></param>
/// <created>UPh,20.03.2016</created>
/// <changed>UPh,20.03.2016</changed>
// ********************************************************************************
internal void HandleProhibitedTerminologyRequest(TermBaseRequest request, List <TerminologyResultArgs> result = null)
{
bool bSync = (result != null);
bool bTargetLanguage = (_TermbaseQuery.LCID2 > 0);
// Build index if necessary (works on target language)
if (_Index2.LCID != _TermbaseQuery.LCID2)
{
TermListItems items = RetrieveTermList(false, bTargetLanguage);
if (!bSync && _shouldStop)
{
return;
}
// Index from items
_Index2.BuildIndex(bTargetLanguage ? _TermbaseQuery.LCID2 : _TermbaseQuery.LCID1, items);
}
WordSegments wordSegments = new WordSegments(request.Term);
int nWords = wordSegments.Count;
if (nWords == 0)
{
return;
}
// Start with max term word count (3)
for (int nTermWords = 3; nTermWords >= 1; nTermWords--)
{
for (int iWord0 = 0; iWord0 < nWords - nTermWords + 1; iWord0++)
{
int iWord1 = iWord0 + nTermWords - 1;
int from = wordSegments.GetWordStart(iWord0);
int to = wordSegments.GetWordEnd(iWord1);
foreach (IndexItem match in _Index2.Matches(request.Term, from, to - from))
{
HandleProhibitedTerminologyMatch(bTargetLanguage, request.ID, match, from, to - from, result);
}
}
}
}
// ********************************************************************************
/// <summary>
///
/// </summary>
/// <param name="items"></param>
/// <returns></returns>
/// <created>UPh,14.11.2015</created>
/// <changed>UPh,14.11.2015</changed>
// ********************************************************************************
public void BuildIndex(int lcid, TermListItems items)
{
LCID = lcid;
int count = items.Count;
_Items = new IndexItem[count];
for (int i = 0; i < count; i++)
{
TermListItem termItem = items[i];
_Items[i].Hash = MakeGlossaryHashCode(termItem.Term);
_Items[i].TermBaseID = termItem.TermBaseID;
_Items[i].TermID = termItem.TermID;
}
Array.Sort(_Items);
}
// ********************************************************************************
/// <summary>
/// Handle request to get term list items
/// </summary>
/// <returns></returns>
/// <created>UPh,25.10.2015</created>
/// <changed>UPh,25.10.2015</changed>
// ********************************************************************************
private void HandleTermListRequest(TermBaseRequest request)
{
TermListItems items = RetrieveTermList(false, false);
if (items == null)
{
return;
}
if (_Paused || _shouldStop)
{
return;
}
items.Sort((a, b) => string.Compare(a.Term, b.Term, true));
_TermbaseQuery.FireTermListResult(request.ID, items);
}
// ********************************************************************************
/// <summary>
///
/// </summary>
/// <param name="term"></param>
/// <param name="infos"></param>
/// <returns></returns>
/// <created>UPh,17.11.2015</created>
/// <changed>UPh,17.11.2015</changed>
// ********************************************************************************
internal void HandleTermInfosRequest(string term, List <TermInfoResultArgs> result = null)
{
bool bSync = (result != null);
// Build index if necessary
if (_Index.LCID != _TermbaseQuery.LCID1)
{
TermListItems items = RetrieveTermList(true, false);
if (!bSync && _shouldStop)
{
return;
}
// Index from items
_Index.BuildIndex(_TermbaseQuery.LCID1, items);
}
foreach (IndexItem match in _Index.Matches(term))
{
// Get TermInfo
TermBase termbase = _TermBases.FindTermBase(match.TermBaseID);
if (termbase == null)
{
continue;
}
TermInfo terminfo = null;
if (!termbase.GetTermInfo(match.TermID, out terminfo, this))
{
return;
}
TermInfoResultArgs item = new TermInfoResultArgs();
item.RequestID = 0;
item.TermBaseID = match.TermBaseID;
item.Info = terminfo;
result.Add(item);
}
}
// ********************************************************************************
/// <summary>
///
/// </summary>
/// <param name="items"></param>
/// <param name="bAbort"></param>
/// <returns></returns>
/// <created>UPh,25.10.2015</created>
/// <changed>UPh,25.10.2015</changed>
// ********************************************************************************
internal override void GetTermList(TermListItems items, IAbortTermQuery abort, bool bTargetLanguage)
{
if (_Stream == null)
{
return;
}
for (int i = 0; i < _Terms.Count; i++)
{
var tuple = _Terms[i];
TermListItem item = new TermListItem();
if (bTargetLanguage)
{
items.Add(File.ID, tuple.Item2, i);
}
else
{
items.Add(File.ID, tuple.Item1, i);
}
}
}
// ********************************************************************************
/// <summary>
///
/// </summary>
/// <param name="request"></param>
/// <param name="result"></param>
/// <returns></returns>
/// <created>UPh,17.11.2015</created>
/// <changed>UPh,17.11.2015</changed>
// ********************************************************************************
internal void HandleSingleTermRequest(TermBaseRequest request, List <TerminologyResultArgs> result = null)
{
bool bSync = (result != null);
// Build index if necessary
if (_Index.LCID != _TermbaseQuery.LCID1)
{
TermListItems items = RetrieveTermList(true, false);
if (!bSync && _shouldStop)
{
return;
}
// Index from items
_Index.BuildIndex(_TermbaseQuery.LCID1, items);
}
foreach (IndexItem match in _Index.Matches(request.Term))
{
HandleTerminologyMatch(request.ID, match, 0, request.Term.Length, result);
}
}
// ********************************************************************************
/// <summary>
/// Loops all term bases and collects terms in current language
/// </summary>
/// <returns></returns>
/// <created>UPh,14.11.2015</created>
/// <changed>UPh,14.11.2015</changed>
// ********************************************************************************
private TermListItems RetrieveTermList(bool bLanguagePairOnly, bool bTargetLanguage)
{
TermListItems items = new TermListItems();
foreach (TermBase termbase in _TermBases)
{
if (_Paused || _shouldStop)
{
return(null);
}
if (bLanguagePairOnly && !termbase.HasLanguagePair())
{
continue;
}
TermListItems items2 = new TermListItems();
termbase.GetTermList(items2, this, bTargetLanguage);
items.AddRange(items2);
}
return(items);
}
internal abstract void GetTermList(TermListItems items, IAbortTermQuery abort, bool bTargetLanguage);
