Beispiel #1
0
        public async Task <JsonResult> GetNewTaskItem(TaskItemModel model)
        {
            try
            {
                TaskItemDto dto = _mapper.Map <TaskItemDto>(model);
                dto = await _taskItemService.GetNewTask(dto);

                dto.TaskItemAssigns.Add(new TaskItemAssignDto
                {
                    AssignToFullName     = CurrentUser.FullName,
                    AssignToJobTitleName = CurrentUser.Departments != null ? CurrentUser.Departments[0].JobTitle : string.Empty,
                    Department           = CurrentUser.Departments != null ? CurrentUser.Departments[0].Name : string.Empty,
                    AssignTo             = CurrentUser.Id,
                    TaskType             = Entities.TaskType.Primary
                });
                dto.AssignBy            = CurrentUser.Id; dto.AssignByFullName = CurrentUser.FullName;
                model                   = _mapper.Map <TaskItemModel>(dto);
                model.TaskItemAssignIds = model.TaskItemAssigns.Select(e => e.AssignTo).ToList();
            }
            catch (Exception ex)
            {
                _loggerServices.WriteError(ex.ToString());
            }
            return(Json(model, JsonRequestBehavior.AllowGet));
        }
Beispiel #2
0
        public async Task <IActionResult> UpdateTaskItem(string boardId, TaskItemDto item)
        {
            item.TaskBoardId = boardId;
            await _taskBoardService.UpdateTaskAsync(item);

            return(Json(new { message = "Task Updated successfully" }));
        }
        public IHttpActionResult PutTaskItem(long id, TaskItemDto taskItemDto)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            if (id != taskItemDto.TaskId)
            {
                return(BadRequest());
            }
            var currentUserId = GetCurrentUserId();
            var nullCheck     = _bl.GetTaskItem(currentUserId, id);

            if (nullCheck == null)
            {
                return(NotFound());
            }

            if (currentUserId != taskItemDto.UserId)
            {
                return(Unauthorized());
            }

            _bl.PutTaskItem(taskItemDto);

            return(StatusCode(HttpStatusCode.NoContent));
        }
Beispiel #4
0
        public IActionResult Update(long id, [FromBody] TaskItemDto item)
        {
            if (item == null)
            {
                return(BadRequest());
            }

            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            if (!_taskRepository.Exists(id))
            {
                return(NotFound());
            }

            var taskItem = _taskRepository.Find(id);

            taskItem.UpdateFrom(item);
            if (!_taskRepository.Save())
            {
                return(StatusCode(500, "A problem happened while handling your request."));
            }

            return(NoContent());
        }
Beispiel #5
0
        public async Task CreateReturnsBadRequestForNoName()
        {
            var taskItem = new TaskItemDto {
                IsComplete = false
            };

            var response = await _client.PostAsJsonAsync("api/tasks", taskItem);

            Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
        }
Beispiel #6
0
        public void CreateReturnsCreatedAtRouteStatus()
        {
            var controller = CreateTaskController("CreateReturnsCreatedAtRouteStatus");
            var taskItem   = new TaskItemDto {
                Name = "NewTask", IsComplete = false
            };

            var createResult = controller.Create(taskItem);

            Assert.IsType <CreatedAtRouteResult>(createResult);
        }
Beispiel #7
0
        public void UpdateReturnsBadRequestForInvalidId()
        {
            var controller = CreateTaskController("UpdateReturnsBadRequestForInvalidId");
            var taskItem   = new TaskItemDto {
                Name = "NewTask", IsComplete = false
            };

            var updateResult = controller.Update(1, taskItem);

            Assert.IsType <NotFoundResult>(updateResult);
        }
Beispiel #8
0
        public async Task <IActionResult> OppositeMark([FromBody] TaskItemDto task)
        {
            //var item = _mapper.Map<TaskItem>(task);
            var updItem = _db.Tasks.Find(task.TaskId);

            updItem.IsDone = task.IsDone;
            _db.Tasks.Update(updItem);
            await _db.SaveChangesAsync();

            return(Ok());
        }
