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