public ActionResult Create(GlossaryViewModel model)
{
if (ModelState.IsValid)
{
var glossary = db.Glossaries.FirstOrDefault(
g => (g.term == model.term) && (g.definition == model.definition)
);
if (glossary == null)
{
Glossary g = new Glossary();
g.term = model.term;
g.definition = model.definition;
g.createUser = WebSecurity.CurrentUserId;
g.companyID = (int)db.Users.Find(g.createUser).companyID;
db.Glossaries.Add(g);
if (model.selectedRules != null)
{
foreach (int ruleId in model.selectedRules)
{
SGC_MVC.Models.Rule r = db.Rules.Find(ruleId);
g.Rules.Add(r);
}
}
db.SaveChanges();
return(RedirectToAction("Index"));
}
}
model.allRules = Helper.GetRulesSelect(db);
return(View(model));
}
public ActionResult Edit(GlossaryViewModel model)
{
if (ModelState.IsValid)
{
Glossary g = db.Glossaries.Include(gs => gs.Rules)
.FirstOrDefault(gs => gs.ID == model.glossaryID);
if (g.Rules != null)
{
g.Rules.Clear();
db.SaveChanges();
}
if (model.selectedRules != null)
{
foreach (int ruleId in model.selectedRules)
{
SGC_MVC.Models.Rule r = db.Rules.Find(ruleId);
g.Rules.Add(r);
db.SaveChanges();
}
}
g.term = model.term;
g.definition = model.definition;
g.updateDate = DateTime.Now;
db.Entry(g).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(model));
}
public IActionResult Create(int id, int glossarysId, int enId)
{
Glossary glossary = _db.Glossaries.FirstOrDefault(g => g.Id == id);
if (glossary != null)
{
if (glossary.Active)
{
return(View(new GlossaryViewModel()
{
Id = id, Name = glossary.Name, Action = "AddInterpretation"
}));
}
if (!glossary.Active)
{
return(View(new GlossaryViewModel()
{
Id = id, Name = glossary.Name, GlossarysId = enId
}));
}
}
GlossaryViewModel model = new GlossaryViewModel();
if (glossarysId != 0)
{
model.GlossarysId = glossarysId;
model.Language = Language.en;
model.Glossary = _db.Glossaries.FirstOrDefault(g => g.Id == glossarysId);
}
return(View(model));
}
public async Task <IActionResult> Edit(GlossaryViewModel model)
{
if (ModelState.IsValid)
{
Glossary glossary = await _db.Glossaries.FirstOrDefaultAsync(g => g.Id == model.Id);
if (glossary != null && model.Name != glossary.Name)
{
glossary.Name = model.Name;
_db.Glossaries.Update(glossary);
await _db.SaveChangesAsync();
}
Interpretation interpretation =
await _db.Interpretations.FirstOrDefaultAsync(i => i.Id == model.InterpretationId);
if (interpretation != null && model.Description != null &&
(interpretation.Description != model.Description ||
interpretation.Abbreviation != model.Abbreviation ||
interpretation.Source != model.Source))
{
interpretation.Description = model.Description;
interpretation.Abbreviation = model.Abbreviation;
interpretation.Source = model.Source;
_db.Interpretations.Update(interpretation);
await _db.SaveChangesAsync();
}
return(RedirectToAction("Preview", new { id = glossary.Id }));
}
return(View(model));
}
public ActionResult Create()
{
GlossaryViewModel model = new GlossaryViewModel();
model.allRules = Helper.GetRulesSelect(db);
return(View(model));
}
public IActionResult Create(GlossaryViewModel model)
{
if (ModelState.IsValid)
{
Interpretation interpretation;
Glossary glossary = _db.Glossaries.FirstOrDefault(g => g.Id == model.Id);
if (glossary != null)
{
glossary.Active = true;
glossary.Name = model.Name;
_db.Glossaries.Update(glossary);
_db.SaveChanges();
interpretation = new Interpretation()
{
GlossaryId = glossary.Id,
Description = model.Description,
Abbreviation = model.Abbreviation,
Source = model.Source
};
_db.Interpretations.Add(interpretation);
_db.SaveChanges();
return(RedirectToAction("Preview", new { id = glossary.Id }));
}
glossary = new Glossary()
{
Name = model.Name,
Language = (Models.Language)model.Language
};
_db.Glossaries.Add(glossary);
_db.SaveChanges();
if (model.GlossarysId != null)
{
Glossary glossary1 = _db.Glossaries.FirstOrDefault(g => g.Id == model.GlossarysId);
glossary1.GlossarysId = glossary.Id;
_db.Glossaries.Update(glossary1);
_db.SaveChanges();
}
interpretation = new Interpretation()
{
GlossaryId = glossary.Id,
Description = model.Description,
Abbreviation = model.Abbreviation,
Source = model.Source
};
_db.Interpretations.Add(interpretation);
_db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(model));
}
public void GlossaryViewModel_ItemsUpdated()
{
Mock <IGlossaryRepository> mock = new Mock <IGlossaryRepository>();
mock.Setup(o => o.Items).Returns(new List <Glossary>()
{
new Glossary()
{
Definition = "test1", Term = "Test1"
},
new Glossary()
{
Definition = "test2", Term = "Test2"
}
});
GlossaryViewModel gvm = new GlossaryViewModel(mock.Object);
Assert.IsTrue(gvm.Items.Count == 2);
}
public ActionResult Edit(int id = 0)
{
var glossary = db.Glossaries.Include(g => g.Rules)
.FirstOrDefault(g => g.ID == id);
if (glossary == null)
{
return(HttpNotFound());
}
GlossaryViewModel model = new GlossaryViewModel();
var selectedRules = from r in glossary.Rules
select r.ID;
model.selectedRules = selectedRules.ToArray();
model.allRules = Helper.GetRulesSelect(db);
model.term = glossary.term;
model.definition = glossary.definition;
model.glossaryID = glossary.ID;
return(View(model));
}
public MainWindow(GlossaryViewModel glossaryViewModel)
{
_glossaryViewModel = glossaryViewModel;
DataContext = _glossaryViewModel;
InitializeComponent();
}