Beispiel #9
0
        public void UpdateReturnsNoContentStatus()
        {
            var controller = CreateTaskController("UpdateReturnsNoContentStatus");
            var taskItem   = new TaskItemDto {
                Name = "NewTask", IsComplete = false
            };
            var id = GetTaskIdForTask(controller, _testData[3].Name);

            var updateResult = controller.Update(id, taskItem);

            Assert.IsType <NoContentResult>(updateResult);
        }
Beispiel #10
0
        public void CreateAddsTaskToTaskList()
        {
            var controller = CreateTaskController("CreateAddsTaskToTaskList");
            var taskItem   = new TaskItemDto {
                Name = "NewTask", IsComplete = false
            };

            controller.Create(taskItem);

            var tasks = GetAllTasks(controller);

            Assert.Equal(5, tasks.Count());
        }
Beispiel #11
0
        public async Task CreateReturnsProperErrorMessageForEmptyName()
        {
            var taskItem = new TaskItemDto {
                Name = string.Empty, IsComplete = false
            };

            var response = await _client.PostAsJsonAsync("api/tasks", taskItem);

            var returnMessage   = response.Content.ReadAsStringAsync().Result;
            var expectedMessage = new TaskItemDtoValidator().Validate(taskItem).Errors[0].ErrorMessage;

            Assert.Contains(expectedMessage, returnMessage);
        }
Beispiel #12
0
        public async Task <ActionResult <TaskItemDto> > CreateTask(int projectId, TaskItemDto newTaskItem)
        {
            var newTask = _mapper.Map <TaskItem>(newTaskItem);
            var project = await _projectService.GetProjectById(projectId, false);

            if (await _taskService.CreateTask(project, newTask))
            {
                var location = _linkGenerator.GetPathByAction("GetProjectById", "Projects", new { id = project.Id });
                return(Created(location, _mapper.Map <ProjectDto>(newTask)));
            }

            return(BadRequest("Could not create that task."));
        }
Beispiel #13
0
        public async Task <JsonResult> SaveTaskItem(TaskItemModel model)
        {
            _loggerServices.WriteError("test log");
            SendMessageResponse rs = null;

            try
            {
                TaskItemDto dto = new TaskItemDto();
                //check permission
                dto = _mapper.Map <TaskItemDto>(model);
                dto.IsFullControl = false;
                if (CurrentUser.HavePermission(EnumModulePermission.Task_FullControl))
                {
                    dto.IsFullControl = true;
                }
                dto.ModifiedBy   = CurrentUser.Id;
                dto.ModifiedDate = DateTime.Now;
                dto.Attachments  = new List <AttachmentDto>();
                if (Request.Files.Count > 0)
                {
                    foreach (string file in Request.Files)
                    {
                        var    fileContent = Request.Files[file];
                        byte[] document    = Utility.ReadAllBytes(fileContent);
                        string ext         = Path.GetExtension(fileContent.FileName).Replace(".", "");

                        AttachmentDto attachmentDto = new AttachmentDto()
                        {
                            Id = Guid.NewGuid(),
                            CreateByFullName = CurrentUser.FullName,
                            CreatedBy        = CurrentUser.Id,
                            CreatedDate      = DateTime.Now,
                            FileExt          = ext,
                            FileContent      = document,
                            FileName         = fileContent.FileName,
                            FileSize         = fileContent.ContentLength,
                            ProjectId        = dto.Id,
                            Source           = Entities.Source.TaskItem,
                        };
                        dto.Attachments.Add(attachmentDto);
                    }
                }
                rs = await _taskItemService.SaveAsync(dto);
            }
            catch (Exception ex)
            {
                _loggerServices.WriteError(ex.ToString());
            }
            return(Json(rs, JsonRequestBehavior.AllowGet));
        }
