// ********************************************************************************
/// <summary>
///
/// </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 FireTermInfoResult(long requestid, int termbaseID, TermInfo info)
{
if (TermListResult == null)
{
return;
}
TermInfoResultArgs args = new TermInfoResultArgs();
args.RequestID = requestid;
args.TermBaseID = termbaseID;
args.Info = info;
TermInfoResult(this, args);
}
// ********************************************************************************
/// <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="termID"></param>
/// <param name="info"></param>
/// <returns></returns>
/// <created>UPh,31.10.2015</created>
/// <changed>UPh,31.10.2015</changed>
// ********************************************************************************
internal override bool GetTermInfo(int termID, out TermInfo info, IAbortTermQuery abort)
{
info = null;
if (_LangIndex1 < 0 || _LangIndex2 < 0)
{
return(false);
}
if (termID < 0 || termID >= _Terms.Count)
{
return(false);
}
info = new TermInfo();
info.TermID = termID;
TermInfo.LangSet langset1 = info.AddLanguage(_Languages[_LangIndex1]);
if (langset1 == null)
{
return(false);
}
langset1.AddTerm(_Terms[termID].Item1);
TermInfo.LangSet langset2 = info.AddLanguage(_Languages[_LangIndex2]);
if (langset2 == null)
{
return(false);
}
langset2.AddTerm(_Terms[termID].Item2);
return(true);
}
// ********************************************************************************
/// <summary>
///
/// </summary>
/// <param name="termID"></param>
/// <param name="info"></param>
/// <param name="abort"></param>
/// <returns></returns>
/// <created>UPh,01.11.2015</created>
/// <changed>UPh,01.11.2015</changed>
// ********************************************************************************
internal override bool GetTermInfo(int termID, out TermInfo info, IAbortTermQuery abort)
{
info = null;
if (_DataBase == null)
{
return(false);
}
if (string.IsNullOrEmpty(_LangAttribute1))
{
return(false);
}
try
{
string sql = "SELECT text FROM mtConcepts WHERE conceptid = @id";
using (OleDbCommand cmd = new OleDbCommand(sql, _DataBase))
{
cmd.Parameters.AddWithValue("@id", termID);
string text = cmd.ExecuteScalar() as string;
XmlDocument doc = new XmlDocument();
doc.XmlResolver = null;
doc.LoadXml(text);
info = new TermInfo();
info.TermID = termID;
XmlNode nodeProps = doc.SelectSingleNode("./cG");
if (nodeProps != null)
{
ReadProps(nodeProps, ref info._Props);
}
// Language 1
string xpath1 = string.Format("/cG/lG/l[@type='{0}']", _LangAttribute1);
XmlNode nodeLangset1 = doc.SelectSingleNode(xpath1);
if (nodeLangset1 != null)
{
int lcid1 = GetLCIDFromAttributeName(_LangAttribute1);
if (lcid1 >= 0)
{
TermInfo.LangSet langset1 = info.AddLanguage(lcid1);
ReadLangset(nodeLangset1.ParentNode, langset1);
}
}
// Language 2
string xpath2 = string.Format("/cG/lG/l[@type='{0}']", _LangAttribute2);
XmlNode nodeLangset2 = doc.SelectSingleNode(xpath2);
if (nodeLangset2 != null)
{
int lcid2 = GetLCIDFromAttributeName(_LangAttribute2);
if (lcid2 >= 0)
{
TermInfo.LangSet langset2 = info.AddLanguage(lcid2);
ReadLangset(nodeLangset2.ParentNode, langset2);
}
}
}
}
catch (Exception)
{
return(false);
}
return(true);
}
internal abstract bool GetTermInfo(int termID, out TermInfo info, IAbortTermQuery abort);
// ********************************************************************************
/// <summary>
///
/// </summary>
/// <param name="requestid"></param>
/// <param name="match"></param>
/// <param name="from"></param>
/// <param name="len"></param>
/// <param name="result"></param>
/// <created>UPh,20.03.2016</created>
/// <changed>UPh,20.03.2016</changed>
// ********************************************************************************
private void HandleProhibitedTerminologyMatch(bool bTargetLanguage, long requestid, IndexItem match, int from, int len, List <TerminologyResultArgs> result = null)
{
// Get TermInfo
TermBase termbase = _TermBases.FindTermBase(match.TermBaseID);
if (termbase == null)
{
return;
}
TermInfo terminfo = null;
if (!termbase.GetTermInfo(match.TermID, out terminfo, this))
{
return;
}
int langset = -1;
if (bTargetLanguage)
{
if (terminfo.LanguageSets.Count < 2)
{
return;
}
langset = 1;
}
else
{
if (terminfo.LanguageSets.Count < 1)
{
return;
}
langset = 0;
}
foreach (TermInfo.Term term in terminfo.LanguageSets[langset].Terms)
{
if (term.Props == null || term.Props.Status != TermStatus.prohibited)
{
continue;
}
ulong hash = TermIndex.MakeGlossaryHashCode(term.Text);
if (match.Hash != hash)
{
continue;
}
TerminologyResultArgs args = new TerminologyResultArgs();
args.Status = term.Props.Status;
args.RequestID = requestid;
args.TermBaseID = match.TermBaseID;
args.TermID = match.TermID;
args.FindFrom = from;
args.FindLen = len;
args.Term1 = term.Text;
args.Term2 = term.Text;
args.Origin = termbase.File.DisplayName;
args.Description = "";
if (result != null)
{
result.Add(args);
}
else
{
_TermbaseQuery.FireTerminologyResult(args);
}
}
}
// ********************************************************************************
/// <summary>
///
/// </summary>
/// <param name="match"></param>
/// <returns></returns>
/// <created>UPh,14.11.2015</created>
/// <changed>UPh,14.11.2015</changed>
// ********************************************************************************
private void HandleTerminologyMatch(long requestid, IndexItem match, int from, int len, List <TerminologyResultArgs> result = null)
{
// Get TermInfo
TermBase termbase = _TermBases.FindTermBase(match.TermBaseID);
if (termbase == null)
{
return;
}
TermInfo terminfo = null;
if (!termbase.GetTermInfo(match.TermID, out terminfo, this))
{
return;
}
if (terminfo.LanguageSets.Count != 2)
{
return;
}
TermInfo.Term srcterm = null;
foreach (TermInfo.Term term in terminfo.LanguageSets[0].Terms)
{
ulong hash = TermIndex.MakeGlossaryHashCode(term.Text);
if (match.Hash != hash)
{
continue;
}
srcterm = term;
break;
}
if (srcterm == null)
{
return;
}
string definition = terminfo.Definition;
foreach (TermInfo.Term term in terminfo.LanguageSets[1].Terms)
{
TerminologyResultArgs args = new TerminologyResultArgs();
if (term.Props != null)
{
args.Status = term.Props.Status;
}
else
{
args.Status = TermStatus.none;
}
args.RequestID = requestid;
args.TermBaseID = match.TermBaseID;
args.TermID = match.TermID;
args.FindFrom = from;
args.FindLen = len;
args.Term1 = srcterm.Text;
args.Term2 = term.Text;
args.Origin = termbase.File.DisplayName;
args.Description = definition;
if (result != null)
{
result.Add(args);
}
else
{
_TermbaseQuery.FireTerminologyResult(args);
}
}
}
