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")); }