public override List <GrammarModel> GetAll()
{
using (var db = new JazeDatabaseContext())
{
return(db.Grammars.ToList().Select(o => GrammarModel.Create(o)).ToList());
}
}
public override void LoadFull(GrammarModel model)
{
if (!model.IsLoadFull)
{
using (var db = new JazeDatabaseContext())
{
model.Detail = JsonConvert.DeserializeObject <GrammarDetail[]>(model.DetailText);
foreach (var detail in model.Detail)
{
if (detail.ExampleIds != null)
{
detail.Examples = new List <ExampleModel>();
foreach (var exampleId in detail.ExampleIds)
{
var example = db.JaViExamples.Find(exampleId);
if (example != null)
{
detail.Examples.Add(ExampleModel.Create(example));
}
}
}
}
model.IsLoadFull = true;
}
}
}
public override List <JaenModel> SearchEndWith(string key)
{
using (var db = new JazeDatabaseContext())
{
return(db.JaEns.Where(o => o.Word.EndsWith(key) || o.Kana.EndsWith(key)).ToList().Select(entity => JaenModel.Create(entity)).ToList());
}
}
public override List <VijaModel> GetAll()
{
using (var db = new JazeDatabaseContext())
{
return(db.Vijas.ToList().Select(entity => VijaModel.Create(entity)).ToList());
}
}
static KanjiPartService()
{
using (var db = new JazeDatabaseContext())
{
_maxPartId = db.Parts.Max(entity => entity.Id);
_maxKanjiId = db.Kanjis.Max(entity => entity.Id);
_parts = new PartModel[_maxPartId + 1];
_kanjis = new KanjiModel[_maxKanjiId + 1];
_kanjiParts = new bool[_maxKanjiId + 1, _maxPartId + 1];
var parts = db.Parts.ToList().Select(PartModel.Create);
foreach (var part in parts)
{
_parts[part.Id] = part;
}
var kanjis = db.Kanjis.ToList().Select(KanjiModel.Create);
foreach (var kanji in kanjis)
{
_kanjis[kanji.Id] = kanji;
}
foreach (var kanjiPart in db.KanjiParts)
{
_kanjiParts[kanjiPart.KanjiId, kanjiPart.PartId] = true;
}
}
}
public override List <JaviModel> GetAll()
{
using (var db = new JazeDatabaseContext())
{
return(db.JaVis.ToList().Select(o => JaviModel.Create(o)).ToList());
}
}
public override List <KanjiModel> SearchContain(string key)
{
using (var db = new JazeDatabaseContext())
{
return(db.Kanjis.Where(kanji => kanji.HanViet.Contains(key)).ToList().Select(entity => KanjiModel.Create(entity)).ToList());
}
}
public override List <VijaModel> SearchContain(string key)
{
using (var db = new JazeDatabaseContext())
{
return(db.Vijas.Where(o => o.Word.Contains(key)).ToList().Select(entity => VijaModel.Create(entity)).ToList());
}
}
public override void LoadFull(VijaModel model)
{
if (!model.IsLoadFull)
{
using (var db = new JazeDatabaseContext())
{
model.Means = JsonConvert.DeserializeObject <List <WordMean> >(model.MeanText);
foreach (var mean in model.Means)
{
if (mean.ExampleIds != null)
{
mean.Examples = new List <ExampleModel>();
foreach (var exampleId in mean.ExampleIds)
{
var example = db.JaViExamples.Find(exampleId);
if (example != null)
{
mean.Examples.Add(ExampleModel.Create(example));
}
}
}
}
model.IsLoadFull = true;
}
}
}
public override List <GrammarModel> SearchExact(string key)
{
using (var db = new JazeDatabaseContext())
{
return(db.Grammars.Where(o => o.Struct == key || o.Meaning == key).ToList().Select(o => GrammarModel.Create(o))
.ToList());
}
}
public override List <HanVietModel> SearchStartWith(string key)
{
using (var db = new JazeDatabaseContext())
{
return(db.HanViets.Where(hv => hv.Word.StartsWith(key) || hv.Reading.StartsWith(key))
.ToList().Select(hv => HanVietModel.Create(hv)).ToList());
}
}
public override void LoadFull(HanVietModel model)
{
using (var db = new JazeDatabaseContext())
{
model.Content = db.HanViets.Find(model.Id)?.Content;
model.IsLoadFull = true;
}
}
private List <KanjiModel> LoadKanji(List <char> arr)
{
using (var db = new JazeDatabaseContext())
{
return(arr.Select(c => "" + c).Select(s => db.Kanjis.FirstOrDefault(kanji => kanji.Word == s))
.Select(KanjiModel.Create).ToList());
}
}
public override List <GrammarModel> SearchContain(string key)
{
using (var db = new JazeDatabaseContext())
{
var hirakey = StringUtil.ConvertRomaji2Hiragana(key);
return(db.Grammars.Where(o => o.Struct.Contains(hirakey) || o.Meaning.Contains(key)).ToList().Select(o => GrammarModel.Create(o))
.ToList());
}
}
public override List <HanVietModel> GetAll()
{
using (var db = new JazeDatabaseContext())
{
//return db.HanViets.ToList().Select(hv => HanVietModel.Create(hv)).ToList();
return(db.HanViets.Select(hv => new HanVietModel {
Id = hv.Id, Word = hv.Word, Reading = hv.Reading
}).ToList());
}
}
//public static IEnumerable<HanViet> Search(SearchArgs searchArgs)
//{
// var key = searchArgs.SearchKey;
// if (string.IsNullOrWhiteSpace(key))
// {
// //return GetAll();
// return null;
// }
// switch (searchArgs.Option)
// {
// case SearchOption.Exact:
// return SearchExact(key);
// case SearchOption.StartWith:
// return SearchStartWith(key);
// case SearchOption.EndWith:
// return SearchEndWith(key);
// case SearchOption.Contain:
// return SearchContain(key);
// default:
// throw new ArgumentOutOfRangeException();
// }
//}
//private static IEnumerable<HanViet> SearchContain(string key)
//{
// var context = JazeDatabaseContext.Context;
// return context.HanViets.Where(hv => hv.Word.Contains(key) || hv.Reading.Contains(key)).ToArray();
//}
//private static IEnumerable<HanViet> SearchEndWith(string key)
//{
// var context = JazeDatabaseContext.Context;
// return context.HanViets.Where(hv => hv.Word.EndsWith(key) || hv.Reading.EndsWith(key)).ToArray();
//}
//private static IEnumerable<HanViet> SearchStartWith(string key)
//{
// var context = JazeDatabaseContext.Context;
// return context.HanViets.Where(hv => hv.Word.StartsWith(key) || hv.Reading.StartsWith(key)).ToArray();
//}
//private static IEnumerable<HanViet> SearchExact(string key)
//{
// var context = JazeDatabaseContext.Context;
// //at stat
// var keyStart = key + ", ";
// //at middle
// var keyMiddle = ", " + key + ",";
// //at end
// var keyEnd = ", " + key;
// return context.HanViets.Where(hv => hv.Word == key || hv.Reading == key || hv.Reading.StartsWith(keyStart) || hv.Reading.Contains(keyMiddle) || hv.Reading.EndsWith(keyEnd)).ToArray();
//}
//private static IEnumerable<HanViet> GetAll()
//{
// var context = JazeDatabaseContext.Context;
// return context.HanViets.ToArray();
//}
public override HanVietModel Get(int id)
{
using (var db = new JazeDatabaseContext())
{
var entity = db.HanViets.Find(id);
if (entity != null)
{
return(HanVietModel.Create(entity));
}
return(null);
}
}
public override List <HanVietModel> SearchExact(string key)
{
using (var db = new JazeDatabaseContext())
{
//at stat
var keyStart = key + ", ";
//at middle
var keyMiddle = ", " + key + ",";
//at end
var keyEnd = ", " + key;
return(db.HanViets.Where(hv => hv.Word == key || hv.Reading == key || hv.Reading.StartsWith(keyStart) || hv.Reading.Contains(keyMiddle) || hv.Reading.EndsWith(keyEnd))
.ToList().Select(hv => HanVietModel.Create(hv)).ToList());
}
}
public override List <JaviModel> SearchContain(string key)
{
using (var db = new JazeDatabaseContext())
{
if (StringUtil.IsContainKanji(key))
{
return(db.JaVis.Where(o => o.Word.Contains(key)).ToList().Select(o => JaviModel.Create(o)).ToList());
}
else
{
return(db.JaVis.Where(o => o.Word.Contains(key) || o.Kana.Contains(key)).ToList().Select(o => JaviModel.Create(o)).ToList());
}
}
}
public override List <JaenModel> SearchExact(string key)
{
using (var db = new JazeDatabaseContext())
{
//at stat
var keyStart = key + " ";
//at middle
var keyMiddle = " " + key + " ";
//at end
var keyEnd = " " + key;
return(db.JaEns.Where(o => o.Word == key || o.Kana == key || o.Kana.StartsWith(keyStart) || o.Kana.Contains(keyMiddle) || o.Kana.EndsWith(keyEnd))
.ToList().Select(entity => JaenModel.Create(entity)).ToList());
}
}
public override void LoadFull(JaviModel model)
{
if (!model.IsLoadFull)
{
using (var db = new JazeDatabaseContext())
{
model.Means = JsonConvert.DeserializeObject <List <WordMean> >(model.MeanText);
foreach (var mean in model.Means)
{
if (mean.ExampleIds != null)
{
mean.Examples = new List <ExampleModel>();
foreach (var exampleId in mean.ExampleIds)
{
var example = db.JaViExamples.Find(exampleId);
if (example != null)
{
mean.Examples.Add(ExampleModel.Create(example));
}
}
}
}
//fetch kanji in word
model.Kanjis = new List <KanjiModel>();
var kanjis = StringUtil.FilterCharsInString(model.Word, CharSet.Kanji);
foreach (var c in kanjis)
{
var kanji = c.ToString();
var kanjiEntity = db.Kanjis.FirstOrDefault(e => e.Word == kanji);
if (kanjiEntity != null)
{
model.Kanjis.Add(KanjiModel.Create(kanjiEntity));
}
else
{
model.Kanjis.Add(new KanjiModel {
Word = kanji
});
}
}
model.IsLoadFull = true;
}
}
}
public override List <KanjiModel> SearchExact(string key)
{
using (var db = new JazeDatabaseContext())
{
if (StringUtil.IsVietnameseWord(key))
{
//at stat
var keyStart = key + ",";
//at middle
var keyMiddle = "," + key + ",";
//at end
var keyEnd = "," + key;
return(db.Kanjis.Where(kanji => kanji.HanViet == key || kanji.HanViet.StartsWith(keyStart) || kanji.HanViet.Contains(keyMiddle) || kanji.HanViet.EndsWith(keyEnd)).ToList().Select(entity => KanjiModel.Create(entity)).ToList());
}
else
{
return(db.Kanjis.Where(kanji => kanji.Word == key).ToList().Select(entity => KanjiModel.Create(entity)).ToList());
}
}
}
public override void LoadFull(KanjiModel model)
{
if (!model.IsLoadFull)
{
using (var db = new JazeDatabaseContext())
{
var kanjiEntity = db.Kanjis.Find(model.Id);
if (kanjiEntity != null)
{
model.Copy(kanjiEntity);
model.Radical = RadicalModel.Create(kanjiEntity.Radical);
model.Parts = kanjiEntity.KanjiParts.Select(entity => entity.Part).ToList().Select(PartModel.Create).ToList();
model.JaviModels = new List <JaviModel>();
var kuns = model.Kunyomi.Replace(" ", "").Split('、');
foreach (var kun in kuns)
{
if (kun.Contains('-'))
{
continue;
}
string kana = kun.Replace(".", "");
var arr = kun.Split('.');
var word = model.Word;
if (arr.Length == 2)
{
word = model.Word + arr[1];
}
var javi = db.JaVis.FirstOrDefault(entity => entity.Word == word && entity.Kana == kana);
if (javi != null)
{
var javiModel = JaviModel.Create(javi);
javiModel.Means = JsonConvert.DeserializeObject <List <WordMean> >(javiModel.MeanText);
model.JaviModels.Add(javiModel);
}
}
}
model.IsLoadFull = true;
}
}
}
private List <JaviModel> SearchHanViet(SearchArgs searchArgs)
{
if (_isLoadingCache)
{
return(new List <JaviModel>());
}
var key = searchArgs.SearchKey;
var arr = key.Split(' ');
var kanjiOfWord = arr.Length;
var result = new List <JaviModel>();
using (var db = new JazeDatabaseContext())
{
foreach (var simpleJavi in _javiHanVietCaches)
{
if (simpleJavi.HanViet.Count == kanjiOfWord)
{
bool flag = true;
for (int i = 0; i < kanjiOfWord; i++)
{
if (simpleJavi.HanViet2[i].All(hv => hv != arr[i]))
{
flag = false;
break;
}
}
if (flag)
{
var javi = db.JaVis.Find(simpleJavi.DbId);
if (javi != null)
{
result.Add(JaviModel.Create(javi));
}
}
}
}
return(result);
}
}
private static void LoadCaches()
{
_isLoadingCache = true;
_javiHanVietCaches = new List <JaviHanVietCache>();
string cacheFolder = System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Caches");
var cachePath = System.IO.Path.Combine(cacheFolder, HanvietCacheFile);
System.IO.Directory.CreateDirectory(cacheFolder);
if (System.IO.File.Exists(cachePath))
{
//read from created cache file
foreach (var line in System.IO.File.ReadAllLines(cachePath))
{
if (!string.IsNullOrWhiteSpace(line))
{
try
{
var arr = line.Split('\t');
var simpleJavi = new JaviHanVietCache();
simpleJavi.DbId = int.Parse(arr[0]);
simpleJavi.HanViet = new List <string>();
for (int i = 1; i < arr.Length; i++)
{
simpleJavi.HanViet.Add(arr[i]);
}
_javiHanVietCaches.Add(simpleJavi);
}
catch (Exception)
{
// ignored
}
}
}
}
else
{
//read from database
using (var db = new JazeDatabaseContext())
{
var hvDic = db.Kanjis.ToDictionary(kanji => kanji.Word, kanji => kanji.HanViet);
var javis = db.JaVis.Select(javi => new { javi.Id, javi.Word }).ToList();
foreach (var javi in javis)
{
var simpleJavi = new JaviHanVietCache();
simpleJavi.DbId = javi.Id;
simpleJavi.HanViet = new List <string>();
foreach (var c in javi.Word.ToCharArray())
{
var key = c.ToString();
if (hvDic.ContainsKey(key))
{
simpleJavi.HanViet.Add(hvDic[key]);
}
}
_javiHanVietCaches.Add(simpleJavi);
}
//save to cache file
var writer = System.IO.File.AppendText(cachePath);
foreach (var simpleJavi in _javiHanVietCaches)
{
if (simpleJavi.HanViet.Count > 0)
{
writer.Write("{0}\t", simpleJavi.DbId);
var hvCount = simpleJavi.HanViet.Count;
for (int i = 0; i < hvCount - 1; i++)
{
writer.Write("{0}\t", simpleJavi.HanViet[i]);
}
writer.WriteLine("{0}", simpleJavi.HanViet[hvCount - 1]);
}
}
writer.Close();
}
}
foreach (var simpleJavi in _javiHanVietCaches)
{
simpleJavi.HanViet2 = new List <List <string> >();
foreach (var s in simpleJavi.HanViet)
{
simpleJavi.HanViet2.Add(s.Split(',').ToList());
}
}
_isLoadingCache = false;
}
