public void WordQueryByTitleUpperCase()
{
var w1 = session.Load <Word>(IntToGuid <Word>(1));
var res = WordQuery.ByTitle(session)(w1.Title.ToUpper());
Assert.AreEqual(w1, res);
}
public async Task <QueryResult <Word> > GetWords(WordQuery queryObj)
{
var result = new QueryResult <Word>();
var query = context.Words
.Include(w => w.PartOfSpeech)
.Include(w => w.Features)
.ThenInclude(wf => wf.Feature)
.Include(w => w.Subcategory)
.ThenInclude(m => m.Category)
.AsQueryable();
query = query.ApplyFiltering(queryObj);
var columnsMap = new Dictionary <string, Expression <Func <Word, object> > >()
{
["category"] = w => w.Subcategory.Category.Name,
["subcategory"] = w => w.Subcategory.Name,
["name"] = w => w.Name,
["meaning"] = w => w.Meaning,
["createdAt"] = w => w.CreatedAt
};
query = query.ApplyOrdering(queryObj, columnsMap);
result.TotalItems = await query.CountAsync();
query = query.ApplyPaging(queryObj);
result.Items = await query.ToListAsync();
return(result);
}
public void WordQueryStartingWithUpperCase()
{
var w1 = session.Load <Word>(IntToGuid <Word>(1));
var res = WordQuery.StartingWith(session)(w1.Title.ToUpper());
Assert.IsTrue(res.Contains(w1));
}
public IEnumerable GetWords([FromBody] WordQuery query)
{
var words = new List <Word>();
var connection = DatabaseHelper.OpenConnection();
var command = GetCommandForWordsSp(connection, query);
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
var word = new Word();
word.Id = int.Parse(reader[0].ToString());
word.Text = reader[1].ToString();
word.EnglishExplanation = reader[2].ToString();
word.RussianExplanation = reader[3].ToString();
word.Image = reader[4].ToString();
word.Sound = reader[4].ToString();
word.Synonim = reader[5].ToString();
word.Status = reader[6].ToString();
words.Add(word);
}
}
DatabaseHelper.CloseConnection(connection);
return(words);
}
/// <summary>
/// 线程参数
/// </summary>
/// <param name="searcher">绑定结果池的分词搜索器</param>
/// <param name="checkLessWord">未匹配分词自定义过滤处理</param>
/// <param name="checkLess">未匹配分词自定义过滤处理</param>
public ThreadParameter(StaticSearcher <keyType> searcher, CheckLessWord checkLessWord = null, CheckLess checkLess = null)
{
this.searcher = searcher;
this.checkLessWord = checkLessWord;
wordQuery = new WordQuery(searcher);
queue = new Queue(searcher);
}
public void WordQueryByTitlesUpperCase()
{
var w1 = session.Load <Word>(IntToGuid <Word>(1));
var w2 = session.Load <Word>(IntToGuid <Word>(2));
var res = WordQuery.ByTitles(session)(new[] { w1.Title.ToUpper(), w2.Title.ToUpper() });
Assert.AreEqual(2, res.Count());
Assert.IsTrue(res.Contains(w1));
Assert.IsTrue(res.Contains(w2));
}
private IEnumerable <Word> LoadMeasureWords(SearchOptionsDTO dto, ISession session, out bool mWordsMissed)
{
var mWordTitles = (from w in dto.MeasuresAll
.Union(dto.MeasuresAny)
.Select(x => x.Word)
where w != null
select w.Title).Distinct().ToList();
var mWords = WordQuery.ByTitles(session)(mWordTitles).ToList();
mWordsMissed = mWordTitles.Count != mWords.Count;
return(mWords);
}
public async Task <FileResult> GetPdf()
{
IWorkbook workbook = new XSSFWorkbook();
ISheet sheet1 = workbook.CreateSheet("Sheet1");
var titleFont = workbook.CreateFont();
titleFont.Boldweight = (short)NPOI.SS.UserModel.FontBoldWeight.Bold;
var titleStyle = workbook.CreateCellStyle();
titleStyle.SetFont(titleFont);
IRow row = sheet1.CreateRow(0);
string[] headers = new string[] { "Word", "Meaning", "UK", "US", "Example", "Subcategory", "Category", "Date add" };
for (var i = 0; i < headers.Length; i++)
{
ICell cell = row.CreateCell(i);
cell.SetCellValue(headers[i]);
cell.CellStyle = titleStyle;
}
var filter = new WordQuery();
filter.WithoutPagination = true;
var queryResult = await repository.GetWords(filter);
for (var i = 0; i < queryResult.Items.Count(); i++)
{
row = sheet1.CreateRow(i + 1);
var word = queryResult.Items.ElementAt(i);
row.CreateCell(0).SetCellValue(word.Name);
row.CreateCell(1).SetCellValue(word.Meaning);
row.CreateCell(2).SetCellValue(word.PronunciationUK);
row.CreateCell(3).SetCellValue(word.PronunciationUS);
row.CreateCell(4).SetCellValue(Regex.Replace(word.Example, "<.*?>", String.Empty));
row.CreateCell(5).SetCellValue(word.Subcategory.Name);
row.CreateCell(6).SetCellValue(word.Subcategory.Category.Name);
row.CreateCell(7).SetCellValue(String.Format("{0:MM-dd-yyyy}", word.CreatedAt));
}
for (var i = 0; i < headers.Length; i++)
{
sheet1.AutoSizeColumn(i);
}
var stream = new MemoryStream();
workbook.Write(stream);
return(File(new MemoryStream(stream.ToArray()), "application/vnd.ms-excel", "plik.xls"));
}
/// <summary>
/// 释放资源
/// </summary>
public void Dispose()
{
if (wordQuery != null)
{
wordQuery.Dispose();
wordQuery = null;
}
if (queue != null)
{
queue.Dispose();
queue = null;
}
Unmanaged.Free(ref getResultIndexsMapBuffer);
}
public JsonResult GetWordsForUserByUserLevel([FromBody] WordQuery query)
{
var connection = DatabaseHelper.OpenConnection();
var param = GetParamForGettingWordsForUserByLevel(query.UserId, query.Level, int.Parse(query.Sublevel));
var data = connection.QueryMultiple("WordRepository_GetWordsForUserByLevel", param, commandType: CommandType.StoredProcedure);
var wordsUdts = data.Read <WordUdt>().ToList();
var attemptsUdts = data.Read <AttemptUdt>().ToList();
var words = GetListWords(wordsUdts, attemptsUdts);
DatabaseHelper.CloseConnection(connection);
var serializedWords = JsonConvert.SerializeObject(words);
return(new JsonResult(serializedWords));
}
public static IQueryable <Word> ApplyFiltering(this IQueryable <Word> query, WordQuery queryObj)
{
if (!String.IsNullOrEmpty(queryObj.Query))
{
query = query.Where(w => w.Name.Contains(queryObj.Query) ||
w.Meaning.Contains(queryObj.Query) ||
w.Example.Contains(queryObj.Query) ||
w.PronunciationUK.Contains(queryObj.Query) ||
w.PronunciationUS.Contains(queryObj.Query));
}
if (queryObj.CategoryId.HasValue)
{
query = query.Where(w => w.Subcategory.CategoryId == queryObj.CategoryId.Value);
}
if (queryObj.SubcategoryId.HasValue)
{
query = query.Where(w => w.SubcategoryId == queryObj.SubcategoryId.Value);
}
if (queryObj.PartOfSpeechId.HasValue)
{
query = query.Where(w => w.PartOfSpeechId == queryObj.PartOfSpeechId.Value);
}
if (!String.IsNullOrEmpty(queryObj.Name))
{
query = query.Where(w => w.Name.Contains(queryObj.Name));
}
if (!String.IsNullOrEmpty(queryObj.Meaning))
{
query = query.Where(w => w.Meaning.Contains(queryObj.Meaning));
}
if (!String.IsNullOrEmpty(queryObj.Example))
{
query = query.Where(w => w.Example.Contains(queryObj.Example));
}
if (queryObj.IsLearned.HasValue)
{
query = query.Where(w => w.IsLearned == queryObj.IsLearned.Value);
}
return(query);
}
protected override void OnOk()
{
foreach (var crit in word.Crits)
{
var l = OptionsLoader.FromFormat(crit.OptionsFormat);
crit.Options = l.ReplaceWord(crit.Options, oldTitle, word.Title);
}
(word as IEditableObject).EndEdit();
// если такое слово уже было, делааем доступным врачу
var toSave = WordQuery.ByTitle(Session)(word.Title) ?? word;
AuthorityController.CurrentDoctor.AddWords(toSave.ToEnumerable());
Session.DoSave(toSave);
this.Send(Event.EntitySaved, toSave.AsParams(MessageKeys.Entity));
}
/// <summary>
/// Все слова с началом как у запроса с учетом предыдущего.
/// </summary>
/// <param name="query"></param>
/// <param name="prev"></param>
/// <returns></returns>
private IEnumerable <Word> QueryWords(string query, object prev, bool withNotPersisted)
{
if (query.IsNullOrEmpty() && !ShowAllWordsOnEmptyQuery)
{
return(Enumerable.Empty <Word>());
}
Word parent = prev as Word;
var unsaved = withNotPersisted
? CreatedWordsManager.Created.Where(w => w.Title.StartsWith(query, StringComparison.OrdinalIgnoreCase))
: Enumerable.Empty <Word>();
var fromDB = ShowChildrenFirst ?
WordQuery.StartingWithChildrenFirst(session)(parent, query) :
WordQuery.StartingWith(session)(query);
return(fromDB.Union(unsaved));
}
private SqlCommand GetCommandForWordsSp(SqlConnection connection, WordQuery query)
{
var command = new SqlCommand("WordRepository_GetWordsByLevel", connection);
command.CommandType = CommandType.StoredProcedure;
var userId = new SqlParameter {
ParameterName = "userId", Value = query.UserId
};
var section = new SqlParameter {
ParameterName = "level", Value = query.Level
};
var level = new SqlParameter {
ParameterName = "sublevel", Value = int.Parse(query.Sublevel)
};
command.Parameters.Add(userId);
command.Parameters.Add(section);
command.Parameters.Add(level);
return(command);
}
/// <summary>
/// Делает тексты словаря словами словаря.
/// Возвращает созданные слова.
/// </summary>
/// <param name="voc"></param>
private IEnumerable <Word> CreateWordsFromTemp(Vocabulary voc, IEnumerable <WordTemplate> templates)
{
// для каждого шаблона есть слово
Contract.Ensures(templates.Select(x => x.Title.ToLower())
.Except(voc.Words.Select(x => x.Title.ToLower())).Count() == 0);
var created = new List <Word>();
foreach (var text in templates.Select(x => x.Title))
{
var existing = WordQuery.ByTitle(session)(text); // для любого врача, в любом регистре
if (existing == null)
{
var w = new Word(text);
voc.AddWord(w);
created.Add(w);
}
else
{
voc.AddWord(existing);
}
}
return(created);
}
private void CreateFilter()
{
_filter = new FilterViewModel <Word>(WordQuery.StartingWith(Session));
}
public void Update(WordQuery item)
{
_todos[item.Key] = item;
}
public void Add(WordQuery item)
{
item.Key = Guid.NewGuid().ToString();
_todos[item.Key] = item;
}
/// <summary>
/// 线程参数
/// </summary>
/// <param name="searcher">绑定结果池的分词搜索器</param>
public ThreadParameter(StaticSearcher <keyType> searcher)
{
this.searcher = searcher;
wordQuery = new WordQuery(searcher);
queue = new Queue(searcher);
}
/// <summary>
/// Determines whether an english word should be preceded by the indefinite article "a" or "an".
/// By Eamon Nerbonne; feedback can be reported to https://github.com/EamonNerbonne/a-vs-an/
/// </summary>
/// <param name="word">
/// The word to test. AvsAn assumes this is a complete word; in some cases word-prefixes may result in
/// a differing classification that complete words. If you wish to classify an incomplete word (a prefix), append a
/// non-word, non-space character such as the underscore "_" as a placeholder for further letters.
/// </param>
/// <returns>A classification result indicating "a" or "an" with some wikipedia-derived statistics.</returns>
public static Result Query(string word)
{
return(WordQuery.Query(BuiltInDictionary.Root, word));
}
/// <summary>
/// Делает опции с реальными сущностями.
/// </summary>
protected SearchOptions LoadFromDTO(SearchOptionsDTO dto, ISession session)
{
Contract.Requires(dto != null);
Contract.Ensures(dto.GetAllChildrenCount() == Contract.Result <SearchOptions>().GetAllChildrenCount());
var result = new SearchOptions();
// some options
bool sscopeNotParsed = false;
bool grOpNotParsed = false;
QueryGroupOperator groupOperator;
if (!Enum.TryParse <QueryGroupOperator>(dto.GroupOperator, out groupOperator))
{
groupOperator = QueryGroupOperator.All;
grOpNotParsed = true;
}
SearchScope sscope;
if (!Enum.TryParse <SearchScope>(dto.SearchScope, out sscope))
{
sscope = SearchScope.HealthRecord;
sscopeNotParsed = true;
}
result.GroupOperator = groupOperator;
result.SearchScope = sscope;
result.MinAny = dto.MinAny;
result.WithConf = dto.WithConf;
// words
var allWordsTitles = dto.CWordsAll.Union(dto.CWordsAny).Union(dto.CWordsNot).Select(x => x.Title);
var words = WordQuery.ByTitles(session)(allWordsTitles);
bool confNotParsedAll;
bool confNotParsedAny;
bool confNotParsedNot;
result.CWordsAll = new List <Confindencable <Word> >(SelectConfWords(dto.CWordsAll, words, out confNotParsedAll));
result.CWordsAny = new List <Confindencable <Word> >(SelectConfWords(dto.CWordsAny, words, out confNotParsedAny));
result.CWordsNot = new List <Confindencable <Word> >(SelectConfWords(dto.CWordsNot, words, out confNotParsedNot));
// measures
bool mWordsMissed;
bool uomsMissed;
var mWords = LoadMeasureWords(dto, session, out mWordsMissed);
var uoms = LoadUoms(dto, session, out uomsMissed);
bool mopNotParsed;
var mAll = SelectMeasures(dto.MeasuresAll, mWords, uoms, out mopNotParsed);
var mAny = SelectMeasures(dto.MeasuresAny, mWords, uoms, out mopNotParsed);
result.MeasuresAll = new List <MeasureOp>(mAll);
result.MeasuresAny = new List <MeasureOp>(mAny);
// cats
var cats = CategoryQuery.ByTitles(session)(dto.Categories.Select(x => x.Title));
result.Categories = new List <HrCategory>(cats);
// childs
dto.Children.ForAll(x =>
{
var child = this.LoadFromDTO(x, session);
result.Children.Add(child);
});
var smthMissed =
result.CWordsAll.Count != dto.CWordsAll.Count ||
result.CWordsAny.Count != dto.CWordsAny.Count ||
result.CWordsNot.Count != dto.CWordsNot.Count ||
result.MeasuresAll.Count != dto.MeasuresAll.Count ||
result.MeasuresAny.Count != dto.MeasuresAny.Count ||
result.Categories.Count != dto.Categories.Count ||
mWordsMissed ||
uomsMissed;
var notParsed = confNotParsedAll || confNotParsedAny || confNotParsedNot || sscopeNotParsed || grOpNotParsed || mopNotParsed;
if (smthMissed || notParsed || result.Children.Any(x => x.PartialLoaded))
{
result.SetPartialLoaded();
}
return(result);
}
