public async Task <IActionResult> PutWorkTaskAsync([FromBody] WorkTaskResource newWorkTaskResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
if (newWorkTaskResource == null)
{
return(BadRequest($"Parameter {nameof(newWorkTaskResource)} is null"));
}
mLogger.LogDebug($"Requesting putting new task {newWorkTaskResource.Description} to group {newWorkTaskResource.GroupName}");
try
{
IResponse <IWorkTask> result =
await mTasksGroupService.SaveTaskAsync(newWorkTaskResource.GroupName, newWorkTaskResource.Description)
.ConfigureAwait(false);
if (!result.IsSuccess)
{
return(StatusCode(StatusCodes.Status405MethodNotAllowed, result.Message));
}
WorkTaskResource workTaskResource = mMapper.Map <IWorkTask, WorkTaskResource>(result.ResponseObject);
return(Ok(workTaskResource));
}
catch (Exception ex)
{
mLogger.LogError(ex, "Put operation failed with error");
return(new StatusCodeResult(StatusCodes.Status500InternalServerError));
}
}
public async Task <IActionResult> RemoveTask(string id)
{
mLogger.LogDebug($"Requesting deleting task id {id}");
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
try
{
IResponse <IWorkTask> result = await mTasksGroupService.RemoveTaskAsync(id).ConfigureAwait(false);
mLogger.LogDebug($"Remove result {(result.IsSuccess ? "succeeded" : "failed")}");
if (!result.IsSuccess)
{
return(StatusCode(StatusCodes.Status405MethodNotAllowed, result.Message));
}
WorkTaskResource workTaskResource = mMapper.Map <IWorkTask, WorkTaskResource>(result.ResponseObject);
return(Ok(workTaskResource));
}
catch (Exception ex)
{
mLogger.LogError(ex, "Remove operation failed with error");
return(new StatusCodeResult(StatusCodes.Status500InternalServerError));
}
}
public async Task PutWorkTaskAsync_RequestSuccess_ExpectedResourceReturned()
{
IWorkTask expectedWorkTask = A.Fake <IWorkTask>();
A.CallTo(() => expectedWorkTask.Description).Returns("description");
A.CallTo(() => expectedWorkTask.GroupName).Returns("newGroupName");
ITasksGroupService tasksGroupService = A.Fake <ITasksGroupService>();
A.CallTo(() => tasksGroupService.SaveTaskAsync(expectedWorkTask.GroupName, expectedWorkTask.Description))
.Returns(new SuccessResponse <IWorkTask>(expectedWorkTask));
using TestServer testServer = ApiTestHelper.BuildTestServerWithFakes(tasksGroupService);
using HttpClient httpClient = testServer.CreateClient();
WorkTaskResource workTaskResource = new WorkTaskResource
{
GroupName = expectedWorkTask.GroupName,
Description = expectedWorkTask.Description
};
using StringContent jsonContent =
new StringContent(JsonConvert.SerializeObject(workTaskResource), Encoding.UTF8, PostMediaType);
using HttpResponseMessage response = await httpClient.PutAsync(MainRoute, jsonContent).ConfigureAwait(false);
string stringResponse = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
WorkTaskResource returnedResource = JsonConvert.DeserializeObject <WorkTaskResource>(stringResponse);
Assert.Equal(expectedWorkTask.GroupName, returnedResource.GroupName);
Assert.Equal(expectedWorkTask.Description, returnedResource.Description);
}
private async Task <int> ChangeTaskStatus(string taskId, string reason, string newStatus)
{
if (string.IsNullOrEmpty(taskId))
{
mLogger.LogError("No task id given");
return(1);
}
WorkTaskResource workTaskResource = new WorkTaskResource
{
TaskId = taskId,
Status = newStatus,
Reason = reason
};
Uri taskUri = TaskerUris.WorkTasksUri.CombineRelative(taskId);
using HttpRequestMessage httpRequestMessage = new HttpRequestMessage(HttpMethod.Post, taskUri)
{
Content = new StringContent(JsonConvert.SerializeObject(workTaskResource), Encoding.UTF8, PostMediaType)
};
WorkTaskResource workTaskResourceResponse = await HttpMessageRequester.SendHttpRequestMessage <WorkTaskResource>(
mHttpClient, httpRequestMessage, mLogger).ConfigureAwait(false);
if (workTaskResourceResponse != null)
{
mLogger.LogInformation($"Changed status of task {workTaskResourceResponse.TaskId} " +
$"{workTaskResourceResponse.Description} to {newStatus}");
}
return(0);
}
private async Task <int> CreateNewTask(string taskGroupName, string description)
{
if (string.IsNullOrWhiteSpace(description))
{
mLogger.LogError($"{nameof(description)} is null or empty");
return(1);
}
WorkTaskResource workTaskResource = new WorkTaskResource
{
GroupName = taskGroupName,
Description = description
};
using HttpRequestMessage httpRequestMessage = new HttpRequestMessage(HttpMethod.Put, TaskerUris.WorkTasksUri)
{
Content = new StringContent(JsonConvert.SerializeObject(workTaskResource), Encoding.UTF8, PostMediaType)
};
WorkTaskResource workTaskResponse = await HttpMessageRequester.SendHttpRequestMessage <WorkTaskResource>(
mHttpClient, httpRequestMessage, mLogger).ConfigureAwait(false);
if (workTaskResponse != null)
{
mLogger.LogInformation($"Created new task id {workTaskResponse.TaskId} '{workTaskResponse.Description}' at group {workTaskResponse.GroupName}");
}
return(0);
}
public async Task PutWorkTaskAsync_InvalidWorkTaskResourceException_BadRequestReturned()
{
using TestServer testServer = ApiTestHelper.BuildTestServerWithFakes();
using HttpClient httpClient = testServer.CreateClient();
WorkTaskResource workTaskResource = new WorkTaskResource {
GroupName = "newGroupName"
};
using StringContent jsonContent = new StringContent("invalidResource", Encoding.UTF8, PostMediaType);
using HttpResponseMessage response = await httpClient.PutAsync(MainRoute, jsonContent).ConfigureAwait(false);
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
}
public async Task PutWorkTaskAsync_ThrowsException_InternalServerErrorStatusCode()
{
ITasksGroupService fakeTasksGroupService = A.Fake <ITasksGroupService>();
A.CallTo(() => fakeTasksGroupService.SaveTaskAsync(A <string> .Ignored, A <string> .Ignored))
.Throws <Exception>();
using TestServer testServer = ApiTestHelper.BuildTestServerWithFakes(fakeTasksGroupService);
using HttpClient httpClient = testServer.CreateClient();
WorkTaskResource workTaskResource = new WorkTaskResource {
GroupName = "newGroupName", Description = "description"
};
using StringContent jsonContent = new StringContent(JsonConvert.SerializeObject(workTaskResource), Encoding.UTF8, PostMediaType);
using HttpResponseMessage response = await httpClient.PutAsync(MainRoute, jsonContent).ConfigureAwait(false);
Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
}
public async Task PutWorkTaskAsync_RequestSuccess_SuccessStatusCode()
{
WorkTaskResource workTaskResource = new WorkTaskResource {
GroupName = "newGroupName", Description = "description"
};
ITasksGroupService tasksGroupService = A.Fake <ITasksGroupService>();
A.CallTo(() => tasksGroupService.SaveTaskAsync(workTaskResource.GroupName, workTaskResource.Description))
.Returns(new SuccessResponse <IWorkTask>(A.Fake <IWorkTask>()));
using TestServer testServer = ApiTestHelper.BuildTestServerWithFakes(tasksGroupService);
using HttpClient httpClient = testServer.CreateClient();
using StringContent jsonContent =
new StringContent(JsonConvert.SerializeObject(workTaskResource), Encoding.UTF8, PostMediaType);
using HttpResponseMessage response = await httpClient.PutAsync(MainRoute, jsonContent).ConfigureAwait(false);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
public async Task PutWorkTaskAsync_RequestNotSuccess_MethodNotAllowedReturned()
{
ITasksGroupService taskGroupService = A.Fake <ITasksGroupService>();
A.CallTo(() => taskGroupService.SaveTaskAsync(A <string> .Ignored, A <string> .Ignored))
.Returns(new FailResponse <IWorkTask>(""));
using TestServer testServer = ApiTestHelper.BuildTestServerWithFakes(taskGroupService);
using HttpClient httpClient = testServer.CreateClient();
WorkTaskResource workTaskResource = new WorkTaskResource {
GroupName = "newGroupName"
};
using StringContent jsonContent = new StringContent(JsonConvert.SerializeObject(workTaskResource), Encoding.UTF8, PostMediaType);
using HttpResponseMessage response = await httpClient.PutAsync(MainRoute, jsonContent).ConfigureAwait(false);
A.CallTo(() => taskGroupService.SaveTaskAsync(A <string> .Ignored, A <string> .Ignored)).MustHaveHappenedOnceExactly();
Assert.Equal(HttpStatusCode.MethodNotAllowed, response.StatusCode);
}
private async Task <int> RemoveTask(string taskId)
{
if (string.IsNullOrEmpty(taskId))
{
mLogger.LogError("No task id given to remove");
return(1);
}
Uri taskUri = TaskerUris.WorkTasksUri.CombineRelative(taskId);
using HttpRequestMessage httpRequestMessage = new HttpRequestMessage(HttpMethod.Delete, taskUri);
WorkTaskResource workTaskResource = await HttpMessageRequester.SendHttpRequestMessage <WorkTaskResource>(
mHttpClient, httpRequestMessage, mLogger).ConfigureAwait(false);
if (workTaskResource != null)
{
mLogger.LogInformation($"Delete task id {workTaskResource.TaskId}. Description: {workTaskResource.Description}");
}
return(0);
}
private async Task <int> MoveTask(string taskId, string taskGroup)
{
if (string.IsNullOrEmpty(taskId))
{
mLogger.LogError("No task id given to move");
return(1);
}
if (string.IsNullOrEmpty(taskGroup))
{
mLogger.LogError("No group name or group id given");
return(1);
}
WorkTaskResource workTaskResource = new WorkTaskResource
{
TaskId = taskId,
GroupName = taskGroup
};
Uri taskUri = TaskerUris.WorkTasksUri.CombineRelative(taskId);
using HttpRequestMessage httpRequestMessage = new HttpRequestMessage(HttpMethod.Post, taskUri)
{
Content = new StringContent(JsonConvert.SerializeObject(workTaskResource), Encoding.UTF8, PostMediaType)
};
WorkTaskResource workTaskResourceResponse = await HttpMessageRequester.SendHttpRequestMessage <WorkTaskResource>(
mHttpClient, httpRequestMessage, mLogger).ConfigureAwait(false);
if (workTaskResourceResponse != null)
{
mLogger.LogInformation($"Moved task {workTaskResourceResponse.TaskId} {workTaskResourceResponse.Description}" +
$"to group {taskGroup}");
}
return(0);
}
public async Task <IActionResult> PostTaskAsync(string id, [FromBody] WorkTaskResource saveWorkTaskResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
if (saveWorkTaskResource == null)
{
return(BadRequest("Work task resource is null"));
}
mLogger.LogDebug($"Requesting updating work task id {id}");
try
{
saveWorkTaskResource.TaskId = id;
IResponse <IWorkTask> result =
await mTasksGroupService.UpdateTaskAsync(saveWorkTaskResource).ConfigureAwait(false);
mLogger.LogDebug($"Update result {(result.IsSuccess ? "succeeded" : "failed")}");
if (!result.IsSuccess)
{
return(StatusCode(StatusCodes.Status405MethodNotAllowed, result.Message));
}
WorkTaskResource workTaskResource = mMapper.Map <IWorkTask, WorkTaskResource>(result.ResponseObject);
return(Ok(workTaskResource));
}
catch (Exception ex)
{
mLogger.LogError(ex, "Update operation failed with error");
return(new StatusCodeResult(StatusCodes.Status500InternalServerError));
}
}
public async Task <IResponse <IWorkTask> > UpdateTaskAsync(WorkTaskResource workTaskResource)
{
try
{
if (string.IsNullOrEmpty(workTaskResource.TaskId))
{
return(new FailResponse <IWorkTask>("Task id is invalid (null or empty)"));
}
if (!string.IsNullOrEmpty(workTaskResource.Description))
{
return(await UpdateDescriptionAsync(workTaskResource.TaskId, workTaskResource.Description)
.ConfigureAwait(false));
}
if (!string.IsNullOrEmpty(workTaskResource.Status))
{
return(await UpdateStatusAsync(workTaskResource.TaskId, workTaskResource.Status, workTaskResource.Reason)
.ConfigureAwait(false));
}
if (!string.IsNullOrEmpty(workTaskResource.GroupName))
{
return(await MoveTaskAsync(workTaskResource.TaskId, workTaskResource.GroupName)
.ConfigureAwait(false));
}
return(new FailResponse <IWorkTask>("Work task resource does not contain update information as " +
"description or group name"));
}
catch (Exception ex)
{
return(new FailResponse <IWorkTask>(
$"An error occurred when updating work task id {workTaskResource.TaskId}: {ex.Message}"));
}
}
