public ActionResult <TodoTaskReadDto> UpdateTodoTaskDone(int id)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
// ambil data existing by id
TodoTaskModel oldData = _todoTaskService.GetTodoTaskById(id);
if (oldData == null)
{
return(NotFound(new
{
success = false,
message = "No Data"
}));
}
oldData.PercentComplete = 100;
if (_todoTaskService.SaveChanges())
{
return(Created(nameof(UpdateTodoTaskDone), new
{
success = true,
message = "Data updated"
}));
}
return(BadRequest());
}
public ActionResult <TodoTaskReadDto> UpdateTodoTaskPercent(int id, TodoTaskCompleteDto request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
// ambil data existing by id
TodoTaskModel oldData = _todoTaskService.GetTodoTaskById(id);
if (oldData == null)
{
return(NotFound(new
{
success = false,
message = "No Data"
}));
}
// mapping tanpa deklarasi tipe, guna mapping perubahan
_mapper.Map(request, oldData);
_todoTaskService.UpdateTodoTask(oldData); // do nothing
if (_todoTaskService.SaveChanges())
{
return(Created(nameof(UpdateTodoTaskPercent), new
{
success = true,
message = "Data updated"
}));
}
return(BadRequest());
}
public ActionResult <TodoTaskReadDto> GetTodoTaskById(int id)
{
if (id < 1)
{
return(BadRequest());
}
TodoTaskModel response = _todoTaskService.GetTodoTaskById(id);
if (response != null)
{
return(Ok(new
{
success = true,
message = "Data fetched",
data = _mapper.Map <TodoTaskReadDto>(response)
}));
}
return(BadRequest(new
{
success = false,
message = "No Data"
}));
}
public ActionResult <TodoTaskReadDto> CreateTodoTask([FromBody] TodoTaskCreateDto request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
TodoTaskModel data = _mapper.Map <TodoTaskModel>(request);
_todoTaskService.CreateTodoTask(data);
if (_todoTaskService.SaveChanges())
{
//return data sesuai yang masuk
TodoTaskReadDto response = _mapper.Map <TodoTaskReadDto>(data);
return(CreatedAtRoute(nameof(GetTodoTaskById),
new { response.Id },
new
{
success = true,
message = "Data fetched",
data = response
}));
}
return(BadRequest());
}
public void Given_CollectionWithTwoRecords_Then_UpdateTask_With_ChangedProperties_UpdatesRecordCorrectly()
{
_taskProvider.CreateTodoTask(new TodoTaskModel
{
Name = "Skalda",
Status = Enums.TodoTaskStatus.NOT_STARTED
});
_taskProvider.CreateTodoTask(new TodoTaskModel
{
Name = "new",
Status = Enums.TodoTaskStatus.COMPLETED
});
var newTask = new TodoTaskModel
{
Name = "Updated",
Priority = 2,
Status = Enums.TodoTaskStatus.IN_PROGRESS
};
var retrievedTask = _taskProvider.UpdateTask("Skalda", newTask);
Assert.AreEqual(newTask, retrievedTask);
}
public ActionResult <TodoTaskModel> Post(TodoTaskModel todoTaskModel)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest("Inavlid data"));
}
var task = _mapper.Map <TodoTask>(todoTaskModel);
var newTask = _taskRepository.Add(task);
if (newTask == null)
{
return(BadRequest("Could not create new task"));
}
var location = _linkGenerator.GetPathByAction("Get", "ListTasks", new { id = newTask.Id });
if (string.IsNullOrWhiteSpace(location))
{
return(BadRequest("Could not use current Id"));
}
return(Created(location, _mapper.Map <TodoTaskModel>(newTask)));
}
catch (Exception)
{
return(StatusCode(StatusCodes.Status500InternalServerError, "Reposiry Failure"));
}
}
public ActionResult Edit(long id)
{
TodoTaskModel model = new TodoTaskModel();
_ser.GetTask(id);
return(PartialView("EditTask", model));
}
public JsonResult ChangeStatus(long taskId, bool check)
{
TodoTaskModel model = new TodoTaskModel();
model.taskId = taskId;
model.isComplete = check;
_ser.ChangeStatus(taskId, check);
JsonResult result = new JsonResult();
result.Data = taskId;
if (check == true)
{
model.TodoTaskList = _ser.GetTaskList().Where(x => x.taskId == taskId);
result.Data = taskId;
result.Data = _ser.GetTaskName(taskId);
}
else
{
model.TodoTaskList = _ser.GetTaskList().Where(x => x.taskId == taskId);
result.Data = taskId;
result.Data = _ser.GetTaskName(taskId);
}
return(result);
}
public void UpdateAgileTask()
{
_agileTodoTaskModel[0].Description = "Updated";
ToDoTask _toDoTask = new ToDoTask();
TodoTaskModel _todoTaskModel = _toDoTask.Save(_agileTodoTaskModel[0]);
Assert.AreNotEqual(null, _todoTaskModel);
}
public void CreateTodoTask(TodoTaskModel oTodoTaskModel)
{
if (oTodoTaskModel == null)
{
throw new ArgumentNullException(nameof(oTodoTaskModel));
}
_context.TodoTasks.Add(oTodoTaskModel);
}
public void DeleteTodoTask(TodoTaskModel oTodoTaskModel)
{
// validasi
if (oTodoTaskModel == null)
{
throw new ArgumentNullException(nameof(oTodoTaskModel));
}
_context.TodoTasks.Remove(oTodoTaskModel);
}
public void UpdateTask(TodoTaskModel model)
{
var result = ent.ToDoTasks.Where(x => x.TaskId == model.taskId).FirstOrDefault();
result.TaskName = model.taskName;
result.TaskDate = model.taskDate;
result.TaskDescription = model.taskDescription;
ent.ApplyCurrentValues(result.EntityKey.EntitySetName, result);
ent.SaveChanges();
}
public JsonResult DetailTask(string taskId)
{
TodoTaskModel model = new TodoTaskModel();
string str = taskId.Remove(0, 2);
model = _ser.GetTask(long.Parse(str));
JsonResult result = new JsonResult();
result.Data = model;
return(result);
}
//[Authorize]
//[ValidateAntiForgeryToken]
public HttpStatusCodeResult DeleteNormalTask(string taskId)
{
ToDoTask toDoTask = new ToDoTask();
toDoTask.SetToDoTaskStrategy(new NormalTask());
TodoTaskModel _normalTodoTaskModel = toDoTask.DeleteById(new Guid(taskId));
return(_normalTodoTaskModel == null ? new HttpStatusCodeResult(HttpStatusCode.OK, "Record deleted") :
new HttpStatusCodeResult(HttpStatusCode.BadRequest, "Bad Request"));
}
public int DeleteItemTask(int todoItemId, int todoTaskId)
{
TodoItemModel todoItem = _dummyData.AllItems().FirstOrDefault(t => t.ItemId == todoItemId);
TodoTaskModel todoTask = todoItem.TodoTasks.FirstOrDefault(s => s.TaskId == todoTaskId);
if (todoItem == null || todoTask == null)
{
return(OperationStatusCodes.NOT_FOUND);
}
todoTask.IsDeleted = true;
return(OperationStatusCodes.SUCCESS);
}
public TodoTaskModel CreateTodoTask(TodoTaskModel todoTask)
{
if (string.IsNullOrWhiteSpace(todoTask.Name))
{
throw new TodoTaskProviderException(TodoTaskErrors.MissingName);
}
if (!_todoTasks.TryAdd(todoTask.Name, todoTask))
{
throw new TodoTaskProviderException(TodoTaskErrors.Duplicate);
}
return(todoTask);
}
public void SaveTask(TodoTaskModel model)
{
ToDoTasks obj = new ToDoTasks();
obj.UserId = model.userId;
obj.TaskName = model.taskName;
obj.TaskDate = DateTime.Now;//model.taskDate;
obj.TaskTime = model.taskTime;
obj.CreatedDate = model.createdDate;
obj.isComplete = model.isComplete;
obj.TaskDescription = "Hello";//model.taskDescription;
ent.AddToToDoTasks(obj);
ent.SaveChanges();
}
public async Task <ActionResult <TodoTask> > Create(TodoTaskModel taskModel)
{
try
{
return(await _mediator.Send(new CreateTodoTaskCommand
{
Task = _mapper.Map <TodoTask>(taskModel)
}));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public async Task AddTask_TaskIsValid_ReturnCreated()
{
// Arrange
var task = new TodoTaskModel
{
Text = "Test solution"
};
var taskContent = new StringContent(JsonConvert.SerializeObject(task), Encoding.UTF8, "application/json");
// Act
var response = await Client.PostAsync("/api/tasks", taskContent);
// Assert
Assert.AreEqual(HttpStatusCode.Created, response.StatusCode);
}
public TodoTaskModel GetTask(long id)
{
var result = ent.ToDoTasks.Where(x => x.TaskId == id).FirstOrDefault();
TodoTaskModel model = new TodoTaskModel {
createdDate = result.CreatedDate,
isComplete = result.isComplete,
taskDate = result.TaskDate,
taskName = result.TaskName,
taskDescription = result.TaskDescription,
taskTime = result.TaskTime,
userId = result.UserId,
taskId = result.TaskId
};
return(model);
}
public JsonResult EditTask(long taskId, string taskName, string taskDescription, string taskDate)
{
TodoTaskModel model = new TodoTaskModel();
model.taskId = taskId;
model.taskName = taskName;
model.taskDescription = taskDescription;
// model.taskDate = Convert.ToDateTime(taskDate.Remove(24));
model.taskDate = Convert.ToDateTime(taskDate);
_ser.UpdateTask(model);
model = _ser.GetTask(taskId);
JsonResult result = new JsonResult();
result.Data = model;
return(result);
}
public async Task <ActionResult> Index()
{
if (!User.Identity.IsAuthenticated)
{
return(RedirectToAction("Login", "Account"));
}
var UserID = User.Identity.GetUserId <long>();
ICollection <TodoList> lists = await _todoListRepository.GetAllAsync();
ICollection <TodoTask> tasks = await _todoTaskRepository.GetAllAsync();
TodoListsModel listsModel = new TodoListsModel();
listsModel.TodoLists = new List <TodoListModel>();
foreach (TodoList list in lists)
{
if (list.UserID == UserID)
{
TodoListModel listModel = new TodoListModel {
ListID = list.ListID,
ListName = list.ListName,
LeftPositioned = list.LeftPositoned,
DateCreated = list.DateCreated,
TodoTasks = new List <TodoTaskModel> {
}
};
foreach (TodoTask task in tasks)
{
if (task.ListID == list.ListID)
{
TodoTaskModel taskModel = new TodoTaskModel {
TaskID = task.TaskID,
TaskName = task.TaskName,
Description = task.Description,
Colour = task.Colour
};
listModel.TodoTasks.Add(taskModel);
}
}
listsModel.TodoLists.Add(listModel);
}
}
return(View(listsModel));
}
//[Authorize]
//[ValidateAntiForgeryToken]
public JsonResult UpdateNormalTask(NormalTodoTaskModel todoTaskModel)
{
todoTaskModel.IsActive = true;
todoTaskModel.UpdatedDate = DateTime.Now;
//Need to change
todoTaskModel.UpdatedBy = ((Models.User)Session["User"]).Id;
todoTaskModel.UserId = ((Models.User)Session["User"]).Id;
ToDoTask toDoTask = new ToDoTask();
toDoTask.SetToDoTaskStrategy(new NormalTask());
TodoTaskModel _normalTodoTaskModel = toDoTask.Save(todoTaskModel);
return(Json(_normalTodoTaskModel, JsonRequestBehavior.AllowGet));
}
public JsonResult PopulateTask(string projectType, string prjectId, string taskId)
{
ToDoTask toDoTask = new ToDoTask();
if (Convert.ToInt32(projectType) == (int)ProjectType.Agile)
{
toDoTask.SetToDoTaskStrategy(new AgileTask());
}
else if (Convert.ToInt32(projectType) == (int)ProjectType.Normal)
{
toDoTask.SetToDoTaskStrategy(new NormalTask());
}
TodoTaskModel todoTaskModel = toDoTask.GetById(new Guid(taskId));
return(Json(todoTaskModel, JsonRequestBehavior.AllowGet));
}
public JsonResult InsertNormalTask(NormalTodoTaskModel todoTaskModel)
{
todoTaskModel.Id = Guid.NewGuid();
todoTaskModel.IsActive = true;
todoTaskModel.CreatedDate = DateTime.Now;
todoTaskModel.CreatedBy = Guid.Parse(HttpContext.User.Identity.Name.Split('$')[1]);
todoTaskModel.UserId = Guid.Parse(HttpContext.User.Identity.Name.Split('$')[1]);
todoTaskModel.ProjectId = AppSettings.NormalProjectId;
ToDoTask toDoTask = new ToDoTask();
toDoTask.SetToDoTaskStrategy(new NormalTask());
TodoTaskModel normalTodoTaskModel = toDoTask.Save(todoTaskModel);
return(Json(normalTodoTaskModel, JsonRequestBehavior.AllowGet));
}
public IActionResult Update(int id, [FromBody] TodoTaskModel model)
{
if (!CommonHelper.IsValidRequest(model))
{
return(BadRequest("Bad Request."));
}
var todoTaskToUpdate = _todoTaskService.Get(id);
if (todoTaskToUpdate == null)
{
return(NotFound("The TodoTasks record couldn't be found."));
}
var todoTask = _mapper.Map <Entities.TodoTask>(model);
_todoTaskService.Update(todoTaskToUpdate, todoTask);
return(NoContent());
}
public TodoTaskModel UpdateTask(string name, TodoTaskModel todoTask)
{
var existingTodoTask = GetTodoTaskByName(name);
DeleteTodoTaskByName(name);
try
{
CreateTodoTask(todoTask);
}
catch
{
// recreate if create fails
CreateTodoTask(existingTodoTask);
throw;
}
return(todoTask);
}
// public JsonResult AddTask( string taskName, string taskDescription, DateTime taskDate)
public JsonResult AddTask(string taskName)
{
TodoTaskModel model = new TodoTaskModel();
var obj = (TravelSession)Session["TravelPortalSessionInfo"];
model.userId = obj.AppUserId;
model.taskName = taskName;
//model.taskDescription = taskDescription;
//model.taskDate = taskDate;
model.taskTime = new TimeSpan(1);
model.isComplete = false;
model.createdDate = DateTime.Now;
_ser.SaveTask(model);
long id = _ser.GetLastId();
model = _ser.GetTask(id);
JsonResult result = new JsonResult();
result.Data = model;
return(result);
}
public IEnumerable <TodoTaskModel> GetTaskList()
{
var result = ent.ToDoTasks;
List <TodoTaskModel> model = new List <TodoTaskModel>();
foreach (var item in result)
{
TodoTaskModel obj = new TodoTaskModel {
createdDate = item.CreatedDate,
isComplete = item.isComplete,
taskDate = item.TaskDate,
taskName = item.TaskName,
taskDescription = item.TaskDescription,
taskTime = item.TaskTime,
userId = item.UserId,
taskId = item.TaskId
};
model.Add(obj);
}
return(model.AsEnumerable());
}
public async Task <ActionResult <TodoTaskModel> > Put(int id, TodoTaskModel todoTaskModel)
{
try
{
var oldTask = await _taskRepository.GetTaskByIdAsync(id);
if (oldTask == null)
{
NotFound($"Could not find task with id of {id}");
}
_mapper.Map(todoTaskModel, oldTask);
return(_mapper.Map <TodoTaskModel>(oldTask));
}
catch (Exception)
{
return(StatusCode(StatusCodes.Status500InternalServerError, "Reposiry Failure"));
}
}
