public UpdateTaskModel Put(int id, [FromBody] UpdateTaskModel taskModel)
{
var task = _mapper.Map <UpdateTaskModel, Task>(taskModel);
_taskService.UpdateTask(id, task);
return(taskModel);
}
public async Task <IActionResult> ChangeTask([FromBody] UpdateTaskModel updateTaskModel)
{
NewResponseModel newTaskResponseModel = new NewResponseModel();
try
{
Data.Models.Task task = await _db.GetTask(updateTaskModel.Task.Id); //Data.Task.FirstAsync(c => c.Id == updateTaskModel.Task.Id);
task.Name = updateTaskModel.TaskName;
task.Description = updateTaskModel.TaskDescription;
task.UserId = updateTaskModel.UserId;
task.StatusId = updateTaskModel.StatusId;
task.EndDate = updateTaskModel.TaskFinishDate;
/*newTaskResponseModel =*/ await _db.ChangeTask(task);
newTaskResponseModel.CreatedId = task.Id;
newTaskResponseModel.Message = "Success !!!";
return(Ok(newTaskResponseModel));
}
catch (Exception ex)
{
newTaskResponseModel.Message = ex.Message;
return(BadRequest(newTaskResponseModel));
}
}
public async Task <IActionResult> ToggleCompleted([FromQuery] Guid taskId)
{
return(await ProcessAsync(async() =>
{
var user = await UserService.GetUserByPrincipal(User);
var task = await _taskService.GetById(taskId);
if (await AuthoriseUpdate(task, user.Id))
{
var model = new UpdateTaskModel
{
Id = task.Id,
Description = task.Description,
TypeId = task.TypeId,
Title = task.Title,
Completed = !task.Completed,
AssignedToId = task.AssignedToId,
DueDate = task.DueDate
};
await _taskService.Update(model);
return Ok("Task toggled successfully.");
}
return Forbid();
}));
}
public async Task <bool> UpdateTask(string uri, UpdateTaskModel data, string token = "", string header = "")
{
HttpClient httpClient = CreateHttpClient(token);
if (!string.IsNullOrEmpty(header))
{
AddHeaderParameter(httpClient, header);
}
#region File
//var content = new StringContent(JsonConvert.SerializeObject(data));
//content.Headers.ContentType = new MediaTypeHeaderValue("multipart/form-data");
HttpContent file = new StreamContent(data.File.StreamSource);
file.Headers.ContentDisposition = new System.Net.Http.Headers.ContentDispositionHeaderValue("form-data")
{
Name = "file", FileName = data.File.FileName
};
file.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/octet-stream");
#endregion
var formData = new MultipartFormDataContent();
formData.Add(file);
formData.Add(new StringContent(data.Id.ToString()), "Id");
formData.Add(new StringContent(data.Note != null ? data.Note : ""), "Note");
HttpResponseMessage response = await httpClient.PostAsync(uri, formData);
await HandleResponse(response);
if (response.StatusCode == HttpStatusCode.OK)
{
return(true);
}
return(false);
}
public async Task <IActionResult> UpdateTask([FromBody] UpdateTaskModel taskModel)
{
await _taskService.UpdateTask(taskModel.IdPreviousTask, new TaskDto()
{
Name = taskModel.NameTask, Description = taskModel.Description
});
return(Ok(true));
}
private async Task <bool> AuthoriseUpdate(TaskModel model, Guid userId)
{
var updateModel = new UpdateTaskModel
{
AssignedToId = model.AssignedToId,
Description = model.Description,
TypeId = model.TypeId,
Title = model.Title,
DueDate = model.DueDate,
Completed = model.Completed,
Id = model.Id
};
return(await AuthoriseUpdate(updateModel, userId));
}
public async System.Threading.Tasks.Task ChangeTask(SharedServicesModule.Models.Task task, string taskName, string taskDescription, int userId, DateTime taskFinishDate)
{
try
{
UpdateTaskModel updateTaskModel = new UpdateTaskModel()
{
Task = task, TaskName = taskName, TaskDescription = taskDescription, UserId = userId, TaskFinishDate = taskFinishDate
};
string json = JsonConvert.SerializeObject(updateTaskModel);
await RequestService.Put("https://localhost:44316/api/tasks/", json);
}
catch
{
throw;
}
}
public async Task <IActionResult> Update([FromBody] UpdateTaskModel model)
{
try
{
if (await CanUpdateTask(model.Id))
{
await _taskService.Update(model);
return(Ok());
}
return(Error(HttpStatusCode.Forbidden, "You do not have permission to access this task"));
}
catch (Exception e)
{
return(HandleException(e));
}
}
public async Task <IActionResult> Update([FromForm] UpdateTaskModel model)
{
return(await ProcessAsync(async() =>
{
var user = await UserService.GetUserByPrincipal(User);
var canEdit = await AuthoriseUpdate(model, user.Id);
if (canEdit)
{
await _taskService.Update(model);
return Ok("Task updated successfully.");
}
return Forbid();
}));
}
public async Task ChangeTask(SharedServicesModule.Models.Task task, string taskName, string taskDescription, int userId, int statusId, DateTime taskFinishDate)
{
try
{
UpdateTaskModel updateTaskModel = new UpdateTaskModel()
{
Task = task,
TaskName = taskName,
TaskDescription = taskDescription,
UserId = userId, StatusId = statusId,
TaskFinishDate = taskFinishDate
};
string json = JsonConvert.SerializeObject(updateTaskModel);
await RequestService.Put(Consts.BaseAddress + "api/tasks/", json);
}
catch
{
throw;
}
}
public HttpResponseMessage Task(UpdateTaskModel model)
{
using (var repo = new TaskRepository(_taskDataContext))
{
var task = repo.GetTask(model.TaskId);
if (task == null)
{
return(Utils.Invalid("Unable to find task to update"));
}
task = model.Map();
var response = new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(repo.Update(task).ToJson(), Encoding.UTF8, "application/json")
};
return(response);
}
}
private async Task <bool> AuthoriseUpdate(UpdateTaskModel model, Guid userId)
{
if (TaskTypes.IsReserved(model.TypeId))
{
return(false);
}
if (await _taskService.IsTaskOwner(model.Id, userId))
{
return(true);
}
var taskPersonTypes = await _personService.GetPersonTypes(model.AssignedToId);
if (taskPersonTypes.Student)
{
return(User.IsType(UserTypes.Staff));
}
if (taskPersonTypes.Employee)
{
if (await UserHasPermission(Permissions.People.StaffTasks.EditAllStaffTasks))
{
return(true);
}
var taskStaffMember = await _staffMemberService.GetByPersonId(model.AssignedToId, false);
var userStaffMember = await _staffMemberService.GetByUserId(userId, false);
if (userStaffMember != null && taskStaffMember != null &&
await UserHasPermission(Permissions.People.StaffTasks.EditManagedStaffTasks) &&
await _staffMemberService.IsLineManager(taskStaffMember.Id, userStaffMember.Id))
{
return(true);
}
}
return(false);
}
public async System.Threading.Tasks.Task UpdateTaskAsync(Guid id, UpdateTaskModel updateTaskModel)
{
var task = _taskRepository.GetByID(id);
if (task == null)
{
throw new GenericAppException($"Task with id {id} not found");
}
if (task.Status != updateTaskModel.Status)
{
task.UpdateStatus(updateTaskModel.Status);
}
if (!string.IsNullOrEmpty(updateTaskModel.Description) && updateTaskModel.Description != task.Description)
{
task.UpdateDescription(updateTaskModel.Description);
}
_taskRepository.Update(task);
await _taskRepository.SaveChangesAsync();
}
public async Task <bool> UpdateTaskAsync(Guid userId, UpdateTaskModel model)
{
try
{
var access = await _securityService.GetUserAccessAsync(userId, model.ProjectId);
if (access[UserAction.UPDATE_TASK])
{
return(false);
}
var task = await _context.Tasks.FindAsync(model.TaskId);
if (task == null)
{
return(false);
}
var user = await _context.Users.SingleOrDefaultAsync(x => x.Email == model.AssigneeEmail);
var assignee = await _context.ProjectUsers.SingleOrDefaultAsync(x => x.ProjectId == model.ProjectId && x.UserId == user.Id);
task.Title = model.Title;
task.Content = model.Content;
task.Priority = model.Priority;
task.Type = model.Type;
task.Severity = model.Severity;
task.AssigneeId = assignee?.UserId;
_context.Update(task);
await _context.SaveChangesAsync();
}
catch (Exception e)
{
_logger.LogError("TaskService: UpdateTaskAsync", e);
}
return(false);
}
public IActionResult UpdateTaskById(UpdateTaskModel model)
{
ProjectTask projectTask = model.ProjectTask;
projectTask.Employee = new Employee()
{
Id = model.EmployeeId
};
projectTask.Project = new Project()
{
Id = model.ProjectId
};
OperationStatusInfo operationStatusInfo = _hubEnvironment.ServerHubConnector.UpdateProjectTask(projectTask).Result;
if (operationStatusInfo.OperationStatus == OperationStatus.Done)
{
return(RedirectToAction("TaskList"));
}
else
{
return(RedirectToAction("UpdateTaskByIdPage"));
}
}
public async System.Threading.Tasks.Task <bool> Update(string token, UpdateTaskModel updateTaskModel)
{
var uri = UriHelper.CombineUri(_settingsService.EndPoint(), ApiUrlBase + "/Done");
return(await _requestProvider.UpdateTask(uri, updateTaskModel, token));
}
public async Task <ActionResult> Put([FromBody] UpdateTaskModel updateTaskModel)
{
var updatetask = await _taskService.UpdateTask(updateTaskModel);
return(Ok(updatetask));
}
public async Task <IActionResult> UpdateTask([FromBody] UpdateTaskModel model)
{
var result = await _taskService.UpdateTaskAsync(this.UserId(), model);
return(result ? (IActionResult)Ok(result) : BadRequest("Something went wrong, please try again later"));
}
public async Task <CommonResponse> UpdateTask(UpdateTaskModel updateTaskModel)
{
return(await ExecuteAll <CommonResponse>("Glo.UpdateTask", updateTaskModel));
}
/// <summary>
/// This method will used to Update the IsActive Status of the task
/// </summary>
public async Task <CommonResponse> UpdateTask(UpdateTaskModel updateTaskModel)
{
return(await _taskrepository.UpdateTask(updateTaskModel));
}
public async Task <IActionResult> UpdateTaskAsync([FromBody] UpdateTaskModel updateTaskModel, [FromRoute] Guid id)
{
await _taskService.UpdateTaskAsync(id, updateTaskModel);
return(Ok("Task Updated Successfully"));
}
