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