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