/// <summary> /// Fills the task board history /// </summary> /// <param name="response">Response to send</param> /// <param name="currentUser">Current user</param> /// <returns>Task</returns> private async Task FillTaskBoardHistory(PersonalDataResponse response, GoNorthUser currentUser) { response.TaskBoardHistory = new List <TrimmedTaskBoardHistory>(); List <UserTaskBoardHistory> taskBoardHistory = await _userTaskBoardHistoryDbAccess.GetAllOpenedBoardsOfUser(currentUser.Id); foreach (UserTaskBoardHistory curTaskBoard in taskBoardHistory) { TrimmedTaskBoardHistory curTaskBoardHistory = new TrimmedTaskBoardHistory(); curTaskBoardHistory.BoardName = "DELETED"; curTaskBoardHistory.Project = "DELETED"; TaskBoard taskBoard = await _taskBoardDbAccess.GetTaskBoardById(curTaskBoard.LastOpenBoardId); if (taskBoard != null) { curTaskBoardHistory.BoardName = taskBoard.Name; } GoNorthProject project = await _projectDbAccess.GetProjectById(curTaskBoard.ProjectId); if (project != null) { curTaskBoardHistory.Project = project.Name; } response.TaskBoardHistory.Add(curTaskBoardHistory); } }
public ActionResult PostAddTaskBoard(TaskBoard taskBoard) { db.TaskBoards.Add(taskBoard); db.SaveChanges(); return(Redirect("/TaskBoard/Index")); }
public void Convert_ConvertsNonExistingServiceModelToEntity_ReturnsConvertedEntity() { // ARRANGE DbContextOptions <TestDatabaseContext> options = new DbContextOptionsBuilder <TestDatabaseContext>() .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()) .Options; IDatabaseContext dbContext = new TestDatabaseContext(options); TaskBoardConverter converter = new TaskBoardConverter(dbContext); TaskBoardPublic taskBoardPublic = new TaskBoardPublic() { ID = 1, Name = "Test", UserID = 1 }; // ACT TaskBoard taskBoard = converter.Convert(taskBoardPublic); // ASSERT taskBoard.Should().BeEquivalentTo <TaskBoard>(new TaskBoard() { ID = 0, Name = "Test", UserID = 1 }); taskBoard.User.Should().BeNull(); }
public ActionResult PostEditTaskBoard(TaskBoard taskBoard) { db.Entry(taskBoard).State = EntityState.Modified; db.SaveChanges(); return(Redirect("/TaskBoard/Index")); }
public async Task <IActionResult> CreateTaskGroup(string boardId, [FromBody] TaskGroup group) { // Validate Data if (string.IsNullOrEmpty(boardId) || string.IsNullOrEmpty(group.Name)) { return(StatusCode((int)HttpStatusCode.BadRequest)); } // Get Task Board TaskBoard updatedTaskBoard = await _taskBoardDbAccess.GetTaskBoardById(boardId); if (updatedTaskBoard == null) { return(StatusCode((int)HttpStatusCode.NotFound)); } // Create Task Group TaskGroup newGroup = new TaskGroup(); newGroup.Id = Guid.NewGuid().ToString(); newGroup.Name = group.Name; newGroup.Description = group.Description; newGroup.Status = group.Status; newGroup.AssignedTo = group.AssignedTo; newGroup.Tasks = new List <GoNorthTask>(); await this.SetModifiedData(_userManager, newGroup); if (updatedTaskBoard.TaskGroups == null) { updatedTaskBoard.TaskGroups = new List <TaskGroup>(); } updatedTaskBoard.TaskGroups.Add(newGroup); try { await _taskBoardDbAccess.UpdateTaskBoard(updatedTaskBoard); } catch (Exception ex) { _logger.LogError(ex, "Could not updated task board for creating task group."); return(StatusCode((int)HttpStatusCode.InternalServerError)); } // Add Timeline entry try { await _timelineService.AddTimelineEntry(TimelineEvent.TaskGroupCreated, updatedTaskBoard.Id, updatedTaskBoard.Name, newGroup.Name); } catch (Exception ex) { _logger.LogError(ex, "Could not create task group created timeline entry."); return(StatusCode((int)HttpStatusCode.InternalServerError)); } return(Ok(newGroup)); }
public string buildBoard(int n = 1) { var inBoard = new TaskBoard { Name = $"board{n}" }; var resp = controller.PostBoard(inBoard); return(((TaskBoard)resp.Value).Id); }
public ActionResult ShowTaskBoard(int?id) { if (id == null) { return(HttpNotFound()); } TaskBoard taskBoard = db.TaskBoards.Include(t => t.Owner).FirstOrDefault(t => t.BoardId == id); return(View(taskBoard)); }
public ActionResult AddTaskBoard() { ViewBag.Members = db.Users.ToList(); TaskBoard taskBoard = new TaskBoard(); taskBoard.OwnerUserId = db.Users.FirstOrDefault(u => u.Email == User.Identity.Name).UserId; return(View(taskBoard)); }
public ActionResult PostDeleteTaskBoard(int id) { TaskBoard taskBoard = new TaskBoard { BoardId = id }; db.Entry(taskBoard).State = EntityState.Deleted; db.SaveChanges(); return(Redirect("/TaskBoard/Index")); }
public TaskBoard Create(TaskBoard taskBoard) { if (taskBoard.IsTransient()) { return(_context.TaskBoards .Add(taskBoard) .Entity); } return(taskBoard); }
/// <inheritdoc/> public TaskBoardPublic UpdateTaskBoard(TaskBoardPublic taskBoard) { Ensure.ParamNotNull(taskBoard, nameof(taskBoard)); TaskBoardConverter converter = new TaskBoardConverter(mDBContext); TaskBoardLogic logic = new TaskBoardLogic(mDBContext); TaskBoard createdTaskBoard = logic.UpdateTaskBoard(converter.Convert(taskBoard)); mDBContext.SaveChanges(); return(converter.Convert(createdTaskBoard)); }
public ObjectResult PostBoard([FromBody] TaskBoard newBoard) { newBoard.Id = shortUid.generate(); boards.Add(newBoard); if (boards.Find((b) => b.Id == newBoard.Id) != null) { return(new CreatedAtRouteResult(new { id = newBoard.Id }, newBoard)); } // Throw a somewhat meaningful error. Make this a bit more robust at some point. var response = new ObjectResult(new { statusCode = 415 }); return(response); }
/// <inheritdoc/> public TaskBoardPublic GetTaskBoard(int ID) { TaskBoard taskBoard = mDBContext.TaskBoards.FirstOrDefault(tb => tb.ID == ID); // Taskboard o takim ID nie został znaleziony. if (taskBoard == null) { return(null); } TaskBoardConverter converter = new TaskBoardConverter(mDBContext); return(converter.Convert(taskBoard)); }
/// <summary> /// Fills the task numbers for a board /// </summary> /// <param name="taskBoard">Task board to fill</param> /// <returns>Task</returns> private async Task FillTaskNumbersForBoard(TaskBoard taskBoard) { if (taskBoard.TaskGroups == null) { return; } foreach (TaskGroup curGroup in taskBoard.TaskGroups) { await FillTaskNumbersForTaskGroup(taskBoard.ProjectId, curGroup); } await _taskBoardDbAccess.UpdateTaskBoard(taskBoard); }
public async Task <IActionResult> CreateTaskBoard([FromBody] TaskBoard board) { // Validate Data if (string.IsNullOrEmpty(board.Name)) { return(StatusCode((int)HttpStatusCode.BadRequest)); } // Create Task Board TaskBoard newBoard = new TaskBoard(); newBoard.IsClosed = false; newBoard.Name = board.Name; newBoard.PlannedStart = board.PlannedStart; newBoard.PlannedEnd = board.PlannedEnd; newBoard.TaskGroups = new List <TaskGroup>(); await this.SetModifiedData(_userManager, newBoard); GoNorthProject project = await _projectDbAccess.GetDefaultProject(); newBoard.ProjectId = project.Id; try { newBoard = await _taskBoardDbAccess.CreateTaskBoard(newBoard); } catch (Exception ex) { _logger.LogError(ex, "Could not create task board."); return(StatusCode((int)HttpStatusCode.InternalServerError)); } // Add Timeline entry try { await _timelineService.AddTimelineEntry(TimelineEvent.TaskBoardCreated, newBoard.Id, newBoard.Name); } catch (Exception ex) { _logger.LogError(ex, "Could not create task board create timeline entry."); await _taskBoardDbAccess.DeleteTaskBoard(newBoard); return(StatusCode((int)HttpStatusCode.InternalServerError)); } return(Ok(newBoard.Id)); }
/// <summary> /// Usuwa taskboard z bazy danych /// </summary> /// <param name="ID">ID taskboardu</param> /// <returns></returns> public async Task DeleteTaskBoard(int ID) { TaskBoard taskBoard = mDBContext.TaskBoards.Find(ID); if (taskBoard == null) { return; } List <WorkItem> workItems = await mDBContext.WorkItems.Where(wi => wi.WorkItemCollection.TaskBoardId == ID).ToListAsync().ConfigureAwait(false); mDBContext.WorkItems.RemoveRange(workItems); mDBContext.WorkItemCollections.RemoveRange(taskBoard.WorkItemCollections); mDBContext.TaskBoards.Remove(taskBoard); }
public ActionResult PostAddTaskBoard(TaskBoard taskBoard, int[] selectedMembers) { if (selectedMembers != null) { foreach (var m in db.Users.Where(member => selectedMembers.Contains(member.UserId))) { taskBoard.Members.Add(m); } } db.TaskBoards.Add(taskBoard); db.SaveChanges(); return(Redirect("/TaskBoard/Index")); }
public async Task <IActionResult> Post() { var taskBoard = new TaskBoard(); context.TaskBoards.Add(taskBoard); try { await context.SaveChangesAsync(); return(Ok(taskBoard)); } catch (Exception e) { Console.WriteLine(e); return(BadRequest("Unable to create taskboard.")); } }
public ActionResult EditTaskBoard(int?id) { if (id == null) { return(HttpNotFound()); } TaskBoard taskBoard = db.TaskBoards.Include(t => t.Owner).FirstOrDefault(t => t.BoardId == id); if (taskBoard != null) { SelectList users = new SelectList(db.Users, "UserId", "Username", taskBoard.OwnerUserId); ViewBag.Users = users; return(View(taskBoard)); } return(HttpNotFound()); }
public async Task <TaskBoardViewModel> Handle(CreateTaskBoardCommand request, CancellationToken cancellationToken) { var taskBoard = new TaskBoard ( request.Name, request.Position ); _taskBoardRepository.Create(taskBoard); await _taskBoardRepository.UnitOfWork.SaveChangesAsync(cancellationToken); var viewModel = new TaskBoardViewModel { Id = taskBoard.Id, Name = taskBoard.Name }; return(viewModel); }
/// <summary> /// Aktualizuje taskboard w bazie danych /// </summary> /// <param name="taskBoard">Taskboard</param> /// <returns></returns> public TaskBoard UpdateTaskBoard(TaskBoard taskBoard) { Ensure.ParamNotNull(taskBoard, nameof(taskBoard)); if (taskBoard.ID <= 0) { throw new ArgumentException($"Parameter {nameof(taskBoard)} ID's has to be grater than 0. The provided value is {taskBoard.ID}."); } TaskBoard result = mDBContext.TaskBoards.FirstOrDefault(wi => wi.ID == taskBoard.ID); if (result == null) { throw new ArgumentException($"TaskBoard with ID {taskBoard.ID} does not exist."); } result.Name = taskBoard.Name; return(result); }
public async Task <string> Handle(UpdateTaskBoardCommand request, CancellationToken cancellationToken) { if (request == null) { throw new ArgumentNullException(nameof(request)); } var entity = new TaskBoard( id: request.Id, userId: request.UserId, title: request.Title, description: request.Description, lists: request.Lists ); var taskBoardResult = await updateTaskBoard.UpdateAsync(entity, cancellationToken).ConfigureAwait(false); return(taskBoardResult); }
public async Task <IActionResult> SetTaskBoardStatus(string id, bool closed) { // Validate Data if (string.IsNullOrEmpty(id)) { return(StatusCode((int)HttpStatusCode.BadRequest)); } // Updates a Task Board TaskBoard updatedTaskBoard = await _taskBoardDbAccess.GetTaskBoardById(id); if (updatedTaskBoard == null) { return(StatusCode((int)HttpStatusCode.NotFound)); } updatedTaskBoard.IsClosed = closed; await this.SetModifiedData(_userManager, updatedTaskBoard); try { await _taskBoardDbAccess.UpdateTaskBoard(updatedTaskBoard); } catch (Exception ex) { _logger.LogError(ex, "Could not set task board status."); return(StatusCode((int)HttpStatusCode.InternalServerError)); } // Add Timeline entry TimelineEvent timelineEvent = TimelineEvent.TaskBoardClosed; if (!closed) { timelineEvent = TimelineEvent.TaskBoardReopened; } await _timelineService.AddTimelineEntry(timelineEvent, updatedTaskBoard.Id, updatedTaskBoard.Name); return(Ok(updatedTaskBoard.Id)); }
public ActionResult PostEditTaskBoard(TaskBoard taskBoard, int[] selectedMembers) { TaskBoard newBoard = db.TaskBoards.Find(taskBoard.BoardId); newBoard.BoardName = taskBoard.BoardName; newBoard.BoardDescription = taskBoard.BoardDescription; newBoard.OwnerUserId = taskBoard.OwnerUserId; newBoard.Members.Clear(); if (selectedMembers != null) { foreach (var m in db.Users.Where(member => selectedMembers.Contains(member.UserId))) { newBoard.Members.Add(m); } } db.Entry(newBoard).State = EntityState.Modified; db.SaveChanges(); return(Redirect("/TaskBoard/Index")); }
public async Task <string> Handle(CreateTaskBoardCommand request, CancellationToken cancellationToken) { if (request == null) { throw new ArgumentNullException(nameof(request)); } var newId = createTaskBoard.GenerateIdentifier(); var entity = new TaskBoard( id: newId, userId: request.UserId, title: request.Title, description: request.Description, lists: new List <TaskList>() ); var boardResult = await createTaskBoard.CreateAsync(entity, cancellationToken).ConfigureAwait(false); return(boardResult); }
public async Task <IActionResult> DeleteTaskBoard(string id) { // Validate Data if (string.IsNullOrEmpty(id)) { return(StatusCode((int)HttpStatusCode.BadRequest)); } // Updates a Task Board TaskBoard updatedTaskBoard = await _taskBoardDbAccess.GetTaskBoardById(id); if (updatedTaskBoard == null) { return(Ok(id)); } // Check if no tasks are associated if (updatedTaskBoard.TaskGroups != null && updatedTaskBoard.TaskGroups.Count > 0) { return(StatusCode((int)HttpStatusCode.BadRequest, _localizer["CanNotDeleteNonEmptyTaskBoard"].Value)); } // Delete board try { await _taskBoardDbAccess.DeleteTaskBoard(updatedTaskBoard); } catch (Exception ex) { _logger.LogError(ex, "Could not delete task board."); return(StatusCode((int)HttpStatusCode.InternalServerError)); } // Add Timeline entry await _timelineService.AddTimelineEntry(TimelineEvent.TaskBoardDeleted, updatedTaskBoard.Name); return(Ok(id)); }
public async Task <IActionResult> UpdateTaskBoard(string id, [FromBody] TaskBoard board) { // Validate Data if (string.IsNullOrEmpty(id) || string.IsNullOrEmpty(board.Name)) { return(StatusCode((int)HttpStatusCode.BadRequest)); } // Updates a Task Board TaskBoard updatedTaskBoard = await _taskBoardDbAccess.GetTaskBoardById(id); if (updatedTaskBoard == null) { return(StatusCode((int)HttpStatusCode.NotFound)); } updatedTaskBoard.Name = board.Name; updatedTaskBoard.PlannedStart = board.PlannedStart; updatedTaskBoard.PlannedEnd = board.PlannedEnd; await this.SetModifiedData(_userManager, updatedTaskBoard); try { await _taskBoardDbAccess.UpdateTaskBoard(updatedTaskBoard); } catch (Exception ex) { _logger.LogError(ex, "Could not update task board."); return(StatusCode((int)HttpStatusCode.InternalServerError)); } // Add Timeline entry await _timelineService.AddTimelineEntry(TimelineEvent.TaskBoardUpdated, updatedTaskBoard.Id, updatedTaskBoard.Name); return(Ok(updatedTaskBoard.Id)); }
public void GetTaskBoard_OnExistingTaskBoard_ReturnsTaskBoard() { // ARRANGE DbContextOptions <TestDatabaseContext> options = new DbContextOptionsBuilder <TestDatabaseContext>() .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()) .Options; IDatabaseContext dbContext = new TestDatabaseContext(options); TaskBoardRepository repository = new TaskBoardRepository(dbContext); TaskBoardConverter converter = new TaskBoardConverter(dbContext); TaskBoard taskBoard = new TaskBoard() { Name = Guid.NewGuid().ToString(), }; dbContext.TaskBoards.Add(taskBoard); dbContext.SaveChanges(); // ACT TaskBoardPublic taskBoardPublic = repository.GetTaskBoard(1); // ASSERT taskBoardPublic.Should().BeEquivalentTo <TaskBoardPublic>(converter.Convert(taskBoard)); }
/// <summary> /// Tworzy taskboard w bazie danych /// </summary> /// <param name="taskBoard">Taskboard</param> /// <returns></returns> public TaskBoard CreateTaskBoard(TaskBoard taskBoard) { Ensure.ParamNotNull(taskBoard, nameof(taskBoard)); return(mDBContext.TaskBoards.Add(taskBoard).Entity); }
public void Delete(TaskBoard taskBoard) { _context.TaskBoards.Remove(taskBoard); }