public Task UpdateTask(Task task, TaskUpdateRequest taskUpdateRequest)
{
task.Name = taskUpdateRequest.Name;
task.Description = taskUpdateRequest.Description;
return(task);
}
/// <summary>
/// Update a task. This will cancel all queued runs.
/// </summary>
/// <param name="taskId">ID of task to get</param>
/// <param name="request">task update to apply</param>
/// <returns>task updated</returns>
public async Task <TaskType> UpdateTask(string taskId, TaskUpdateRequest request)
{
Arguments.CheckNonEmptyString(taskId, nameof(taskId));
Arguments.CheckNotNull(request, nameof(request));
return(await _service.PatchTasksIDAsync(taskId, request));
}
public async Task <IActionResult> UpdateTask(
[FromBody] TaskUpdateRequest task,
CancellationToken cancellationToken = default)
{
try
{
_dbContext
.Tasks
.Update(task.Map());
var state = await _dbContext.SaveChangesAsync();
return(Ok(state));
}
catch (DbUpdateException ex)
when(ex.IsPgSqlKeyViolationException())
{
return(Conflict(ex.InnerException.Message));
}
catch (DbUpdateException ex)
{
return(BadRequest(ex.Message));
}
catch (Exception ex)
{
return(StatusCode((int)HttpStatusCode.InternalServerError, ex.Message));
}
}
public async Task <IActionResult> TaskUpdate(TaskUpdateRequest request)
{
request.UserId = this.GetUserId();
var response = await _activitiesService.TaskUpdate(request);
return(Ok(response));
}
internal async Task <string> ProcessAsync(string baseAddress)
{
using (var httpClient = new HttpClient())
{
httpClient.BaseAddress = new Uri(baseAddress);
// TODO create a stop mechanism. Ugly but it will work for now. If you want to stop it just close the application.
while (true)
{
HttpResponseMessage pollResponseMessage;
do
{
pollResponseMessage = await httpClient.GetAsync("api/tasks/poll/task_10");
Thread.Sleep(1000);
} while (pollResponseMessage.StatusCode == System.Net.HttpStatusCode.NoContent);
if (!pollResponseMessage.IsSuccessStatusCode)
{
System.Console.WriteLine($"A problem has occurred during task 10 polling. Status code: {pollResponseMessage.StatusCode}");
continue;
}
string task1PollJsonResponse = await pollResponseMessage?.Content?.ReadAsStringAsync();
TaskPollResponse taskPollResponse = JsonConvert.DeserializeObject <TaskPollResponse>(task1PollJsonResponse);
var taskUpdateRequest = new TaskUpdateRequest();
taskUpdateRequest.TaskId = taskPollResponse.TaskId;
taskUpdateRequest.WorkflowInstanceId = taskPollResponse.WorkflowInstanceId;
taskUpdateRequest.OutputData = new OutputData
{
Mod = taskPollResponse?.InputData?.Mod,
OddEven = taskPollResponse?.InputData?.OddEven
};
taskUpdateRequest.Status = Constants.TaskStatuses.COMPLETED;
var stringContent = new StringContent(JsonConvert.SerializeObject(taskUpdateRequest), Encoding.UTF8, "application/json");
HttpResponseMessage responseMessage = await httpClient.PostAsync("api/tasks/", stringContent);
if (!responseMessage.IsSuccessStatusCode)
{
System.Console.WriteLine($"A problem has occurred during task 10 update. Status code: {pollResponseMessage.StatusCode}");
continue;
}
System.Console.WriteLine($"Task10 Worker Processed task: {await responseMessage.Content.ReadAsStringAsync()}");
Thread.Sleep(1000);
}
// TODO Send the received ID through an event
return(null);
}
}
/// <summary>
/// Update a task. This will cancel all queued runs.
/// </summary>
/// <param name="task">task update to apply</param>
/// <returns>task updated</returns>
public async Task <TaskType> UpdateTask(TaskType task)
{
Arguments.CheckNotNull(task, nameof(task));
var status = (TaskStatusType)Enum.Parse(typeof(TaskStatusType), task.Status.ToString());
var request = new TaskUpdateRequest(status, task.Flux, task.Name, task.Every, task.Cron);
return(await UpdateTask(task.Id, request));
}
public void Set(TaskUpdateRequest request)
{
UpdatedOnUtc = DateTime.UtcNow;
if (request.Name != null)
{
Name = request.Name.Trim();
}
if (request.Description != null)
{
Description = request.Description.Trim();
}
ProjectIdentifier = request.ProjectIdentifier;
}
public Response Put(TaskUpdateRequest request, string taskType = null, string taskName = null)
{
CheckMinerOwnerShip();
var hasTaskType = !string.IsNullOrEmpty(taskType);
var hasTaskName = !string.IsNullOrEmpty(taskName);
if (!request.IsCancelation)
{
throw new Exception("Unsupported task update request.");
}
if (!hasTaskType && !hasTaskName)
{
this.LISpMiner.CancelAll();
return(new Response
{
Message = "All tasks has been canceled."
});
}
else if (hasTaskType && !hasTaskName)
{
Type type = this.GetTaskLauncher(taskType);
this.LISpMiner.CancelAll(type);
return(new Response
{
Message = "All tasks has been canceled."
});
}
else if (hasTaskType && hasTaskName)
{
var type = this.GetTaskLauncher(taskType);
this.LISpMiner.Cancel(type, taskName);
return(new Response
{
Message = String.Format("Task {0} has been canceled.", taskName)
});
}
else // if (!hasTaskType && hasTaskName)
{
throw new ArgumentException();
}
}
public async Task <TaskUpdateResponse> TaskUpdate(TaskUpdateRequest request)
{
TaskUpdateResponse response;
var board = await _boardRepository.GetAsync(request.BoardId);
if (board == null)
{
response = new TaskUpdateResponse {
Data = null
};
response.Failed(_errorService.GetError(ErrorType.ItemNotFound));
return(response);
}
if (board.CreatedById != request.UserId)
{
response = new TaskUpdateResponse {
Data = null
};
response.Failed(_errorService.GetError(ErrorType.AccessDenied));
return(response);
}
var task = board.Tasks.Single(t => t.Id == request.Id);
if (task == null)
{
response = new TaskUpdateResponse {
Data = null
};
response.Failed(_errorService.GetError(ErrorType.ItemNotFound));
return(response);
}
_taskCreator.UpdateTask(task, request);
await _boardRepository.UpdateTaskAsync(board.Id, task);
response = _taskCreator.CreateTaskUpdateResponse(task);
response.Succeeded();
return(response);
}
public async Task <IActionResult> UpdateTask(TaskUpdateRequest request)
{
if (!ModelState.IsValid)
{
return(StatusCode(400));
}
var dto = _mapper.Map <TaskUpdateDTO>(request);
dto.DateUpdated = DateTime.Now;
if (await _manager.UpdateTask(dto))
{
return(StatusCode(202));
}
throw new Exception();
}
public void UpdateTask(TaskUpdateRequest model, int id)
{
using (SqlConnection conn = new SqlConnection(connectionString))
{
conn.Open();
SqlCommand cmd = conn.CreateCommand();
cmd.CommandText = "dbo.Task_Update";
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@Id", id);
cmd.Parameters.AddWithValue("@Name", model.Name);
cmd.Parameters.AddWithValue("@StartTime", model.StartTime);
cmd.Parameters.AddWithValue("@Deadline", model.Deadline);
cmd.ExecuteNonQuery();
conn.Close();
}
}
public TaskUpdate(TaskUpdateRequest request)
{
if (request != null)
{
using (var dbContext = new ApplicationDbContext())
{
var task = dbContext.Tasks.SingleOrDefault(aTask => aTask.Identifier == request.Identifier);
var project = dbContext.Projects.SingleOrDefault(aProject => aProject.Identifier == request.ProjectIdentifier);
if (task == null)
{
Response = new TaskUpdateResponse
{
Type = TaskUpdateResponseType.TaskDoesNotExist
};
return;
}
if (project == null)
{
Response = new TaskUpdateResponse
{
Type = TaskUpdateResponseType.ProjectDoesNotExist
};
return;
}
task.Set(request);
dbContext.SaveChanges();
Response = new TaskUpdateResponse
{
Type = TaskUpdateResponseType.Success
};
}
}
}
internal async Task <string> ProcessAsync(string baseAddress)
{
using (var httpClient = new HttpClient())
{
httpClient.BaseAddress = new Uri(baseAddress);
// TODO create a stop mechanism. Ugly but it will work for now. If you want to stop it just close the application.
while (true)
{
HttpResponseMessage pollResponseMessage;
do
{
pollResponseMessage = await httpClient.GetAsync("api/tasks/poll/task_5");
Thread.Sleep(1000);
} while (pollResponseMessage.StatusCode == System.Net.HttpStatusCode.NoContent);
if (!pollResponseMessage.IsSuccessStatusCode)
{
System.Console.WriteLine($"A problem has occurred during task 5 polling. Status code: {pollResponseMessage.StatusCode}");
continue;
}
string task1PollJsonResponse = await pollResponseMessage?.Content?.ReadAsStringAsync();
TaskPollResponse taskPollResponse = JsonConvert.DeserializeObject <TaskPollResponse>(task1PollJsonResponse);
int?oddEven = taskPollResponse?.InputData?.OddEven;
var taskUpdateRequest = new TaskUpdateRequest();
switch (oddEven)
{
case 0:
var dynamicForkOutputData = new DynamicForkOutputData();
dynamicForkOutputData.DynamicTasks = taskPollResponse.InputData.DynamicTasks;
dynamicForkOutputData.Inputs = taskPollResponse.InputData.Inputs;
taskUpdateRequest.OutputData = dynamicForkOutputData;
break;
case 1:
taskUpdateRequest.OutputData = new OutputData();
taskUpdateRequest.OutputData.Mod = taskPollResponse?.InputData?.Mod;
break;
default:
taskUpdateRequest.OutputData = new OutputData();
break;
}
taskUpdateRequest.TaskId = taskPollResponse.TaskId;
taskUpdateRequest.WorkflowInstanceId = taskPollResponse.WorkflowInstanceId;
taskUpdateRequest.Status = Constants.TaskStatuses.COMPLETED;
taskUpdateRequest.OutputData.OddEven = oddEven;
// TODO Remove fixed address from code
taskUpdateRequest.OutputData.ElasticSearchHost = "192.168.137.93";
var stringContent = new StringContent(JsonConvert.SerializeObject(taskUpdateRequest), Encoding.UTF8, "application/json");
HttpResponseMessage responseMessage = await httpClient.PostAsync("api/tasks/", stringContent);
if (!responseMessage.IsSuccessStatusCode)
{
System.Console.WriteLine($"A problem has occurred during task 5 update. Status code: {pollResponseMessage.StatusCode}");
continue;
}
System.Console.WriteLine($"Task5 Worker Processed task: {await responseMessage.Content.ReadAsStringAsync()}");
Thread.Sleep(1000);
}
// TODO Send the received ID through an event
return(null);
}
}
public async Task <TaskUpdateResponse> TaskUpdate(TaskUpdateRequest request)
{
return(await _taskUpdateRequest.Request(request));
}
public TaskCancelationRequest(TaskUpdateRequest request)
: base(request.Controller.LISpMiner, request.HttpContext)
{
this.Request = request;
}
public async Task ProcessAsync(string baseAddress)
{
using (var httpClient = new HttpClient())
{
httpClient.BaseAddress = new Uri(baseAddress);
// TODO create a stop mechanism. Ugly but it will work for now. If you want to stop it just close the application.
while (true)
{
HttpResponseMessage pollResponseMessage;
do
{
pollResponseMessage = await httpClient.GetAsync("api/tasks/poll/task_1");
Thread.Sleep(1000);
} while (pollResponseMessage.StatusCode == System.Net.HttpStatusCode.NoContent);
if (!pollResponseMessage.IsSuccessStatusCode)
{
System.Console.WriteLine($"A problem has occurred during task 1 polling. Status code: {pollResponseMessage.StatusCode}");
continue;
}
string task1PollJsonResponse = await pollResponseMessage?.Content?.ReadAsStringAsync();
TaskPollResponse taskPollResponse = JsonConvert.DeserializeObject <TaskPollResponse>(task1PollJsonResponse);
int?oddEven = taskPollResponse?.InputData?.OddEven;
var taskUpdateRequest = new TaskUpdateRequest();
switch (oddEven)
{
case 0:
const string TASK_1 = "task_1";
const string TASK_1_1 = "task_1_1";
const string WF_DYN = "wf_dyn";
var dynamicForkOutputData = new DynamicForkOutputData();
dynamicForkOutputData.TaskToExecute = TASK_1;
dynamicForkOutputData.DynamicTasks = new List <DynamicTask>();
dynamicForkOutputData.DynamicTasks.Add(new SimpleDynamicTask
{
Name = TASK_1,
TaskReferenceName = TASK_1_1,
});
dynamicForkOutputData.DynamicTasks.Add(new SubWorkFlowDynamicTask
{
Name = "sub_workflow_4",
TaskReferenceName = WF_DYN,
SubWorkflowParam = new SubWorkFlowParameter
{
Name = "sub_flow_1"
}
});
dynamicForkOutputData.Inputs = new JRaw($"{{\"{TASK_1_1}\": {{}}, \"{WF_DYN}\": {{}}}}");
taskUpdateRequest.OutputData = dynamicForkOutputData;
break;
case 1:
taskUpdateRequest.OutputData = new OutputData();
taskUpdateRequest.OutputData.Mod = taskPollResponse?.InputData?.Mod;
break;
default:
taskUpdateRequest.OutputData = new OutputData();
break;
}
taskUpdateRequest.TaskId = taskPollResponse.TaskId;
taskUpdateRequest.WorkflowInstanceId = taskPollResponse.WorkflowInstanceId;
taskUpdateRequest.Status = Constants.TaskStatuses.COMPLETED;
taskUpdateRequest.OutputData.OddEven = oddEven;
var stringContent = new StringContent(JsonConvert.SerializeObject(taskUpdateRequest), Encoding.UTF8, "application/json");
HttpResponseMessage responseMessage = await httpClient.PostAsync("api/tasks/", stringContent);
if (!responseMessage.IsSuccessStatusCode)
{
System.Console.WriteLine($"A problem has occurred during task 1 update. Status code: {pollResponseMessage.StatusCode}");
continue;
}
System.Console.WriteLine($"Task1 Worker Processed task: {await responseMessage.Content.ReadAsStringAsync()}");
Thread.Sleep(1000);
}
}
}
public TaskUpdateResponse TaskUpdate(TaskUpdateRequest request) => new TaskUpdate(request).Response;
