public void UpdateTaskNotFoundTest() { var testGuid = Guid.NewGuid(); var taskRequest = new UpdateTaskRequest(testGuid) { TaskProperties = new TaskEditDTO { Name = "test", Time = DateTime.Now, UserId = Guid.NewGuid() } }; var mockUow = new Mock <IUnitOfWork>(); var mockRepo = new Mock <ITaskRepository>(); mockRepo.Setup(x => x.FindBy(taskRequest.Id)).Returns((Domain.Task.Task)null); var mockMapper = new Mock <ITaskDtoMapper>(); var mockValidator = new Mock <IValidator <Domain.Task.Task> >(); var service = new TaskService(mockUow.Object, mockRepo.Object, mockMapper.Object, mockValidator.Object); var response = service.UpdateTask(taskRequest); Assert.IsFalse(response.Result); Assert.IsNotNull(response.Exception); Assert.AreEqual(typeof(ResourceNotFoundException), response.Exception.GetType()); mockRepo.Verify(x => x.Insert(It.IsAny <Domain.Task.Task>()), Times.Never); mockUow.Verify(x => x.Commit(), Times.Never); }
public TaskDTO UpdateTask(TodoContext context, UpdateTaskRequest updateTaskRequest) { _updateTaskRequestValidator.ValidateAndThrow(updateTaskRequest); var user = _authenticationService.GetUserBySessionToken( context, updateTaskRequest.SessionToken); var task = context.Tasks .Include("User") .SingleOrDefault(t => t.TaskId == updateTaskRequest.TaskId); if (task == null) { throw new TodoException(ServiceError.NoSuchTask); } if (task.UserId != user.UserId) { throw new TodoException(ServiceError.NoPermissions); } task.TaskDescription = updateTaskRequest.TaskDescription; task.ModifiedAt = _timeProvider.GetCurrentTime(); context.SaveChanges(); return(_taskToTaskDtoMapper.Map(task)); }
public async Task <TaskResponse> ExecuteAsync(int taskId, UpdateTaskRequest request) { Entities.Task task = await _factory .CreateAsyncQueryable(_uow.Tasks.Query()) .FirstOrDefaultAsync(tk => tk.Id == taskId); if (task == null) { return(null); } task.Tags = _uow.TagsInTasks.Query(t => t.Tag).Where(t => t.TaskId == task.Id).ToList(); task = _mapper.Map(request, task); foreach (var tagsInTask in task.Tags) { var tag = await _factory .CreateAsyncQueryable(_uow.Tags.Query()) .FirstOrDefaultAsync(t => t.Name == tagsInTask.Tag.Name); if (tag != null) { tagsInTask.Tag = tag; } } await _uow.CommitAsync(); task.Project = await _factory.CreateAsyncQueryable(_uow.Projects.Query(p => p.Tasks, p => p.User)) .FirstOrDefaultAsync(p => p.Id == task.ProjectId); return(_mapper.Map <Entities.Task, TaskResponse>(task)); }
void Awake() { Finished = Resources.Load <Sprite>("Sprites/Finished"); UnFinished = Resources.Load <Sprite>("Sprites/UnFinished"); UnConfirmed = Resources.Load <Sprite>("Sprites/UnConfirmed"); addPanel = transform.Find("AddPanel").gameObject; addPanel.SetActive(false); confirmPanel = transform.Find("ConfirmPanel").gameObject; confirmPanel.SetActive(false); layout = transform.Find("ScrollPanel/Layout"); confirmTaskRequest = GetComponent <ConfirmTaskRequest>(); addTaskRequest = GetComponent <AddTaskRequest>(); updateTaskRequest = GetComponent <UpdateTaskRequest>(); deleteTaskRequest = GetComponent <DeleteTaskRequest>(); transform.Find("BackButton").GetComponent <Button>().onClick.AddListener(Back); transform.Find("EditButton").GetComponent <Button>().onClick.AddListener(Edit); EditButtonText = transform.Find("EditButton").GetComponent <Text>(); addButton = transform.Find("AddButton").gameObject; addButton.GetComponent <Button>().onClick.AddListener(ShowAddPanel); transform.Find("ConfirmPanel/Panel/YesButton").GetComponent <Button>().onClick.AddListener(FinishTask); transform.Find("ConfirmPanel/Panel/NoButton").GetComponent <Button>().onClick.AddListener(UnFinishTask); addPanel.transform.Find("Panel/SaveButton").GetComponent <Button>().onClick.AddListener(Add); content = addPanel.transform.Find("Panel/Content").GetComponent <InputField>(); taskText = transform.Find("Task/TaskText").GetComponent <Text>(); fillImage = transform.Find("Task/FillImage").GetComponent <Image>(); score = fillImage.transform.Find("Score").GetComponent <Text>(); }
public async Task <IActionResult> UpdateTaskStatusAsync(Guid conferenceId, long taskId, [FromBody] UpdateTaskRequest updateTaskRequest) { _logger.LogDebug("UpdateTaskStatus"); try { var command = new UpdateTaskCommand(conferenceId, taskId, updateTaskRequest.UpdatedBy); await _commandHandler.Handle(command); } catch (TaskNotFoundException ex) { _logger.LogError(ex, "Unable to find task"); return(NotFound()); } var query = new GetTasksForConferenceQuery(conferenceId); var tasks = await _queryHandler.Handle <GetTasksForConferenceQuery, List <Task> >(query); var task = tasks.SingleOrDefault(x => x.Id == taskId); if (task == null) { _logger.LogError("Unable to find task"); return(NotFound()); } var response = TaskToResponseMapper.MapTaskToResponse(task); return(Ok(response)); }
public UpdateTaskResponse UpdateTask(UpdateTaskRequest request) { var response = new UpdateTaskResponse(); try { var existingTask = _taskRepository.FindBy(request.Id); if (existingTask != null) { _taskMapper.PopulateDomainObject(existingTask, request.TaskProperties); ThrowExceptionIfTaskIsInvalid(existingTask); _taskRepository.Update(existingTask); _uow.Commit(); response.Result = true; return(response); } response.Exception = GetStandardTaskNotFoundException(); return(response); } catch (Exception ex) { response.Exception = ex; return(response); } }
public async Task <TaskResponse> ExecuteAsync(UpdateTaskRequest request, int taskId) { var task = await _context.Tasks //.Include(t => t.Tags) //.Include(p => p.Project) .FirstOrDefaultAsync(t => t.Id == taskId); if (task == null) { throw new Exception("Такой задачи не существует не существует"); } task = Mapper.Map <Entities.Task>(request);//у реквеста нет проджекта. добавить проджект на таск task.Project = await _context.Projects //.Include(p => p.Tasks) .FirstOrDefaultAsync(p => p.Id == task.ProjectId); foreach (var tagsInTask in task.Tags) { var tag = await _context.Tags.FirstOrDefaultAsync(t => t.Name == tagsInTask.Tag.Name); if (tag != null) { tagsInTask.Tag = tag; } } await _context.SaveChangesAsync(); var response = Mapper.Map <TaskResponse>(task); return(response); }
public void UpdateTask_WhenSpecifiedTaskDoesExist_UpdatesSpecifiedTaskAndReturnsOkResult() { const int taskId = 1; var request = new UpdateTaskRequest(); var task = A.Fake <ITask>(); var taskRepository = A.Fake <ITaskRepository>(); A.CallTo(() => taskRepository.GetById(taskId)).Returns(task); var mapper = A.Fake <IMapper>(); var controller = new TaskController( taskRepository, mapper); var result = controller.UpdateTask(taskId, request) as OkResult; Assert.IsNotNull(result); A.CallTo(() => mapper.Map(request, task)).MustHaveHappened(); A.CallTo(() => taskRepository.SaveChanges()).MustHaveHappened(); }
public void UpdateTaskTest() { var testGuid = Guid.NewGuid(); var request = new UpdateTaskRequest(testGuid) { TaskProperties = new TaskEditDTO { Name = "test", Time = DateTime.Now, UserId = Guid.NewGuid() } }; var expectedResonse = new UpdateTaskResponse { Exception = null }; var mockService = new Mock <ITaskService>(); mockService.Setup(x => x.UpdateTask(request)).Returns(expectedResonse); var mockLogger = new Mock <ILoggingService>(); var mockEmail = new Mock <IEmailService>(); var mockConfig = new Mock <IAppConfig <IServiceConfigOptions> >(); var service = new EnrichedTaskService(mockService.Object, mockLogger.Object, mockEmail.Object, mockConfig.Object); var response = service.UpdateTask(request); Assert.IsNull(response.Exception); Assert.AreEqual(expectedResonse.Exception, response.Exception); mockService.Verify(x => x.UpdateTask(request), Times.Once); }
private Task CheckForTaskUpdate(IMessageHandlerContext context) { //If we have a response from the Task, we can update it. Can't be certain that the response is back before the fraud event arrives. if (Data.TaskCreatedResponse != null && Data.ReviewResult != null) { UpdateTaskRequest updateTask = new UpdateTaskRequest(); updateTask.TaskId = Data.TaskCreatedResponse.TaskId; updateTask.Subject = "Fraud Review"; Console.WriteLine($"Updating the task {updateTask.TaskId}. Mark Complete will be {Data.ReviewResult.Success}"); var fraudDetail = Data.ReviewResult.ResponseDescription; if (Data.ReviewResult.Success) { updateTask.Description = $"Automated Fraud Review Successful. Detail:{fraudDetail}"; updateTask.MarkComplete = true; } else { updateTask.Description = $"Automated Fraud Review Failure. It's up to you now. Detail:{fraudDetail}"; updateTask.MarkComplete = false; updateTask.AssignedToUserId = Data.NewCustomerEvent.CreatedById; } return(context.Send(updateTask)); } return(Task.CompletedTask); }
public void GivenNoExistingTaskCharacters_AddsTaskCharacters() { var task = new Task(DefaultPlayer.Id, TaskType.Achievement); var firstCharacter = new Character(); var secondCharacter = new Character(); Context.Tasks.Add(task); Context.Characters.AddRange(firstCharacter, secondCharacter); Context.SaveChanges(); // Arrange var dto = new UpdateTaskRequest() { TaskId = task.Id, Characters = new List <Guid>() { firstCharacter.Id, secondCharacter.Id } }; // Act var result = _controller.UpdateTask(dto); // Assert var foundTask = Context.Tasks.Find(result.Value); foundTask.Id.Should().Be(dto.TaskId); foundTask.TaskType.Should().Be(dto.TaskType); foundTask.TaskCharacters.Count.Should().Be(2); foundTask.TaskCharacters.Any(tc => tc.CharacterId == firstCharacter.Id).Should().BeTrue(); foundTask.TaskCharacters.Any(tc => tc.CharacterId == secondCharacter.Id).Should().BeTrue(); }
protected override void ProcessRecord() { base.ProcessRecord(); UpdateTaskRequest request; try { request = new UpdateTaskRequest { WorkspaceId = WorkspaceId, TaskKey = TaskKey, UpdateTaskDetails = UpdateTaskDetails, OpcRequestId = OpcRequestId, IfMatch = IfMatch }; response = client.UpdateTask(request).GetAwaiter().GetResult(); WriteOutput(response, response.Task); FinishProcessing(response); } catch (Exception ex) { TerminatingErrorDuringExecution(ex); } }
public void UpdateTaskInvalidTest() { var testGuid = Guid.NewGuid(); var taskRequest = new UpdateTaskRequest(testGuid) { TaskProperties = new TaskEditDTO { Name = null, Time = DateTime.Now, UserId = Guid.NewGuid() } }; var expectedTask = new Domain.Task.Task { Id = testGuid, Name = "test", Time = taskRequest.TaskProperties.Time, User = new Domain.User.User { Id = taskRequest.TaskProperties.UserId, FirstName = "test", LastName = "test", Address = new Address { Country = "UK" } } }; var expectedUpdatedTask = expectedTask; expectedUpdatedTask.Name = taskRequest.TaskProperties.Name; var mockUow = new Mock <IUnitOfWork>(); var mockRepo = new Mock <ITaskRepository>(); mockRepo.Setup(x => x.Update(expectedTask)); mockRepo.Setup(x => x.FindBy(taskRequest.Id)).Returns(expectedTask); var mockMapper = new Mock <ITaskDtoMapper>(); mockMapper.Setup(x => x.PopulateDomainObject(expectedTask, taskRequest.TaskProperties)) .Returns(expectedUpdatedTask); var mockValidator = new Mock <IValidator <Domain.Task.Task> >(); mockValidator.Setup(x => x.GetBrokenRules(expectedTask)).Returns(new List <BusinessRule> { TaskBusinessRules.TaskNameRequired }); var service = new TaskService(mockUow.Object, mockRepo.Object, mockMapper.Object, mockValidator.Object); var response = service.UpdateTask(taskRequest); Assert.IsFalse(response.Result); Assert.IsNotNull(response.Exception); Assert.AreEqual(typeof(ValidationException), response.Exception.GetType()); mockRepo.Verify(x => x.Insert(expectedTask), Times.Never); mockUow.Verify(x => x.Commit(), Times.Never); }
public UpdateTaskResponse UpdateTask(UpdateTaskRequest request) { var response = _innerService.UpdateTask(request); NotifyIfException(response); return(response); }
public async Task <IActionResult> UpdateTaskAsync(int taskId, [FromBody] UpdateTaskRequest request) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } throw new NotImplementedException(); }
public void GivenIHaveAValidUpdateTaskRequest() { var request = new UpdateTaskRequest { UpdatedBy = UpdatedBy }; _context.Request = _context.Patch(UpdateTaskStatus(_context.Test.ConferenceResponse.Id, _context.Test.TaskId), request); }
public void Invoke(UpdateTaskRequest task) { taskRepository.Replace(new TaskEntity { Title = task.Title, Description = task.Description, Id = new ObjectId(task.Id) }); }
public async Task <IActionResult> PutTask([FromServices] IMediator eventor, Guid projectId, Guid taskId, UpdateTaskRequest request) { request.ProjectId = projectId; request.TaskId = taskId; return(await eventor.SendStream <UpdateTaskRequest, UpdateTaskResponse>( request, x => x.Result)); }
public async Task <bool> Put(long id, [FromBody] TaskModel taskModel) { UpdateTaskRequest updateTaskRequest = _mapper.Map <UpdateTaskRequest>(taskModel); updateTaskRequest.Id = id; bool success = await _mediator.Send(updateTaskRequest); return(success); }
public ActionResult <Guid> UpdateTask(UpdateTaskRequest request) { var task = _context.Tasks.Include(t => t.TaskCharacters).Where(t => t.Id == request.TaskId).FirstOrDefault(); if (task is null) { return(NotFound()); } task.TaskType = request.TaskType; task.Description = request.Description; task.Notes = request.Notes; task.CollectibleType = request.CollectibleType; task.Source = request.Source; task.Priority = request.Priority; task.RefreshFrequency = request.RefreshFrequency; task.GameDataReferences = request.GameDataReferenceItems.Select(ri => new GameDataReference(ri.GameId, ri.Type, ri.Subclass, ri.Description)) .ToList(); _context.SaveChanges(); var taskCharacterList = new List <TaskCharacter>(); // Of all incoming entries foreach (var c in request.Characters) { var tc = task.TaskCharacters.Where(tc => tc.CharacterId == c).FirstOrDefault(); // If there is a match, add it if (tc != null) { taskCharacterList.Add(tc); } // If there isn't a match, create it else { taskCharacterList.Add(new TaskCharacter(c, task.Id)); } } // Overwrite the original list (purge extras) task.TaskCharacters.Clear(); _context.SaveChanges(); foreach (var tc in taskCharacterList) { task.TaskCharacters.Add(tc); } _context.SaveChanges(); return(task.Id); }
public async Task Should_return_missing_username() { var request = new UpdateTaskRequest(); var result = await _validator.ValidateAsync(request); result.IsValid.Should().BeFalse(); result.Errors .Any(x => x.ErrorMessage == UpdateTaskRequestValidation.NoUsernameErrorMessage) .Should().BeTrue(); }
public async Task Should_pass_validation() { var request = new UpdateTaskRequest { UpdatedBy = "*****@*****.**" }; var result = await _validator.ValidateAsync(request); result.IsValid.Should().BeTrue(); }
public async Task <IActionResult> PutTask(Guid taskId, [FromBody] UpdateTaskRequest request) { var updatedTask = await _taskService.UpdateTaskAsync(taskId, request); if (updatedTask != null) { return(Ok(updatedTask)); } return(NotFound()); }
public async Task <IActionResult> Update([FromBody] UpdateTaskRequest request) { await this.tasksService.Update( request.Id, request.Description, request.Title, request.Estimate, request.Status, request.UserId); return(this.NoContent()); }
//public async Task<IActionResult> UserTaskUpdate(int userTaskId, int assignedToUserId, DateTime startDate, DateTime EndDate, int taskType, string description, string name, TimeSpan timeSpend) public async Task <IActionResult> UserTaskUpdate([FromBody] UpdateTaskRequest updateTaskRequest) { var result = await _userTaskServer.UpdateUserTask(updateTaskRequest); if (result == null) { return(NotFound()); } var userTask = _mapper.Map <UserTaskResponse>(result); return(Ok(userTask)); }
public async Task <IActionResult> UpdateTask([FromRoute] Guid taskId, [FromBody] UpdateTaskRequest request) { var result = _requestValidator.Validate(request); if (!result.IsValid) { throw new InvalidValueException(result.Errors.Select(e => e.ErrorMessage).Distinct().ToArray()); } await _tasksService.UpdateTask(taskId, _mapper.Map <UpdateTask>(request)); return(Ok()); }
public void GivenValidUser_AndAllValidProperties_UpdatesTaskInDatabase() { var task = new Task(DefaultPlayer.Id, TaskType.Achievement) { IsFavourite = false, Priority = Priority.Highest, Notes = "This shouldn't be here." }; Context.Tasks.Add(task); Context.SaveChanges(); // Arrange var dto = new UpdateTaskRequest() { TaskId = task.Id, TaskType = TaskType.Achievement, Description = "Secret Fish and Where To Find Them", Notes = null, CollectibleType = null, Source = null, Priority = Priority.Medium, RefreshFrequency = RefreshFrequency.Never }; dto.GameDataReferenceItems.Add( new GameDataReferenceItem() { Id = 2, GameId = 13502, Type = GameDataType.Achievement, Subclass = null, Description = "Secret Fish and Where To Find Them" }); // Act var result = _controller.UpdateTask(dto); // Assert var foundTask = Context.Tasks.Find(result.Value); foundTask.PlayerId.Should().Be(DefaultPlayer.Id); foundTask.Id.Should().Be(dto.TaskId); foundTask.TaskType.Should().Be(dto.TaskType); foundTask.Description.Should().Be(dto.Description); foundTask.Notes.Should().BeNull(); foundTask.CollectibleType.Should().BeNull(); foundTask.Source.Should().BeNull(); foundTask.Priority.Should().Be(dto.Priority); foundTask.RefreshFrequency.Should().Be(dto.RefreshFrequency); }
public async Task UpdateTask_Success() { var dataGenerationResult = _trackingContext.AddTestData <Domain.Entities.Task>(5); var selectedId = dataGenerationResult.Item2[1]; var updatedModel = new Domain.Models.Task { Id = selectedId, Name = "NewTaskName" }; var request = new UpdateTaskRequest(selectedId, updatedModel); var handler = new UpdateTaskRequestHandler(_trackingContext, Mapper.Instance); var result = await handler.Handle(request, default(CancellationToken)); Assert.AreEqual(Unit.Value, result); }
public async Task <IHttpActionResult> Put([FromBody] UpdateTaskRequest request) { if (!ModelState.IsValid) { return(BadRequest()); } else { var itemExists = await _context.Tasks.SingleOrDefaultAsync(i => i.TaskId == request.TaskId && i.TaskListId == request.TaskListId && i.IsDeleted != true); if (itemExists != null) { // parse the updated properties foreach (var item in request.Data) { switch (item.Key) { case TaskPropertyEnum.IsCompleted: itemExists.IsCompleted = bool.Parse(item.Value); break; case TaskPropertyEnum.CompletedOn: itemExists.CompletedOnUtc = DateTime.Parse(item.Value); break; case TaskPropertyEnum.DueOn: itemExists.DueOnUtc = DateTime.Parse(item.Value); break; case TaskPropertyEnum.IsActive: itemExists.IsActive = bool.Parse(item.Value); break; case TaskPropertyEnum.Title: itemExists.Title = item.Value; break; default: break; } } _context.Entry(itemExists).State = EntityState.Modified; await _context.SaveChangesAsync(); System.Web.HttpContext.Current.Response.StatusCode = 201; return(Ok()); } return(BadRequest("Record not found. Make sure it exists")); } }
public ServiceResult <TaskDTO> UpdateTask(string sessionToken, int taskId, string taskDescription) { var updateTaskRequest = new UpdateTaskRequest { SessionToken = sessionToken, TaskId = taskId, TaskDescription = taskDescription }; return(ExecuteWithExceptionHandling( context => UpdateTaskTransactionScript.UpdateTask( context, updateTaskRequest))); }