private void AddNew(object sender, EventArgs e)
{
if (Pivot.SelectedItem == TermsTab)
{
var term = new TermViewModel();
set.Terms.Add(term);
Dispatcher.BeginInvoke(delegate {
Debug.Assert(TermList.ItemContainerGenerator != null, "TermList.ItemContainerGenerator != null");
var container = TermList.ItemContainerGenerator.ContainerFromItem(term) as FrameworkElement;
FocusTextBox(container);
});
}
else if (Pivot.SelectedItem == SubjectsTab)
{
var subject = new SubjectViewModel();
set.Subjects.Insert(0, subject);
Dispatcher.BeginInvoke(delegate {
Debug.Assert(SubjectList.ItemContainerGenerator != null, "SubjectList.ItemContainerGenerator != null");
var container = SubjectList.ItemContainerGenerator.ContainerFromItem(subject) as FrameworkElement;
FocusTextBox(container);
});
}
}
public ActionResult Create(TermViewModel termVM)
{
termService.Create(termVM);
ViewBag.Message = "Term added succesfully";
return(View());
}
public override async Task OnNavigatedToAsync(object parameter, NavigationMode mode, IDictionary <string, object> suspensionState)
{
Set = null;
if (suspensionState.ContainsKey(nameof(Set)))
{
Set = suspensionState[nameof(Set)] as Set;
}
if (parameter != null)
{
Set = parameter as Set;
}
if (_settingsService.AuthenticatedUser.Username == Set.CreatedBy)
{
Editable = true;
}
Title = Set.Title;
TermCount = Set.TermCount;
CreatedBy = Set.CreatedBy;
foreach (var term in Set.Terms)
{
var tvm = TermViewModel.Create(term);
Terms.Add(tvm);
AllTerms.Add(tvm);
}
await Task.CompletedTask;
}
private async Task <bool> Upsert(int?TermId, TermViewModel model)
{
if (ModelState.IsValid)
{
// check the current term
var helper = (TermId.HasValue ? GetHelper(TermId.Value) : new TermHelper()
{
ServiceUserId = GetUserId()
});
if (model.IsCurrentTerm && model.TermId <= 0)
{
var currentTerm = context.Terms.ToList().FirstOrDefault(m => m.IsCurrentTerm);
if (currentTerm != null)
{
if (currentTerm.EndDate > model.StartDate)
{
ShowError(string.Format("You cannot set new current term starting {0} since Current term ends on {1} ", model.StartDate.ToString("ddd, dd MMM yyyy"), currentTerm.EndDate.ToString("ddd, dd MMM yyyy")));
return(false);
}
if (currentTerm.EndDate > DateTime.Today)
{
ShowError(string.Format("You cannot set new current term unless the {0} has ended. ", currentTerm.GetTerm()));
return(false);
}
helper.UpdateStudentsOldDebt(currentTerm);
currentTerm.IsCurrentTerm = false;
context.Entry(currentTerm).State = System.Data.Entity.EntityState.Modified;
}
}
if (model.EndDate < UgandaDateTime.DateNow().Date)
{
ShowError("Term End date seems to have passed according to System Calendar.");
return(false);
}
var upsert = await helper.UpsertTerm(UpsertMode.Admin, model);
if (upsert.i_RecordId() > 0)
{
ShowSuccess(upsert.ErrorMsg);
return(true);
}
else
{
ShowError(upsert.ErrorMsg);
}
}
//ParseDefaults(model);
return(false);
}
public ActionResult CreateTerm(TermViewModel model)
{
using (var context = new DataContext())
{
context.Terms.Add(model.ToDbModel());
context.SaveChanges();
return(View());
}
}
private void DefinitionAsQuestion(TermViewModel term)
{
QAndAs.Add(new QAndA()
{
Answer = term.TermText,
Question = term.Definition,
Id = term.Id
});
}
async void Save_Clicked(object sender, EventArgs e)
{
_viewModel = (TermViewModel)BindingContext;
var successful = _viewModel.Save();
if (successful)
{
await Navigation.PopAsync();
}
}
public async Task <TermViewModel> ViewTerm(long id)
{
using (var session = _db.GetSession())
{
var result = await session.RunAsync(
string.Format(_transactions.GetTermView(), id)
);
var record = await result.SingleAsync();
Term term = null;
if (record[0] is INode node)
{
term = new Term(node);
}
else
{
return(null);
}
var themes = (record[1] as IEnumerable <object>)?
.Select(v => new Theme(v as INode))
.ToList();
var relatedTerms = (record[2] as IEnumerable <object>)?
.Select(v => new Term(v as INode))
.ToList();
var response = new TermViewModel()
{
Id = term.Id,
Name = term.Name,
Source = term.Source,
//Description = term.Description,
};
response.Themes = themes?.Select(v => new IdValueModel()
{
Id = v.Id,
Value = v.Name
}).ToList();
response.RelatedTerms = relatedTerms?.Select(v => new TermSimpleModel()
{
Id = v.Id,
Name = v.Name,
Description = v.Description,
}).ToList();
response.Description = await IndexDescription(term, relatedTerms);
return(response);
}
}
private async void Return()
{
var viewModel = new TermViewModel();
var terms = App.Database.GetTermsAsync();
var page = new TermPage(_term[0])
{
BindingContext = viewModel
};
await this.Navigation.PushAsync(page, true);
}
protected override bool OnBackButtonPressed()
{
var pageViewModel = new TermViewModel();
var page = new TermPage(_term[0])
{
BindingContext = pageViewModel
};
this.Navigation.PushAsync(page, true);
return(true);
}
public App()
{
InitializeComponent();
var viewModel = new TermViewModel();
var page = new TermPage()
{
BindingContext = viewModel
};
MainPage = new NavigationPage(page);
}
public Term Update(TermViewModel termVM)
{
var term = _unitOfWork.TermRepository.GetById(termVM.TermID);
term.TermID = termVM.TermID;
term.Type = termVM.Type;
term.Content = termVM.Content;
_unitOfWork.TermRepository.Update(term);
_unitOfWork.Save();
return term;
}
public Term Create(TermViewModel termVM)
{
var term = new Term
{
Type = termVM.Type,
Content = termVM.Content
};
_unitOfWork.TermRepository.Insert(term);
_unitOfWork.Save();
return term;
}
public async Task <ActionResult> Store([FromBody] TermViewModel model)
{
await ValidateRequestAsync(model);
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var term = model.MapEntity(_mapper, CurrentUserId);
term = await _termsService.CreateAsync(term);
return(Ok(term.Id));
}
public async Task <IActionResult> Create()
{
var yearOptions = await this.GetTermYearOptions();
var termModel = new TermViewModel
{
termYearId = Convert.ToInt16(yearOptions.FirstOrDefault().value)
};
var model = new TermEditForm {
term = termModel, yearOptions = yearOptions, order = 1
};
return(Ok(model));
}
public async Task <ActionResult> Create(TermViewModel model)
{
if (!IsRoutingOK(null))
{
return(RedirectOnError());
}
bool success = await Upsert(null, model);
if (success)
{
return(RedirectOnError());
}
return(View("New", model));
}
public TermPage()
{
InitializeComponent();
viewModel = new TermViewModel();
BindingContext = viewModel;
//Items = new ObservableCollection<string>
//{
// "Item 1",
// "Item 2",
// "Item 3",
// "Item 4",
// "Item 5"
//};
//MyListView.ItemsSource = Items;
}
public async Task <ActionResult> Update(int TermId, TermViewModel model)
{
if (!IsRoutingOK(TermId))
{
return(RedirectOnError());
}
bool success = await Upsert(TermId, model);
if (success)
{
return(RedirectOnSuccess(TermId));
}
// If we got this far, an error occurred
return(View("New", model));
}
public static TermViewModel MapTermViewModel(Term term)
{
var model = new TermViewModel
{
id = term.Id,
active = term.Active,
title = term.Title,
number = term.Number,
termYearId = term.TermYearId,
};
if (term.TermYear != null)
{
model.termYear = MapTermYearViewModel(term.TermYear);
}
return(model);
}
public ActionResult TermUpdate(TermViewModel editTerm)
{
var message = new ActionMessage();
var tempTerm = db.Term.Find(editTerm.Id);
if (tempTerm != null)
{
tempTerm.Color = editTerm.Color;
tempTerm.NoDragClass = editTerm.NoDragClass == "1";
tempTerm.NoChildrenClass = editTerm.NoChildrenClass == "1";
tempTerm.Name = editTerm.Name;
db.Entry(tempTerm).State = EntityState.Modified;
db.SaveChanges();
message.IsSuccess = true;
return(Json(message, JsonRequestBehavior.AllowGet));
}
return(Json(message, JsonRequestBehavior.AllowGet));
}
//private bool UpdateStudentClass(Term Term)
//{
// var helper = new TermHelper(Term);
// helper.ServiceUserId = GetUserId();
// return helper;
//}
private TermViewModel GetTermModel(int?TermId)
{
TermViewModel model;
if (TermId.HasValue)
{
var Term = GetTerm(TermId.Value);
model = new TermViewModel(Term);
}
else
{
model = new TermViewModel();
}
// pass needed lists
//ParseDefaults(model);
return(model);
}
public async Task <IActionResult> Patch([FromBody] TermViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(string.Join(",", ModelState.Values.SelectMany(v => v.Errors.Select(e => e.ErrorMessage)))));
}
try
{
// Update
await _termsRepository.UpdateTerm(_mapper.Map <Term>(model));
// Return
return(Json(model));
}
catch (Exception e)
{
_logger.LogError(e, "Update failed for term. {User} {Term}", _userManager.GetUserId(User), model.TermId);
return(StatusCode(500, $"Update failed for term. Please try again. {e.Message}"));
}
}
public static Term MapEntity(this TermViewModel model, IMapper mapper, string currentUserId)
{
var entity = mapper.Map <TermViewModel, Term>(model);
if (!entity.Text.HasHtmlTag())
{
entity.Text = entity.Text.ReplaceNewLine();
}
entity.Highlight = model.Highlights.HasItems() ? JsonConvert.SerializeObject(model.Highlights) : "";
entity.Reference = model.References.HasItems() ? JsonConvert.SerializeObject(model.References) : "";
if (model.Id == 0)
{
entity.SetCreated(currentUserId);
}
entity.SetUpdated(currentUserId);
return(entity);
}
public void SaveTermNotes(TermViewModel model, List <NoteViewModel> noteViewList)
{
int termId = model.Id;
int subjectId = model.SubjectId;
model.Subject = null;
if (model.SubItems.HasItems())
{
foreach (var item in model.SubItems)
{
item.Subject = null;
}
}
model.LoadNotes(noteViewList);
_termNotesRepository.InsertOne(new TermNotes {
SubjectId = subjectId, TermId = termId, Content = JsonConvert.SerializeObject(model)
});
}
public async Task <ActionResult> Update(int id, [FromBody] TermViewModel model)
{
var existingEntity = _termsService.GetById(id);
if (existingEntity == null)
{
return(NotFound());
}
await ValidateRequestAsync(model);
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var term = model.MapEntity(_mapper, CurrentUserId);
await _termsService.UpdateAsync(existingEntity, term);
return(Ok());
}
public async Task <ActionResult> Create(int subject, int parent)
{
Subject selectedSubject = await _subjectsService.GetByIdAsync(subject);
if (selectedSubject == null)
{
ModelState.AddModelError("subject", "科目不存在");
return(BadRequest(ModelState));
}
int maxOrder = await _termsService.GetMaxOrderAsync(selectedSubject, parent);
int order = maxOrder + 1;
var model = new TermViewModel()
{
Order = order,
SubjectId = subject,
ParentId = parent,
Active = order >= 0
};
var terms = await _termsService.FetchAsync(selectedSubject);
if (terms.HasItems())
{
_termsService.LoadSubItems(terms);
terms = terms.GetOrdered();
}
var form = new TermEditForm()
{
Term = model,
Parents = terms.MapViewModelList(_mapper)
};
return(Ok(form));
}
async Task ValidateRequestAsync(TermViewModel model)
{
var subject = await _subjectsService.GetByIdAsync(model.SubjectId);
if (subject == null)
{
ModelState.AddModelError("subjectId", "科目不存在");
}
if (model.ParentId > 0)
{
var parent = await _termsService.GetByIdAsync(model.ParentId);
if (parent == null)
{
ModelState.AddModelError("parentId", "主條文不存在");
}
if (parent.Id == model.Id)
{
ModelState.AddModelError("parentId", "主條文重疊.請選擇其他主條文");
}
}
}
public void Update(string term, [FromBody] TermViewModel model)
{
}
public void Create([FromBody] TermViewModel model)
{
}
public ActionResult Edit(TermViewModel termVM)
{
termService.Update(termVM);
return(View());
}