Beispiel #14
0
        public void CreateReturnsExpectedValueInCreatedAtRouteStatus()
        {
            var controller = CreateTaskController("CreateReturnsExpectedValueInCreatedAtRouteStatus");
            var taskItem   = new TaskItemDto {
                Name = "NewTask", IsComplete = false
            };

            var createResult = controller.Create(taskItem) as CreatedAtRouteResult;

            var createdTask = createResult.Value as TaskItem;

            Assert.Equal(taskItem.Name, createdTask.Name);
            Assert.Equal(taskItem.IsComplete, createdTask.IsComplete);
        }
Beispiel #15
0
        public async Task <IActionResult> Add([FromBody] TaskItemDto task)
        {
            ApplicationUser user = await GetCurrentUserAsync();

            TaskItem ts = new TaskItem {
                Name = task.Name, Description = task.Description, IsDone = false, DeadLine = task.DeadLine, User = user
            };

            TagFilter(ts, task.Tags);
            _db.Tasks.Add(ts);
            await _db.SaveChangesAsync();

            return(Ok());
        }
        public IHttpActionResult PostTaskItem(TaskItemDto taskItemDto)
        {
            taskItemDto.UserId = GetCurrentUserId();


            //ModelState["taskItemDto.UserId"].Errors.Clear();
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            var taskId = _bl.PostTaskItem(taskItemDto); //todo get id logic

            return(CreatedAtRoute("DefaultApi", taskId, taskItemDto));
        }
Beispiel #17
0
        public void UpdateCorrectlyModifiesTask()
        {
            string newName    = "NewName";
            var    controller = CreateTaskController("UpdateCorrectlyModifiesTask");
            var    taskItem   = new TaskItemDto {
                Name = newName
            };
            var id = GetTaskIdForTask(controller, _testData[3].Name);

            controller.Update(id, taskItem);

            var updatedTaskItem = GetTaskById(controller, id);

            Assert.Equal(newName, updatedTaskItem.Name);
        }
Beispiel #18
0
        public async Task <IActionResult> Update([FromBody] TaskItemDto task)
        {
            TaskItem updItem = _db.Tasks.Include(t => t.TaskTags).ThenInclude(t => t.Tag).First(t => t.TaskId == task.TaskId);

            // update user properties
            updItem.Name        = task.Name;
            updItem.Description = task.Description;
            updItem.IsDone      = task.IsDone;
            updItem.DeadLine    = task.DeadLine;
            //_db.TaskTag.RemoveRange(_db.TaskTag.Where(t => t.TaskId == task.TaskId));
            TagFilter(updItem, task.Tags);
            //_db.Tasks.Update(updItem);
            await _db.SaveChangesAsync();

            return(Ok());
        }
        public long?PostTaskItem(TaskItemDto taskItemDto)
        {
            var taskItem = _mapper.Map <TaskItemDto, TaskItem>(taskItemDto);

            taskItem.CreatedDate = DateTime.Now;  //Set Created Date
            try
            {
                _uoWork.Tasks.Add(taskItem);
                _uoWork.Complete();
                return(null);
            }
            catch (Exception e)
            {
                return(null);
            }
        }
 public HttpStatusCode PutTaskItem(TaskItemDto taskItemDto)
 {
     try
     {
         var taskItem = _uoWork.Tasks.Get((long)taskItemDto.TaskId);
         taskItemDto.CreatedDate  = taskItem.CreatedDate; //Reset to orginal value.
         taskItemDto.ModifiedDate = DateTime.Now;         //Set Modified Date
         taskItem = _mapper.Map(taskItemDto, taskItem);
         _uoWork.Tasks.Update(taskItem);
         _uoWork.Complete();
         return(HttpStatusCode.NoContent); //No Content
     }
     catch (Exception e)
     {
         //todo implement logger
         return(HttpStatusCode.InternalServerError);
     }
 }
