// GET: BoardTasks/Delete/5 public async Task <IActionResult> Delete(long?id)//View BoardTask delete page { bool userExists = CheckUser(); if (!userExists) { return(RedirectToAction("Signin", "Account")); } if (id == null) { return(NotFound()); } BoardTask boardTask = null; try { await Task.Run(() => { boardTask = new BoardTaskUtils().GetBoardTask(_context, (long)id); }); } catch (Exception) { return(NotFound()); } if (boardTask == null) { return(NotFound()); } return(View(boardTask)); }
public async Task <IHttpActionResult> Post(string boardSlug, BoardTask boardTask) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } try { var result = await mediator.Send(new CreateBoardTaskCommand { BoardSlug = boardSlug, BoardTask = boardTask }); hyperMediaFactory.Apply(result); return(Created(hyperMediaFactory.GetLink(result, Link.SELF), result)); } catch (BoardColumnNotFoundException) { return(BadRequest("Board Column Not Found")); } catch (BoardNotFoundException) { return(NotFound()); } }
public async Task <IActionResult> PutTaskBoard([FromRoute] Guid id, [FromBody] BoardTask taskBoard) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (id != taskBoard.Id) { return(BadRequest()); } _context.Entry(taskBoard).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!TaskBoardExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public BoardTask Delete(BoardTask task) { try { if (task != null) { var DeletedTaskEntityEntry = _context.Tasks.Update(task); if (DeletedTaskEntityEntry != null && DeletedTaskEntityEntry.State == EntityState.Modified) { var affectedRows = _context.SaveChanges(); if (affectedRows > 0) { _logger.LogInformation($"The {task.Title} was soft deleted."); return(DeletedTaskEntityEntry.Entity); } } } _logger.LogInformation($"The task given as null."); return(null); } catch (Exception ex) { _logger.LogError(ex, $"When deleting the task Failed."); throw; } }
public BoardTask Create(BoardTask task) { try { if (task != null) { var newTaskEntityEntry = _context.Tasks.Add(task); if (newTaskEntityEntry != null && newTaskEntityEntry.State == EntityState.Added) { var affectedRows = _context.SaveChanges(); if (affectedRows > 0) { _logger.LogInformation($"The {task.Title} was created."); return(newTaskEntityEntry.Entity); } } } _logger.LogInformation($"The task given as null."); return(null); } catch (Exception ex) { _logger.LogError(ex, $"When creating a task Failed."); throw; } }
/// <summary> /// Edit a board /// </summary> /// <param name="newBoardContents">The new contents of the board</param> public async Task EditAsync(BoardTask newBoardContents) { await Client.Cypher .Match("(board:Board)") .Where("board.id = {id}") .WithParam("id", newBoardContents.Id) .With("board, {newBoardContents} AS newBoard") .WithParam("newBoardContents", newBoardContents) .Set("board = newBoard { .*, encrypted: board.encrypted }") .ExecuteWithoutResultsAsync(); }
public async Task <IActionResult> PostTaskBoard([FromBody] BoardTask taskBoard) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } _context.BoardTasks.Add(taskBoard); await _context.SaveChangesAsync(); return(CreatedAtAction("GetTaskBoard", new { id = taskBoard.Id }, taskBoard)); }
public void GiveAObjWhenIsABoardThenReturnsTrue() { // Arrange SetupState(); var boardTask = new BoardTask(); // Act var isAppliable = state.IsAppliable(boardTask); // Assert Assert.True(isAppliable); }
public List <BoardTask> Map(List <Board> board) { List <BoardTask> listBoardTask = new List <BoardTask>(); foreach (var b in board) { List <TaskModel> listTask = new List <TaskModel>(); foreach (var t in b.Tasks) { List <string> taskUserTask = new List <string>(); foreach (var tu in t.TaskUsers) { var uName = tu.User.Username; taskUserTask.Add(uName); } List <CommentModel> taskComment = new List <CommentModel>(); foreach (var co in t.Comments) { var comModel = new CommentModel() { Description = co.Description, }; taskComment.Add(comModel); } var newTask = new TaskModel() { Title = t.Title, Description = t.Description, OrderNo = t.OrderNo, StartDate = t.StartDate, EndDate = t.EndDate, StatusType = t.Status == null ?null: t.Status.StatusType, Tagname = t.Tag == null ? null : t.Tag.Tagname, TaskUsers = taskUserTask, Comments = taskComment }; listTask.Add(newTask); } var newBoardTask = new BoardTask() { BoardName = b.BoardName, Tasks = listTask }; listBoardTask.Add(newBoardTask); } return(listBoardTask); }
public void GivenAObjWhenIsABoardThenSelfLinkAdded() { // Arrange SetupState(); mockLinkFactory.Setup(x => x.Build("BoardTaskGet", It.IsAny <object>())).Returns("http://fake-url/"); var boardTask = new BoardTask(); // Act state.Apply(boardTask); // Assert Assert.NotNull(boardTask.Links); Assert.NotNull(boardTask.Links.FirstOrDefault(x => x.Rel == Link.SELF)); }
public void SetupTests() { Config.Load("../../../../server-config.json"); new Database().Init(Config.Values.TestDatabaseUrl, Config.Values.TestDatabaseUser, Config.Values.TestDatabasePassword); _graphClient = Database.Client; _uow = new UnitOfWork(_graphClient); _defaultBoard = new BoardTask { Name = "name", Description = "some description" }; }
/// <summary> /// Edit a board /// </summary> /// <param name="parentId">Parent board id</param> /// <param name="newBoardContents">Board object with the new contents</param> public async Task <IActionResult> EditBoard(string parentId, BoardTask newBoardContents) { var validation = ModelValidator.Validate(newBoardContents); if (!validation.isValid) { return(new BadRequestObjectResult(validation.errors)); } await Clients.Group(parentId).EditBoard(newBoardContents); await _uow.Boards.EditAsync(newBoardContents); return(new OkObjectResult("")); }
public async void GivenABoardSlugAndTaskWhenBoardColumnIsInvalidThenReturnInvalidModelState() { // Arrange SetupController(); const string boardSlug = "board-name"; var boardTask = new BoardTask(); controller.ModelState.AddModelError("error", "error"); // Act var invalidModelStateResult = await controller.Post(boardSlug, boardTask) as InvalidModelStateResult; // Assert Assert.NotNull(invalidModelStateResult); }
public async Task <IActionResult> Create([Bind("NameTask,ContentTask,DateFinished")] BoardTask boardTask, string date_create)//Create BoardTask { bool userExists = CheckUser(); if (!userExists) { return(RedirectToAction("Signin", "Account")); } // boardTask.DateCreated = ConvertStringToDateTime(date_create); double localDate = Convert.ToDouble(date_create); boardTask.DateCreated = new DateTime(1970, 1, 1, 0, 0, 0).AddMilliseconds(localDate); if ((boardTask.DateCreated.CompareTo(boardTask.DateFinished)) > 0) { ModelState.AddModelError("DateFinished", "Дата окончния меньше текущей"); } if (ModelState.IsValid) { boardTask.IdOwner = GetUserId(); BoardTask newBoard = new BoardTask { IdOwner = boardTask.IdOwner, ContentTask = boardTask.ContentTask, NameTask = boardTask.NameTask, DateCreated = boardTask.DateCreated, DateFinished = boardTask.DateFinished }; try { await Task.Run(() => { new GeneralActions().AddNewObject(_context, newBoard); }); } catch (Exception) { return(NotFound()); } return(RedirectToAction(nameof(Index))); } return(View(boardTask)); }
/// <summary> /// Create a new board /// </summary> /// <param name="parentId">Parent board id</param> /// <param name="board">Board object</param> /// <param name="groupId">Id of the group to add it under</param> public async Task <IActionResult> AddBoard(string parentId, BoardTask board, string groupId) { var validation = ModelValidator.Validate(board); if (!validation.isValid) { return(new BadRequestObjectResult(validation.errors)); } string id = await _uow.Boards.AddAsync(board, groupId, Context.User.Identity.Name); board.Id = id; await Clients.Group(parentId).ReceiveNewBoard(board, groupId); return(new OkObjectResult(new { id = id })); }
public async void GivenABoardSlugAndTaskWhenBoardDoesNotExistThenNotFound() { // Arrange SetupController(); const string boardSlug = "board-name"; var boardTask = new BoardTask(); mockCommandDispatcher.Setup( x => x.HandleAsync <CreateBoardTaskCommand, BoardTask>(It.IsAny <CreateBoardTaskCommand>())) .Throws <BoardNotFoundException>(); // Act var notFoundResult = await controller.Post(boardSlug, boardTask) as NotFoundResult; // Assert Assert.NotNull(notFoundResult); }
public async void GivenABoardSlugTaskIdAndTaskWhenAllAreValidThenHypermediaSet() { // Arrange SetupController(); const string boardSlug = "board-name"; const int taskId = 1; var boardTask = new BoardTask { Id = taskId, Name = "Updated Name" }; // Act await controller.Put(boardSlug, taskId, boardTask); // Assert mockHyperMediaFactory.Verify(x => x.Apply(It.IsAny <object>()), Times.Once); }
public async Task <IActionResult> Edit(long id, [Bind("Id,IdOwner,NameTask,ContentTask,DateCreated,DateFinished,BackgroundImage,TaskCreated")] BoardTask boardTask)//Edit BoardTask { bool userExists = CheckUser(); if (!userExists) { return(RedirectToAction("Signin", "Account")); } if (id != boardTask.Id) { return(NotFound()); } if ((boardTask.DateCreated.CompareTo(boardTask.DateFinished)) > 0) { ModelState.AddModelError("DateFinished", "Дата окончния меньше текущей"); } if (ModelState.IsValid) { try { await Task.Run(() => { new GeneralActions().UpdateObject(_context, boardTask); }); } catch (Exception) { if (!BoardTaskExists(boardTask.Id)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } ViewData["IdOwner"] = boardTask.IdOwner; return(View(boardTask)); }
public async void GivenABoardSlugSlugAndTaskWhenBoardExistsThenHyperMediaSet() { // Arrange SetupController(); const string boardSlug = "board-name"; var boardTask = new BoardTask(); mockCommandDispatcher.Setup( x => x.HandleAsync <CreateBoardTaskCommand, BoardTask>(It.IsAny <CreateBoardTaskCommand>())) .ReturnsAsync(new BoardTask()); mockHyperMediaFactory.Setup(x => x.GetLink(It.IsAny <IHyperMediaItem>(), It.IsAny <string>())) .Returns("http://fake-url/"); // Act await controller.Post(boardSlug, boardTask); // Assert mockHyperMediaFactory.Verify(x => x.Apply(It.IsAny <BoardTask>()), Times.Once); }
public async void GivenABoardSlugTaskIdAndTaskWhenAllAreValidThenOkResultReturned() { // Arrange SetupController(); const string boardSlug = "board-name"; const int taskId = 1; var boardTask = new BoardTask { Id = taskId, Name = "Updated Name" }; // Act var okNegotiatedContentResult = await controller.Put(boardSlug, taskId, boardTask) as OkNegotiatedContentResult <BoardTask>; // Assert Assert.NotNull(okNegotiatedContentResult); }
public async void GivenABoardSlugAndTaskWhenBoardColumnDoesNotExistThenBadRequestReturned() { // Arrange SetupController(); const string boardSlug = "board-name"; var boardTask = new BoardTask(); mockCommandDispatcher.Setup( x => x.HandleAsync <CreateBoardTaskCommand, BoardTask>(It.IsAny <CreateBoardTaskCommand>())) .Throws <BoardColumnNotFoundException>(); // Act var badRequestErrorMessageResult = await controller.Post(boardSlug, boardTask) as BadRequestErrorMessageResult; // Assert Assert.NotNull(badRequestErrorMessageResult); Assert.Equal("Board Column Not Found", badRequestErrorMessageResult.Message); }
public async void GivenABoardSlugAndTaskWhenBoardAndColumnExistsThenReturnOkResult() { // Arrange SetupController(); const string boardSlug = "board-name"; var boardTask = new BoardTask(); mockCommandDispatcher.Setup( x => x.HandleAsync <CreateBoardTaskCommand, BoardTask>(It.IsAny <CreateBoardTaskCommand>())) .ReturnsAsync(new BoardTask()); mockHyperMediaFactory.Setup(x => x.GetLink(It.IsAny <IHyperMediaItem>(), It.IsAny <string>())) .Returns("http://fake-url/"); // Act var createdNegotiatedContentResult = await controller.Post(boardSlug, boardTask) as CreatedNegotiatedContentResult <BoardTask>; // Assert Assert.NotNull(createdNegotiatedContentResult); }
public async void GivenABoardSlugTaskIdAndTaskWhenAllAreValidThenUpdateBoardTaskCommandCalled() { // Arrange SetupController(); const string boardSlug = "board-name"; const int taskId = 1; var boardTask = new BoardTask { Id = taskId, Name = "Updated Name" }; // Act await controller.Put(boardSlug, taskId, boardTask); // Assert mockMediator.Verify( x => x.Send(It.Is <UpdateBoardTaskCommand>( y => y.BoardSlug == boardSlug && y.BoardTask == boardTask ), It.IsAny <CancellationToken>()), Times.Once); }
public async void GivenABoardSlugAndTaskWhenBoardExistsThenCreateBoardTaskCommandCalled() { // Arrange SetupController(); const string boardSlug = "board-name"; var boardTask = new BoardTask(); mockHyperMediaFactory.Setup(x => x.GetLink(It.IsAny <IHyperMediaItem>(), It.IsAny <string>())) .Returns("http://fake-url/"); // Act await controller.Post(boardSlug, boardTask); // Assert mockMediator.Verify( x => x.Send( It.Is <CreateBoardTaskCommand>(y => y.BoardTask == boardTask && y.BoardSlug == boardSlug), It.IsAny <CancellationToken>()), Times.Once); }
public async void GivenABoardSlugTaskIdAndTaskWhenAllAreValidThenUpdateBoardTaskCommandCalled() { // Arrange SetupController(); const string boardSlug = "board-name"; const int taskId = 1; var boardTask = new BoardTask { Id = taskId, Name = "Updated Name" }; // Act await controller.Put(boardSlug, taskId, boardTask); // Assert mockCommandDispatcher.Verify( x => x.HandleAsync <UpdateBoardTaskCommand, BoardTask>(It.Is <UpdateBoardTaskCommand>( y => y.BoardSlug == boardSlug && y.BoardTask == boardTask )), Times.Once); }
/// <summary> /// Add a board to a parent board. /// </summary> /// <remarks> /// Board gets added at the end. /// </remarks> /// <param name="board">Board object</param> /// <param name="groupId">Id of group to add it to</param> /// <param name="username">Username of the owner</param> public async Task <string> AddAsync(BoardTask board, string groupId, string username) { username = username.ToLower(); string id = _generator.NewId(username); board.Id = id; await Client.Cypher .Match("(parent:Board)-[:CHILD_GROUP]->(group:Group)") .Where((GroupNode group) => group.Id == groupId) .Call("apoc.lock.nodes([group])") .Match("(group)-[:NEXT*]->(next:End)") .Match("(previous)-[oldRel:NEXT]->(next)") .Create("(previous)-[:NEXT]->(board:Board {newBoard})-[:NEXT]->(next)") .WithParam("newBoard", board) .Create("(parent)-[:CHILD_BOARD]->(board)") .Set("board.encrypted = parent.encrypted") .Delete("oldRel") .ExecuteWithoutResultsAsync(); return(id); }
public async void GivenABoardSlugTaskIdAndTaskWhenDoesNotExistThenNotFoundResultReturned() { // Arrange SetupController(); const string boardSlug = "board-name"; const int taskId = 1; var boardTask = new BoardTask { Id = taskId, Name = "Updated Name" }; mockCommandDispatcher.Setup( x => x.HandleAsync <UpdateBoardTaskCommand, BoardTask>(It.IsAny <UpdateBoardTaskCommand>())) .Throws <BoardTaskNotFoundException>(); // Act var notFoundResult = await controller.Put(boardSlug, taskId, boardTask) as NotFoundResult; // Assert Assert.NotNull(notFoundResult); }
public async Task <IHttpActionResult> Put(string boardSlug, int taskId, BoardTask boardTask) { try { var result = await mediator.Send(new UpdateBoardTaskCommand { BoardSlug = boardSlug, BoardTask = boardTask }); hyperMediaFactory.Apply(result); return(Ok(result)); } catch (BoardTaskNotFoundException) { return(NotFound()); } catch (BoardColumnNotFoundException) { return(BadRequest("Board Column Not Found")); } }
/// <summary> /// Add a root board to a user. /// </summary> /// <remarks> /// Board gets added at the start. /// </remarks> /// <param name="board">Board object</param> /// <param name="username">User to add it to.</param> public async Task <string> AddAsync(BoardTask board, string username) { username = username.ToLower(); string id = _generator.NewId(username); board.Id = id; await Client.Cypher .Match("(user:User)") .Where((User user) => user.Username == username) .Call("apoc.lock.nodes([user])") .Match("(user)-[:CHILD_GROUP]->(previous)-[oldRel:NEXT]->(next)") .Create("(previous)-[:NEXT]->(board:Board {newBoard})-[:NEXT]->(next)") .WithParam("newBoard", board) .Create("(user)-[childBoardRel:CHILD_BOARD]->(board)") .Set("childBoardRel.shared = false") .Delete("oldRel") .With("user") .Set("user.boardCount = user.boardCount + 1") .ExecuteWithoutResultsAsync(); return(id); }
public async void GivenABoardSlugTaskIdAndTaskWhenBoardColumnDoesNotExistThenBadRequestReturned() { // Arrange SetupController(); const string boardSlug = "board-name"; const int taskId = 1; var boardTask = new BoardTask { Id = taskId, Name = "Updated Name" }; mockMediator.Setup( x => x.Send(It.IsAny <UpdateBoardTaskCommand>(), It.IsAny <CancellationToken>())) .Throws <BoardColumnNotFoundException>(); // Act var badRequestErrorMessageResult = await controller.Put(boardSlug, taskId, boardTask) as BadRequestErrorMessageResult; // Assert Assert.NotNull(badRequestErrorMessageResult); Assert.Equal("Board Column Not Found", badRequestErrorMessageResult.Message); }