public async Task <ActionResult> Edit(int id, ToDoListItemFormViewModel toDoListItem)
{
try
{
var toDoItem = new ToDoListItem()
{
Id = toDoListItem.Id,
Title = toDoListItem.Title,
ToDoStatusId = toDoListItem.ToDoStatusId
};
var user = await GetCurrentUserAsync();
toDoItem.ApplicationUserId = user.Id;
_context.ToDoListItems.Update(toDoItem);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
catch
{
return(View());
}
}
// factory method creates items as required by ToDoList
public ToDoListItem Create(string title)
{
var item = new ToDoListItem(this, title);
this.Items.Add(item);
return(item);
}
public void MultipleListItems()
{
ToDoLists.Lists.Add(1, new List <ToDoList>());
ToDoList toDoList = new ToDoList
{
UserID = 1,
Title = "Test list"
};
var insertedList = _toDoListRepository.Create(toDoList);
var firstItem = new ToDoListItem
{
UserID = 1,
Title = "Test item 1",
ToDoListID = insertedList.ID,
Content = "Lorem ipsum dolor sit amet, consectetur adipiscing elit"
};
_toDoListItemRepository.Create(firstItem);
var secondItem = new ToDoListItem
{
UserID = 1,
Title = "Test item 2",
ToDoListID = insertedList.ID,
Content = "Lorem ipsum dolor sit amet, consectetur adipiscing elit"
};
var insertedItem = _toDoListItemRepository.Create(secondItem);
Assert.AreEqual(2, insertedItem.ID);
Assert.AreEqual(2, ToDoLists.Lists[1].FirstOrDefault(l => l.ID == insertedList.ID).ToDoListItems.Count());
}
public async Task <IActionResult> PutToDo([FromRoute] int id, [FromBody] ToDoListItem todo)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != todo.ID)
{
return(BadRequest());
}
_context.Entry(todo).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ToDoExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public void AddItem(ToDoListItem item)
{
item.Id = counter;
Items.Add(item);
counter++;
OnToDoListUpdated?.Invoke(this, new Events.EventArgs.ToDoListUpdatedArgs());
}
public async void DeleteItemHandler_IsVerifiable_ReturnsNotNullResult()
{
var itemToDelete = new ToDoListItem {
Id = Guid.Parse("7a73db1a-f0a8-4937-a229-b9787ea2c54f"), Completed = true, Name = "test"
};
//Arrange
var _serviceContextMock = new Mock <IServiceContext>();
_serviceContextMock.Setup(a => a.DeleteToDoItem(It.IsAny <ToDoListItem>())).Verifiable();
_serviceContextMock.Setup(a => a.GetToDoListItemAsync(itemToDelete.Id)).Verifiable();
DeleteToDoItemCommand command = new DeleteToDoItemCommand();
command.Id = Guid.NewGuid();
IToDoListRepository _todoListRepository = new ToDoListRepository(_serviceContextMock.Object);
DeleteToDoItemHandler handler = new DeleteToDoItemHandler(_todoListRepository, _mapper);
//Act
var _handler = await handler.Handle(command, new System.Threading.CancellationToken());
//Assert
Assert.NotNull(handler);
}
public IActionResult CreateUpdate(ToDoListViewModel viewModel)
{
if (ModelState.IsValid)
{
using (var db = DbHelper.GetConnection())
{
if (viewModel.EditableItem.Id <= 0)
{
viewModel.EditableItem.AddDate = DateTime.Now;
db.Insert <ToDoListItem>(viewModel.EditableItem);
}
else
{
ToDoListItem dbItem = db.Get <ToDoListItem>(viewModel.EditableItem.Id);
TryUpdateModelAsync <ToDoListItem>(dbItem, "EditableItem");
db.Update <ToDoListItem>(dbItem);
}
}
return(RedirectToAction("Index"));
}
else
{
return(View("Index", new ToDoListViewModel()));
}
}
//Ajouter un objet à la todolist en y associant le nom de l'utilisateur l'ayant ajouté
public ToDoListItem AddItem(ToDoListItem item, string UserName)
{
item.userName = UserName;
_todolistItem.Add(item.ItemName + "." + item.Id, item);
return(item);
}
private void MenuItemMarkDone_Click(object sender, RoutedEventArgs e)
{
int _itemId = 0;
if (lbTodoListItem.SelectedItem != null)
{
_itemId = (lbTodoListItem.SelectedItem as ToDoListItem).ToDoListItemId;
}
else
{
return;
}
ToDoListItem _ = _toDoListItemRepository.Get(a => a.ToDoListItemId == _itemId);
_.status = "Done";
_toDoListItemRepository.Delete(_itemId);
_toDoListItemRepository.Save();
_toDoListItemRepository.Insert(_);
_toDoListItemRepository.Save();
Populate();
RefreshList();
}
public async void UpdateToDoItemHandler_IsVerifiable_ReturnsNotNullResult()
{
//Arrange
var itemToUpdate = new ToDoListItem {
Id = Guid.Parse("7a73db1a-f0a8-4937-a229-b9787ea2c54f"), Completed = true, Name = "test"
};
var _serviceContextMock = new Mock <IServiceContext>();
_serviceContextMock.Setup(a => a.UpdateToDoItemStatus(itemToUpdate)).Verifiable();
_serviceContextMock.Setup(a => a.GetToDoListItemAsync(itemToUpdate.Id)).Returns(GetToDoListItemFromFileAsync(itemToUpdate.Id)).Verifiable();
JsonPatchDocument <ToDoItemUpdationDto> patch = new JsonPatchDocument <ToDoItemUpdationDto>();
patch.Replace(e => e.Completed, !itemToUpdate.Completed);
var command = new UpdateToDoListItemStatusCommand();
command.Id = itemToUpdate.Id;
command.UpdateItem = patch;
IToDoListRepository _todoListRepository = new ToDoListRepository(_serviceContextMock.Object);
UpdateToDoListItemStatusHandler handler = new UpdateToDoListItemStatusHandler(_todoListRepository, _mapper);
//Act
var _handler = await handler.Handle(command, new System.Threading.CancellationToken());
//Assert - verify able to call UpdateToDoListItemStatusHandler
Assert.NotNull(handler);
}
public ActionResult <StatusViewModel> UpdateToDoList([FromBody] ToDoViewModel info)
{
StatusViewModel result = new StatusViewModel();
ToDoListItem updatedToDoList = new ToDoListItem();
updatedToDoList.Name = info.ToDoList.Name;
updatedToDoList.Description = info.ToDoList.Description;
updatedToDoList.Category = info.ToDoList.Category;
try
{
updatedToDoList.Id = _db.GetToDoListItem(info.ToDoList.Id).Id;
}
catch (Exception ex)
{
result.IsSuccessful = false;
result.Message = ex.Message;
}
try
{
_db.UpdateToDoListItem(updatedToDoList);
}
catch (Exception ex)
{
result.IsSuccessful = false;
result.Message = ex.Message;
}
return(Json(result));
}
public async Task <IActionResult> Edit(int id, [Bind("ID,ListItemOrder,Description,IsComplete")] ToDoListItem listItem)
{
if (id != listItem.ID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(listItem);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ListItemExists(listItem.ID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(listItem));
}
//public async Task<IActionResult> Edit(Guid id, [Bind("Name,Complete,DueDate,Id,TimeStamp")] ToDoListItem toDoListItem)
public IActionResult Edit(Guid id, [Bind("Name,Complete,DueDate,Id,TimeStamp")] ToDoListItem toDoListItem)
{
if (id != toDoListItem.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_toDoRepo.Update(toDoListItem);
_toDoRepo.SaveChanges();
//await _toDoRepo.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ToDoListItemExists(toDoListItem.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(toDoListItem));
}
public ActionResult DeleteConfirmed(int id)
{
ToDoListItem toDoListItem = db.ToDoListItems.Find(id);
db.ToDoListItems.Remove(toDoListItem);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public void StopTrackTimeFor(ToDoListItem item)
{
if (this.currentItem != item)
{
throw new Exception();
}
// stop time tracking logic.
this.currentItem = null;
}
public void AddToDoListItem(int ToDoListObjectID, ToDoListItem obj)
{
ToDoListObject objToDoListObject = _ToDoListObject.GetToDoList(ToDoListObjectID);
if (objToDoListObject != null)
{
_ToDoListObject.AddToDoListItem(ToDoListObjectID, obj);
}
}
public void Delete(ToDoListItem toDoListItem)
{
Models
.ToDoLists
.Lists[toDoListItem.UserID]
.FirstOrDefault(l => l.ID == toDoListItem.ToDoListID)
.ToDoListItems
.Remove(toDoListItem);
}
public ToDoListItem Get(ToDoListItem toDoListItem)
{
return(Models
.ToDoLists
.Lists[toDoListItem.UserID]?
.FirstOrDefault(l => l.ID == toDoListItem.ToDoListID)?
.ToDoListItems
.FirstOrDefault(l => l.ID == toDoListItem.ID));
}
public void DeleteToDoList(ToDoListItem toDoList)
{
using (var context = new ToDoAppContext(_options))
{
//ToDoListItem toDoList = context.ToDoListItem.Find(toDoListId);
context.ToDoListItem.Remove(toDoList);
context.SaveChanges();
}
}
public void UpdateItem(ToDoListItem old, ToDoListItem newItem)
{
old.CreationTime = newItem.CreationTime;
old.Description = newItem.Description;
old.DueDate = newItem.DueDate;
old.Name = newItem.Name;
old.Completed = newItem.Completed;
OnToDoListUpdated?.Invoke(this, new Events.EventArgs.ToDoListUpdatedArgs());
}
public void StartTrackTimeFor(ToDoListItem item)
{
if (this.currentItem != null)
{
throw new Exception();
}
// could also throw different exception if specified item is current item being tracked
// start time tracking logic.
this.currentItem = item;
}
public ActionResult Edit([Bind(Include = "itemNumber,itemText,DateAdded,Completed")] ToDoListItem toDoListItem)
{
if (ModelState.IsValid)
{
db.Entry(toDoListItem).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(toDoListItem));
}
public IActionResult UpdateToDoList(ToDoListItem obj)
{
if (ModelState.IsValid)
{
_db.ToDoListItems.Update(obj);
_db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(obj));
}
public IActionResult GetToDo([FromBody] ToDoListItem toDoListItem)
{
try
{
return(Json(_toDoListItemRepository.Get(toDoListItem)));
} catch (Exception ex)
{
return(BadRequest(ex));
}
}
//
// GET: /ToDoList/Delete/5
public ActionResult Delete(int id = 0)
{
ToDoListItem item = _db.ToDoListItems.Find(id);
if (item == null)
{
return(HttpNotFound());
}
return(View(item));
}
public async Task <ToDoItemListDto> Handle(CreateToDoItemCommand request, CancellationToken cancellationToken)
{
ToDoListItem item = new ToDoListItem {
Id = Guid.NewGuid(), Name = request.Name, Completed = request.Completed
};
var result = await _todoListRepository.AddToDoItemAsync(item);
return(_mapper.Map <ToDoListItem, ToDoItemListDto>(item));
}
public ActionResult Edit(ToDoListItem item)
{
if (ModelState.IsValid)
{
//_db.Entry(item).State = EntityState.Modified;
//_db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(item));
}
public bool Create(ToDoListItem toDoListItem)
{
if (toDoListItem == null)
{
throw new ApplicationException("Item cannot be null");
}
toDoListItem.CreateDate = DateTime.Now;
return(_todoListItemRepo.Create(toDoListItem));
}
public ActionResult Create(ToDoListItem item)
{
if (ModelState.IsValid)
{
_db.ToDoListItems.Add(item);
_db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(item));
}
public ActionResult <ToDoListItem> AddItem(ToDoListItem item)
{
var todolistItem = _services.AddItem(item, User.Identity.Name);
if (todolistItem == null)
{
return(NotFound());
}
return(todolistItem);
}
