// Import data
public int ImportData(DataTable source)
{
int result = 0;
if (source == null)
{
//file sai cau truc
return(-1);
}
else
{
for (int i = 0; i < source.Rows.Count; i++)
{
AddTermViewModel termOrSynset = new AddTermViewModel();
var term = source.Rows[i]["Thuật ngữ"].ToString();
var def = source.Rows[i]["Giải thích"].ToString();
if (!String.IsNullOrWhiteSpace(term) && !String.IsNullOrWhiteSpace(def))
{
termOrSynset.HeadWord = term;
termOrSynset.Catagory = source.Rows[i]["Loại từ"].ToString();
termOrSynset.Def = def;
termOrSynset.Exa = source.Rows[i]["Ví dụ"].ToString();
termOrSynset.Synonyms = source.Rows[i]["Từ đồng nghĩa"].ToString();
if (AddNewTermOrSynset(termOrSynset) > 0)
{
result++;
}
}
}
}
return(result);
}
public ActionResult Edit(AddTermViewModel editedSynset, int synsetId)
{
EntriesModel entriesModel = new EntriesModel();
int result = entriesModel.EditSynsetBySynsetId(editedSynset, synsetId);
ViewBag.Result = result;
return(RedirectToAction("Edit", new { synsetId = synsetId, headWord = editedSynset.HeadWord, r = "success" }));
//return View();
}
public ActionResult Edit(int?synsetId, string headWord)
{
EntriesModel entriesModel = new EntriesModel();
var synsetId_ = synsetId ?? -1;
AddTermViewModel editSynset = entriesModel.ViewEditSynset(synsetId_, headWord);
ViewBag.ListAnotherSynset = entriesModel.GetAnotherSynsetOfTerm(headWord, synsetId_);
ViewBag.ListSynonyms = entriesModel.GetSynonyms(synsetId_, headWord);
return(View(editSynset));
}
public ActionResult Add(AddTermViewModel term)
{
try
{
EntriesModel entriesModel = new EntriesModel();
entriesModel.AddNewTermOrSynset(term);
ViewBag.Success = "Thêm thuật ngữ thành công!";
}
catch
{
ViewBag.Fail = "Thêm thuật ngữ không thành công!";
}
return(View());
}
// Edit synset by synsetId
public int EditSynsetBySynsetId(AddTermViewModel editedSynset, int synsetId)
{
Synset synset = context.Synsets.Find(synsetId);
synset.Category = editedSynset.Catagory;
synset.Def = editedSynset.Def;
synset.Exa = editedSynset.Exa;
//delete all synonym relation
synset.WordIndexes.Clear();
synset.WordIndexes.Add(context.WordIndexes.Find(editedSynset.HeadWord));
// If synset has synonym(s)
if (!String.IsNullOrWhiteSpace(editedSynset.Synonyms))
{
string[] synonyms = editedSynset.Synonyms.Split(',');
foreach (string headWord in synonyms)
{
// Check headWord exist in database
WordIndex wordIndex = context.WordIndexes.Find(headWord);
if (wordIndex != null)
{
//synset.WordIndexes.Add(wordIndex);
}
else
{
//entry
wordIndex = new WordIndex();
wordIndex.HeadWord = headWord;
string[] word = headWord.Split(' ');
if (word.Count() > 1)
{
wordIndex.WordType = "c";
}
else
{
wordIndex.WordType = "s";
}
}
synset.WordIndexes.Add(wordIndex);
}
}
context.Entry(synset).State = EntityState.Modified;
return(context.SaveChanges());
}
public ActionResult AddTerm(AddTermViewModel viewModel)
{
var userId = User.Identity.GetUserId();
var currentDoctor = _context.Doctors
.SingleOrDefault(x => x.AccountId == userId);
var term = new Term
{
DateTimeOfTerm = viewModel.DateTimeOfTerm,
Doctor = currentDoctor
};
_context.Terms.Add(term);
_context.SaveChanges();
return(RedirectToAction("ShowTerm", "Doctor"));
}
public virtual async Task <ActionResult> Create(AddTermViewModel viewModel)
{
if (ModelState.IsValid)
{
try
{
var t = _TermService.GetByTermName(viewModel.Name);
if (t != null)
{
ModelState.AddModelError("Name", "This Term Name Is Already Exist In Database");
return(View(viewModel));
}
var obj = new Term
{
Name = viewModel.Name,
StartDate = viewModel.StartDate,
EndDate = viewModel.EndDate
};
_TermService.Insert(obj);
await _unitOfWork.SaveChangesAsync();
CacheManager.InvalidateChildActionsCache();
return(RedirectToAction("Index", "Term"));
}
catch (System.Data.Entity.Validation.DbEntityValidationException e)
{
string s = "";
foreach (var eve in e.EntityValidationErrors)
{
s += String.Format("Entity of type \"{0}\" in state \"{1}\" has the following validation errors:",
eve.Entry.Entity.GetType().Name, eve.Entry.State);
foreach (var ve in eve.ValidationErrors)
{
s += String.Format("- Property: \"{0}\", Error: \"{1}\"",
ve.PropertyName, ve.ErrorMessage);
}
}
ViewBag.err = s;
}
}
return(View(viewModel));
}
// View edit synset
public AddTermViewModel ViewEditSynset(int synsetId, string headWord)
{
AddTermViewModel editSynset = new AddTermViewModel();
Synset synset;
if (synsetId == -1)
{
synset = context.WordIndexes.Find(headWord).Synsets.FirstOrDefault();
}
else
{
synset = context.Synsets.Find(synsetId);
}
editSynset.Catagory = synset.Category;
editSynset.Def = synset.Def;
editSynset.Exa = synset.Exa;
editSynset.HeadWord = headWord;
return(editSynset);
}
public ActionResult Add(AddTermViewModel model)
{
if (ModelState.IsValid)
{
using (var db = new DBContext())
{
if (db.Terms.FirstOrDefault(x => x.TermName.ToLower() == model.TermName.ToLower()) == null)
{
FundamentalArea area = db.FundamentalAreas
.FirstOrDefault(x => x.NameFundamentalArea.ToLower() == model.FundamentalArea.ToLower());
if (area == null)
{
area = new FundamentalArea()
{
NameFundamentalArea = model.FundamentalArea
};
db.FundamentalAreas.Add(area);
db.SaveChanges();
}
var term = new Term()
{
TermName = model.TermName,
Addition = model.Addition,
IdFundamentalArea = area.IdFundamentalArea
};
Mapper.Initialize(cfg =>
{
cfg.CreateMap <Definition, DefinitionViewModel>()
.ForMember("TermName", opt => opt.MapFrom(c => c.Term.TermName))
.ForMember("Freq", opt => opt.MapFrom(c => c.Projects.Count));
cfg.CreateMap <DefinitionViewModel, Definition>();
});
db.Terms.Add(term);
db.SaveChanges();
var definition = new Definition()
{
IdTerm = term.IdTerm,
Description = model.Definition,
URL = model.URL,
URLTitle = model.URLTitle,
UserId = WebSecurity.CurrentUserId
};
db.Definitions.Add(definition);
db.SaveChanges();
return(View("Index", term.IdTerm));
}
else
{
ModelState.AddModelError("TermName", "Данный термин уже добавлен");
}
}
}
using (var db = new DBContext())
{
ViewData["Areas"] = db.FundamentalAreas.Select(x => x.NameFundamentalArea).ToList();
}
if (Request.IsAjaxRequest())
{
return(PartialView("AddPartical", new AddTermViewModel()));
}
return(View("IndexAdd", new AddTermViewModel()));
}
public AddTermView()
{
InitializeComponent();
BindingContext = new AddTermViewModel(Navigation);
}
// Add new term or new synset
public int AddNewTermOrSynset(AddTermViewModel term)
{
// Check isExist term
WordIndex checkTerm = context.WordIndexes.Find(term.HeadWord);
if (checkTerm == null)
{
// Entry
checkTerm = new WordIndex();
checkTerm.HeadWord = term.HeadWord;
string[] word = term.HeadWord.Split(' ');
if (word.Count() > 1)
{
checkTerm.WordType = "c";
}
else
{
checkTerm.WordType = "s";
}
}
else
{
// Check duplicate content
//var checkDup = checkTerm.Synsets.Contains(context.Synsets.Where(x => x.Def.Contains(term.Def)).FirstOrDefault());
bool checkDup2 = false;
foreach (var item in checkTerm.Synsets)
{
if (item.Def.Equals(term.Def))
{
checkDup2 = true;
break;
}
}
if (checkDup2)
{
return(0);
}
}
// Synset
Synset synset = new Synset();
synset.Category = term.Catagory;
synset.Def = term.Def;
synset.Exa = term.Exa;
// If synset has synonym(s)
if (!String.IsNullOrWhiteSpace(term.Synonyms))
{
string[] synonyms = term.Synonyms.Split(',');
foreach (string headWord in synonyms)
{
// Check headWord exist in database
WordIndex wordIndex = context.WordIndexes.Find(headWord);
if (wordIndex != null)
{
//synset.WordIndexes.Add(wordIndex);
}
else
{
//entry
wordIndex = new WordIndex();
wordIndex.HeadWord = headWord;
string[] words = headWord.Split(' ');
if (words.Count() > 1)
{
wordIndex.WordType = "c";
}
else
{
wordIndex.WordType = "s";
}
}
synset.WordIndexes.Add(wordIndex);
}
}
//
synset.WordIndexes.Add(checkTerm);
context.Synsets.Add(synset);
int result = context.SaveChanges();
return(result);
}
