public async Task <TaskResponseModel> UpdateTaskById(int id, TaskRequestModel taskRequestModel)
{
var task = new ApplicationCore.Entities.Task()
{
Id = id,
userid = taskRequestModel.userid,
Title = taskRequestModel.Title,
Description = taskRequestModel.Description,
DueDate = taskRequestModel.DueDate,
Priority = taskRequestModel.Priority,
Remarks = taskRequestModel.Remarks,
};
var createdTask = await _taskRepository.UpdateAsync(task);
var taskResponse = new TaskResponseModel()
{
Id = createdTask.Id,
userid = createdTask.userid,
Title = createdTask.Title,
Description = createdTask.Description,
DueDate = createdTask.DueDate,
Priority = createdTask.Priority,
Remarks = createdTask.Remarks,
};
return(taskResponse);
}
public async Task <TaskResponseModel> CreateTask(TaskRequestModel taskRequest)
{
var task = _mapper.Map <AppTask>(taskRequest);
var createdTask = await _taskRepository.AddAsync(task);
var response = _mapper.Map <TaskResponseModel>(createdTask);
return(response);
}
public async Task <TaskResponseModel> CreateTaskHistory(TaskRequestModel taskRequest)
{
var history = _mapper.Map <TaskHistory>(taskRequest);
var createdHistory = await _taskHistoryRepository.AddAsync(history);
var response = _mapper.Map <TaskResponseModel>(createdHistory);
return(response);
}
public async Task <IActionResult> Post(Guid flowId, TaskRequestModel model)
{
var task = await _taskService.Create(new StateTask()
{
FlowId = flowId,
Title = model.Title
});
return(CreatedAtAction(nameof(Get), new { id = task.Id }, _mapper.Map <TaskResponseModel>(task)));
}
public bool validate(TaskRequestModel requestModel)
{
if (string.IsNullOrEmpty(requestModel.ProjectCode) ||
string.IsNullOrEmpty(requestModel.TaskCode) ||
string.IsNullOrEmpty(requestModel.Brand) ||
string.IsNullOrEmpty(requestModel.Costcenter) ||
string.IsNullOrEmpty(requestModel.Brand)
)
{
return(false);
}
return(true);
}
public void Test1(string projectCode, string brand, string task, string costcenter)
{
var response = new TaskRequestModel()
{
Brand = brand,
Costcenter = costcenter,
TaskCode = task,
ProjectCode = projectCode
};
var result = sut.InsertDataTask(response);
Assert.Null(result);
}
public async Task <TaskResponseModel> UpdateTask(TaskRequestModel taskRequest)
{
var task = _mapper.Map <AppTask>(taskRequest);
var updatedTask = await _taskRepository.UpdateAsync(task,
t => t.Title,
t => t.Description,
t => t.DueDate,
t => t.Priority,
t => t.Remarks);
var response = _mapper.Map <TaskResponseModel>(updatedTask);
return(response);
}
public async Task <TaskEntity> AddTask(TaskRequestModel task)
{
var taskCreated = new TaskEntity
{
UserId = task.UserId,
Title = task.Title,
Description = task.Description,
DueDate = task.DueDate,
Priority = task.Priority,
Remarks = task.Remarks
};
return(await _taskRepository.AddAsync(taskCreated));
}
public void Test2(string projectCode, string brand, string task, string costcenter)
{
var response = new TaskRequestModel()
{
Brand = brand,
Costcenter = costcenter,
TaskCode = task,
ProjectCode = projectCode
};
var result = sut.InsertDataTask(response);
var expexted = (result != null) ? true : false;
Assert.True(expexted);
}
public async Task <TaskEntity> UpdateTask(TaskRequestModel task)
{
var taskDb = await _taskRepository.GetByIdAsync(task.Id);
taskDb.UserId = task.UserId;
taskDb.Title = task.Title;
taskDb.Description = task.Description;
taskDb.DueDate = task.DueDate;
taskDb.Priority = task.Priority;
taskDb.Remarks = task.Remarks;
var updatedTask = await _taskRepository.UpdateAsync(taskDb);
return(updatedTask);
}
public async Task <IActionResult> Post([FromBody] TaskRequestModel task)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var description = task.Description;
var edit = task.Edit;
var done = task.Done;
taskService.AddTaskAsync(description, done);
var todoList = await taskService.GetAllTaskAsync();
return(Created("Get", todoList));
}
public async Task <IActionResult> Put(Guid id, TaskRequestModel model)
{
var task = await _taskService.Update(new StateTask()
{
Id = id,
Title = model.Title
});
if (task == null)
{
return(NotFound());
}
return(Ok(_mapper.Map <TaskResponseModel>(task)));
}
public async Task <IActionResult> CreateTask(TaskRequestModel taskRequestModel)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.Values));
}
await _taskService.AddTask(taskRequestModel);
return(Ok());
}
catch (Exception e)
{
Console.WriteLine(e);
return(StatusCode(500, e.Message));
}
}
public async Task <IActionResult> Update(TaskRequestModel taskRequest)
{
try
{
taskRequest.CreatedBy = this.UserId;
var taskDto = _mapper.Map <Tasks>(taskRequest);
var result = await taskService.Update(taskDto);
if (result != null)
{
return(Ok(new { status = HttpStatusCode.OK, valid = true, msg = "Task updated successfully", response = result }));
}
return(Ok(new { status = HttpStatusCode.InternalServerError, valid = true, msg = "Something went wrong" }));
}
catch (Exception ex)
{
return(Ok(new { status = HttpStatusCode.InternalServerError, valid = true, msg = ex.InnerException.Message }));
}
}
public TaskResponseModel InsertDataTask(TaskRequestModel requestModel)
{
var isCreate = validate(requestModel);
if (!isCreate)
{
return(null);
}
var result = new TaskResponseModel()
{
Brand = requestModel.Brand,
Costcenter = requestModel.Costcenter,
TaskCode = requestModel.TaskCode
};
_task.Add(result);
return(result);
}
internal void UpdateCell(TaskRequestModel task)
{
if (!string.IsNullOrEmpty(task.TaskName) && task.TaskName.Length > Constants.MaxLength)
{
TaskName.Text = task.TaskName.Substring(0, Constants.MaxLength);
}
if (!string.IsNullOrEmpty(task.TaskName) && task.TaskName.Length <= Constants.MaxLength)
{
TaskName.Text = task.TaskName;
}
if (!string.IsNullOrEmpty(task.TaskDescription) && task.TaskDescription.Length > Constants.MaxLength)
{
TaskDescription.Text = task.TaskDescription.Substring(0, Constants.MaxLength);
}
if (!string.IsNullOrEmpty(task.TaskDescription) && task.TaskName.Length <= Constants.MaxLength)
{
TaskDescription.Text = task.TaskDescription;
}
}
public async Task <ActionResult> AddTask(TaskRequestModel taskRequestModel)
{
var task = await _taskService.AddTask(taskRequestModel);
return(Created("GetTask", task));
}
public async Task <IActionResult> UpdateTask(TaskRequestModel taskRequest)
{
var updatedTask = await _taskService.UpdateTask(taskRequest);
return(Ok(updatedTask));
}
public async Task <IActionResult> CreateTask(TaskRequestModel taskRequest)
{
var createdTask = await _taskService.CreateTask(taskRequest);
return(Ok(createdTask));
}
public async Task <IActionResult> DeleteTask([FromBody] TaskRequestModel taskRequest)
{
await _taskService.DeleteTask(taskRequest);
return(Ok());
}
public async Task <IActionResult> UpdateTask([FromBody] TaskRequestModel taskRequest)
{
var taskUpdated = await _taskService.UpdateTask(taskRequest);
return(Ok(taskUpdated));
}
public System.Threading.Tasks.Task <Task> UpdateTask(TaskRequestModel taskRequest)
{
var task = _requestMapper.Map <Task>(taskRequest);
return(_taskRepository.Update(task));
}
public IActionResult Post(TaskRequestModel requestModel)
{
var result = _service.Task().InsertDataTask(requestModel);
return(Ok(result));
}
public async Task DeleteTask(TaskRequestModel task)
{
var taskDb = await _taskRepository.GetByIdAsync(task.Id);
await _taskRepository.DeleteAsync(taskDb);
}
public async Task <ActionResult> UpdateTaskById(int id, TaskRequestModel taskRequestModel)
{
var task = await _taskService.UpdateTaskById(id, taskRequestModel);
return(Created("GetTask", task));
}
public async Task <IActionResult> CreateHistory(TaskRequestModel taskRequest)
{
var createdHistory = await _historyService.CreateTaskHistory(taskRequest);
return(Ok(createdHistory));
}