Beispiel #21
0
        public async Task <JsonResult> GetTaskItem(Guid?id)
        {
            TaskItemModel model = new TaskItemModel();

            try
            {
                TaskItemDto dto = null;
                if (id.HasValue)
                {
                    dto = await _taskItemService.GetById(id.Value);

                    if (dto == null)
                    {
                        var rs = SendMessageResponse.CreateFailedResponse("NotExist");
                        return(Json(rs, JsonRequestBehavior.AllowGet));
                    }
                    if (dto.CreatedBy != CurrentUser.Id && !CurrentUser.HavePermission(EnumModulePermission.Task_FullControl))
                    {
                        var rs = SendMessageResponse.CreateFailedResponse("AccessDenied");
                        return(Json(rs, JsonRequestBehavior.AllowGet));
                    }
                }
                else
                {
                    dto = new TaskItemDto {
                        AssignBy = CurrentUser.Id, AssignByFullName = CurrentUser.FullName
                    };
                    dto.TaskItemAssigns.Add(new TaskItemAssignDto
                    {
                        AssignToFullName     = CurrentUser.FullName,
                        AssignToJobTitleName = CurrentUser.Departments != null ? CurrentUser.Departments[0].JobTitle : string.Empty,
                        Department           = CurrentUser.Departments != null ? CurrentUser.Departments[0].Name : string.Empty,
                        AssignTo             = CurrentUser.Id,
                        TaskType             = Entities.TaskType.Primary
                    });
                }
                model = _mapper.Map <TaskItemModel>(dto);
            }
            catch (Exception ex)
            {
                _loggerServices.WriteError(ex.ToString());
            }
            return(Json(model, JsonRequestBehavior.AllowGet));
        }
Beispiel #22
0
        public IActionResult Create([FromBody] TaskItemDto item)
        {
            if (item == null)
            {
                return(BadRequest());
            }

            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            var taskItem = new TaskItem(item);

            _taskRepository.Add(taskItem);
            if (!_taskRepository.Save())
            {
                return(StatusCode(500, "A problem happened while handling your request."));
            }

            return(CreatedAtRoute("GetTask", new { id = taskItem.Id }, taskItem));
        }
Beispiel #23
0
        public async Task <IActionResult> UpdateTask(int projectId, TaskItemDto updatedTask)
        {
            var project = await _projectService.GetProjectById(projectId, true);

            if (project == null)
            {
                return(NotFound("Project with that Id not found."));
            }

            var oldTask = project.Tasks.Where(t => t.Id == updatedTask.Id).Single();

            if (oldTask == null)
            {
                return(NotFound("Task in the project with the specified Id not found."));
            }

            if (await _taskService.UpdateTask(_mapper.Map <TaskItem>(oldTask), _mapper.Map <TaskItem>(updatedTask)))
            {
                return(Ok());
            }

            return(BadRequest("Could not delete that project."));
        }
Beispiel #24
0
        public async Task <JsonResult> UpdateStatusTaskItem(TaskItemModel model)
        {
            SendMessageResponse rs = null;

            try
            {
                TaskItemDto dto = new TaskItemDto();
                dto = _mapper.Map <TaskItemDto>(model);
                dto.IsFullControl = false;
                if (CurrentUser.HavePermission(EnumModulePermission.Task_FullControl))
                {
                    dto.IsFullControl = true;
                }
                dto.ModifiedBy   = CurrentUser.Id;
                dto.ModifiedDate = DateTime.Now;
                rs = await _taskItemService.UpdateStatusTaskItem(dto);
            }
            catch (Exception ex)
            {
                _loggerServices.WriteError(ex.ToString());
            }
            return(Json(rs, JsonRequestBehavior.AllowGet));
        }
 public TaskItemDeletedEvent(TaskItemDto item)
 {
     Item = item;
 }
 public TaskItemUpdatedEvent(TaskItemDto item)
 {
     Item = item;
 }
Beispiel #27
0
 public TaskItem(TaskItemDto taskItemDto)
 {
     Name       = taskItemDto.Name;
     IsComplete = taskItemDto.IsComplete;
 }
 public TaskItemAddedEvent(TaskItemDto item)
 {
     Item = item;
 }
 public UpdateTaskItemCommand(TaskItemDto item)
 {
     Item = item;
 }
Beispiel #30
0
 public void UpdateFrom(TaskItemDto otherItem)
 {
     Name       = otherItem.Name;
     IsComplete = otherItem.IsComplete;
 }