//Update / Change
public async Task Change(ToDo todo)
{
if (todo == null)
{
throw new Exception("Input cannot be null");
}
_context.Entry(todo).State = EntityState.Modified;
var rowsAffected = await _context.SaveChangesAsync();
if (rowsAffected != 1)
{
throw new Exception("Input cannot be null");
}
if (todo.Id == 0)
{
throw new Exception("Input must have Id greater than zero");
}
_context.Entry(todo).State = EntityState.Modified;
var rowssAffected = await _context.SaveChangesAsync();
if (rowsAffected != 1)
{
throw new Exception("Change Failed");
}
}
//public List<Todo> GetTodos(string filter)
//{
// var filterOn = filter.Split(',');
// var todoList = _context.Todos.Select(s => new { s.Id, s.Title }).ToList();
// return todoList;
//}
public int StoreTodo(TodoMapper mapper)
{
var newTodo = new Todo();
if (mapper.Id > 0)
{
newTodo = _context.Todos.Find(mapper.Id);
}
newTodo.Title = mapper.Title;
newTodo.Description = mapper.Description;
newTodo.Status = (TaskStatus)mapper.Status;
newTodo.Created = mapper.Created;
newTodo.Due = mapper.Due;
newTodo.Completed = mapper.Completed;
newTodo.OwnerId = 1;
if (mapper.Id == 0)
{
_context.Entry(newTodo).State = Microsoft.EntityFrameworkCore.EntityState.Added;
}
else
{
_context.Entry(newTodo).State = Microsoft.EntityFrameworkCore.EntityState.Modified;
}
return(_context.SaveChanges());
}
public IHttpActionResult PutTache(int id, Tache tache)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != tache.ID)
{
return(BadRequest());
}
db.Entry(tache).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!TacheExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public IHttpActionResult PutTodoList(int id, TodoListViewModel todoListDto)
{
if (!ModelState.IsValid)
{
return(Message(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState)));
}
if (id != todoListDto.TodoListId)
{
return(StatusCode(HttpStatusCode.BadRequest));
}
TodoList todoList = todoListDto.ToEntity();
if (!String.Equals(db.Entry(todoList).Entity.UserId, User.Identity.GetUserId(), StringComparison.OrdinalIgnoreCase))
{
// Trying to modify a record that does not belong to the user
return(StatusCode(HttpStatusCode.Unauthorized));
}
db.Entry(todoList).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
return(StatusCode(HttpStatusCode.InternalServerError));
}
return(StatusCode(HttpStatusCode.OK));
}
private void StopTracking(TodoItem item)
{
_context.Entry(item).State = EntityState.Detached;
foreach (var mapping in item.TagsMapping)
{
_context.Entry(mapping).State = EntityState.Detached;
_context.Entry(mapping.Tag).State = EntityState.Detached;
}
}
public void Delete(T entity)
{
if (_context.Entry(entity).State == EntityState.Detached)
{
_dbSet.Attach(entity);
}
_dbSet.Remove(entity);
SaveChange();
}
public async Task <bool> MarkAsCompleted(Guid todoId, Guid userId)
{
TodoItem ret = await Get(todoId, userId);
if (ret != null)
{
_context.Entry(ret).State = EntityState.Modified;
ret.MarkAsCompleted();
_context.SaveChanges();
return(true);
}
return(false);
}
public async Task <IActionResult> PutTodoList([FromRoute] int id, [FromBody] TodoList todoList)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != todoList.ID)
{
return(BadRequest());
}
_context.Entry(todoList).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TodoListExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutEmployee(int id, Employee employee)
{
if (id != employee.Id)
{
return(BadRequest());
}
_context.Entry(employee).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EmployeeExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
// PUT api/Todo/5
public HttpResponseMessage PutTodos(int id, Todos todos)
{
if (!ModelState.IsValid)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
if (id != todos.Id)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
db.Entry(todos).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, ex));
}
return(Request.CreateResponse(HttpStatusCode.OK));
}
public async Task <IActionResult> PutUser(int id, User user)
{
if (id != user.UserId)
{
return(BadRequest());
}
_context.Entry(user).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UserExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <ActionResult <UserTaskViewModel> > PatchUserTask(int id, UserTaskDTO userTaskUpdate)
{
var userTask = await _context.UserTasks.FindAsync(id);
if (userTask == null)
{
return(NotFound());
}
userTask.Name = userTaskUpdate.Name ?? userTask.Name;
userTask.Status = userTaskUpdate.Status;
userTask.User = await _context.Users.FindAsync(userTaskUpdate.UserId);
userTask.Deadline = userTaskUpdate.Deadline;
_context.Entry(userTask).State = EntityState.Modified;
await _context.SaveChangesAsync();
return(new UserTaskViewModel
{
Id = userTask.Id,
Name = userTask.Name ?? "No-name",
Deadline = userTask.Deadline ?? DateTime.Now,
UserId = userTask?.User.Id,
Status = userTask?.Status.ToString() ?? Models.TaskStatus.New.ToString(),
GroupId = userTask?.TaskGroup?.Id
});
}
public async Task <IActionResult> PutTodo(int id, Todo todo)
{
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 int UpdateTodoItem(TodoItemViewModel item)
{
try
{
var itemEntity = new TodoItem
{
Id = item.Id,
Title = item.Title,
Description = item.Description,
Lat = item.Latitude,
Long = item.Longitude
//Location = new Point(item.Latitude, item.Latitude) { SRID = 4326 }
};
// add validation
_context.Entry(itemEntity).State = EntityState.Modified;
_context.SaveChanges();
return(1);
}
catch (Exception ex)
{
throw;
}
}
public async Task Update(TodoAggregate item)
{
var entity = m_mapper.Map <Entity.Todo>(item);
var originalEntity = await m_dbContext.Todos.FindAsync(entity.Id);
m_dbContext.Entry <Entity.Todo>(originalEntity).CurrentValues.SetValues(entity);
await m_dbContext.SaveChangesAsync();
}
public async Task <Board> UpdateBoardTitleAsync(Board board)
{
if (!await boardRepository.CheckBoardExistsAsync(board.Id))
{
throw new ArgumentException("Board with specified Id does not exist");
}
if (board.CreationDate != null)
{
throw new ArgumentException("Cannot change board CreationDate");
}
context.Entry(board).Property(b => b.Title).IsModified = true;
await context.SaveChangesAsync();
context.Detach(board);
return(board);
}
public IActionResult Edit(Todo todo)
{
var user = _userManager.FindByNameAsync(User.Identity.Name).Result;
todo.UserId = user.Id;
_context.Entry(todo).State = Microsoft.EntityFrameworkCore.EntityState.Modified;
_context.Todos.Update(todo);
_context.SaveChanges();
return(RedirectToAction("Index"));
}
public async Task <bool> UpdateItemAsync(Item item)
{
int count = 0;
using (var context = new TodoDbContext())
{
context.Entry(item).State = Microsoft.EntityFrameworkCore.EntityState.Modified;
count = await context.SaveChangesAsync();
}
return(await Task.FromResult(count == 1));
}
public IHttpActionResult PutCategories(int id, Categorie categorie)
{
if (id != categorie.ID)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (db.Categories.Count(x => x.ID == id) != 1)
{
return(BadRequest());
}
db.Entry(categorie).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
return(StatusCode(HttpStatusCode.NoContent)); // renvoyer un code status donc erreur 204 pour dire bien passé mais rien à re
}
public IHttpActionResult PutCategories(int id, Categorie categorie)
{
if (id != categorie.ID)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (db.Categories.Count(x => x.ID == id) != 1)
{
return(BadRequest());
}
db.Entry(categorie).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
return(StatusCode(HttpStatusCode.NoContent));
}
public IHttpActionResult PutTodoItem(int id, TodoItemViewModel todoItemDto)
{
if (!ModelState.IsValid)
{
return(Message(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState)));
}
if (id != todoItemDto.TodoItemId)
{
return(StatusCode(HttpStatusCode.BadRequest));
}
TodoItem todoItem = todoItemDto.ToEntity();
TodoList todoList = db.TodoLists.Find(todoItem.TodoListId);
if (todoList == null)
{
return(StatusCode(HttpStatusCode.NotFound));
}
if (!String.Equals(todoList.UserId, User.Identity.GetUserId(), StringComparison.OrdinalIgnoreCase))
{
// Trying to modify a record that does not belong to the user
return(StatusCode(HttpStatusCode.Unauthorized));
}
// Need to detach to avoid duplicate primary key exception when SaveChanges is called
db.Entry(todoList).State = EntityState.Detached;
db.Entry(todoItem).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
return(StatusCode(HttpStatusCode.InternalServerError));
}
return(StatusCode(HttpStatusCode.OK));
}
public IHttpActionResult PutCategories(int id, Categorie categorie)
{
if (id != categorie.ID)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (db.Categories.Count(x => x.ID == id) != 1)
{
return(BadRequest());
}
db.Entry(categorie).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
return(StatusCode(HttpStatusCode.NoContent)); // renvoie une notification comme quoi ça s'est bien déroulé, mais sans contenu
}
public async Task <ActionResult <Models.Task> > PutTask(long id, Models.Task task)
{
if (id != task.TaskId)
{
return(BadRequest());
}
_context.Entry(task).State = EntityState.Modified;
await _context.SaveChangesAsync();
return(NoContent());
}
public async Task <ActionResult <TaskList> > PutTaskList(long id, TaskList taskList)
{
if (id != taskList.TaskListId)
{
return(BadRequest());
}
_context.Entry(taskList).State = EntityState.Modified;
await _context.SaveChangesAsync();
return(NoContent());
}
public async Task <ActionResult <Comment> > PutComment(long id, Comment comment)
{
if (id != comment.CommentId)
{
return(BadRequest());
}
_context.Entry(comment).State = EntityState.Modified;
await _context.SaveChangesAsync();
return(NoContent());
}
public T UpdateItem(T updatedItem, params object[] itemKey)
{
using (var db = new TodoDbContext())
{
var item = GetItem(itemKey);
if (item == null)
{
throw new KeyNotFoundException($"Item with key {itemKey} not found");
}
db.Entry <T>(item).CurrentValues.SetValues(updatedItem);
return(db.SaveChanges() == 1 ? item : null);
}
}
public IHttpActionResult PutCategories(int id, Categorie categorie)
{
if (id != categorie.ID) // test que l'objet ID fait partit de "categorie"
{
return(BadRequest());
}
if (!ModelState.IsValid) // le ! est un operateur implicite
{
return(BadRequest(ModelState)); // "return" permet de ne pas solliciter un else car apres la condition, on retourne le "return"
}
if (db.Categories.Count(x => x.ID == id) != 1)
{
return(BadRequest());
}
db.Entry(categorie).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
return(StatusCode(HttpStatusCode.NoContent)); // pour renvoyer un message d'erreur 204 si pas de contenu dans la table
// puis Postman afin de modifier les données de la table********
}
public void Update(TodoItem todoItem, Guid userId)
{
TodoItem toBeUpdatedTodoItem = Get(todoItem.Id, userId);
if (toBeUpdatedTodoItem == null)
{
Add(todoItem);
}
else
{
_context.Entry(toBeUpdatedTodoItem).State = EntityState.Modified;
}
_context.SaveChanges();
}
public ActionResult UpdateTodoItem(long id, TodoItem item)
{
Task.Delay(Config.ActionDelay).Wait();
if (id != item.Id)
{
return(BadRequest());
}
_dbContext.Entry(item).State = EntityState.Modified;
_dbContext.SaveChanges();
return(NoContent());
}
public async Task <ActionResult> UpdateTodoItemAsync(long id, TodoItem item)
{
await Task.Delay(Config.ActionDelay);
if (id != item.Id)
{
return(BadRequest());
}
_dbContext.Entry(item).State = EntityState.Modified;
await _dbContext.SaveChangesAsync();
return(NoContent());
}
