private void ChangeLane(KanbanTask kanbanTask, int diff)
{
var currLane = db.Lanes
.Include(l => l.KanbanTasks)
.FirstOrDefault(l => l.KanbanTasks.Any(t => t.KanbanTaskId == kanbanTask.KanbanTaskId));
if (currLane != null)
{
var nextLanePos = currLane.Position + diff;
var nextLane = db.Lanes
.Include(l => l.KanbanTasks)
.FirstOrDefault(l => l.Position == nextLanePos);
if (nextLane != null)
{
kanbanTask.Performer = db.Users.FirstOrDefault(u => u.UserName == User.Identity.Name);
kanbanTask.LastChangeBy = db.Users.FirstOrDefault(u => u.UserName == User.Identity.Name);
kanbanTask.MovedAt = DateTime.Now;
kanbanTask.ChangedAt = DateTime.Now;
if (nextLane.Position > 1 && nextLane.Position < db.Lanes.ToList().Count())
{
kanbanTask.IsInProgress = true;
}
currLane.KanbanTasks.Remove(kanbanTask);
nextLane.KanbanTasks.Add(kanbanTask);
db.SaveChanges();
}
}
}
public ActionResult Create([Bind(Include = "Subject,Description,Tags")] KanbanTask kanbanTask)
{
if (ModelState.IsValid)
{
kanbanTask.CreatedAt = DateTime.Now;
kanbanTask.ChangedAt = DateTime.Now;
kanbanTask.MovedAt = DateTime.Now;
kanbanTask.DueDate = DateTime.Now.AddDays(7);
kanbanTask.Creator = db.Users.FirstOrDefault(u => u.UserName == User.Identity.Name);
kanbanTask.Performer = db.Users.FirstOrDefault(u => u.UserName == User.Identity.Name);
kanbanTask.LastChangeBy = db.Users.FirstOrDefault(u => u.UserName == User.Identity.Name);
db.Tasks.Add(kanbanTask);
db.SaveChanges();
var firstLane = db.Lanes
.Include(l => l.KanbanTasks)
.FirstOrDefault(l => l.Position == 1);
if (firstLane != null)
{
kanbanTask = db.Tasks
.OrderByDescending(t => t.CreatedAt)
.FirstOrDefault();
firstLane.KanbanTasks.Add(kanbanTask);
db.SaveChanges();
}
}
else
{
return(RedirectToAction("Create"));
}
return(RedirectToAction("Index", "Kanban"));
}
public IActionResult Create([FromForm] KanbanTask task)
{
task.OwnerRefId =
_signInContext.UserManager.GetUserId(User);
task.Owner = _context.Users.Find(task.OwnerRefId);
TaskManager.CreateTaskAsync(task);
return(RedirectToAction("Index"));
}
public ActionResult DeleteConfirmed(int id)
{
KanbanTask kanbanTask = db.Tasks.Find(id);
db.Tasks.Remove(kanbanTask);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult Edit([Bind(Include = "KanbanTaskId,Subject,Description,Tags,CreatedAt,DueDate,MovedAt,ChangedAt")] KanbanTask kanbanTask)
{
if (ModelState.IsValid)
{
db.Entry(kanbanTask).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(kanbanTask));
}
public void UpdateTask(KanbanTask task)
{
KanbanTask oldTask = _context.KanbanTasks.Find(task.Id);
foreach (var prop in oldTask.GetType().GetProperties())
{
prop.SetValue(oldTask, prop.GetValue(task));
}
_context.KanbanTasks.Update(task);
_context.SaveChanges();
}
public ActionResult ToPrevious(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
KanbanTask kanbanTask = db.Tasks.Find(id);
ChangeLane(kanbanTask, -1);
return(RedirectToAction("Index", "Kanban"));
}
public async Task Remove(KanbanTask task)
{
object queryParams = new
{
TaskId = task.Id
};
using var transactionScope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled);
using IDbConnection connection = connectionFactory.CreateConnection();
await connection.ExecuteAsync(DeleteQuery, queryParams);
transactionScope.Complete();
}
public async Task <KanbanList> GetByIdAndBoardIdWithTasks(int listId, int boardId)
{
object queryParams = new
{
ListId = listId,
BoardId = boardId
};
using IDbConnection connection = connectionFactory.CreateConnection();
KanbanList listCache = null;
var taskCache = new Dictionary <int, KanbanTask>();
_ = await connection.QueryAsync <KanbanList, KanbanTask, int?, KanbanList>(
GetByIdAndBoardIdWithTasksQuery,
map : (list, task, assignedMemberId) =>
{
if (listCache is null)
{
listCache = list;
}
if (task is object)
{
if (!taskCache.ContainsKey(task.Id))
{
taskCache.Add(task.Id, task);
}
if (assignedMemberId.HasValue)
{
KanbanTask kanbanTask = taskCache[task.Id];
kanbanTask.Assignments.Add(new BoardMember
{
User = new User
{
Id = assignedMemberId.Value
}
});
}
}
return(list);
},
queryParams,
splitOn : "title,id,user_id");
if (listCache is object)
{
listCache.Id = listId;
listCache.Tasks = taskCache.Select(task => task.Value).ToList();
}
return(listCache);
}
public async Task <ActionResult> UpdateKanbanTask([FromBody] KanbanTask kanbanTask)
{
try
{
_context.KanbanTasks.Update(kanbanTask);
await _context.SaveChangesAsync();
return(Ok());
}
catch (Exception)
{
return(BadRequest());
}
}
public ActionResult toggleIsInProgress(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
KanbanTask kanbanTask = db.Tasks.Find(id);
kanbanTask.IsInProgress = !kanbanTask.IsInProgress;
db.SaveChanges();
return(RedirectToAction("Index", "Kanban"));
}
// GET: KanbanTasks/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
KanbanTask kanbanTask = db.Tasks.Find(id);
if (kanbanTask == null)
{
return(HttpNotFound());
}
return(View(kanbanTask));
}
public async Task <KanbanTask> GetByIdAndBoardId(int taskId, int boardId)
{
object queryParams = new
{
BoardId = boardId,
TaskId = taskId
};
using IDbConnection connection = connectionFactory.CreateConnection();
KanbanTask kanbanTask = null;
_ = await connection.QueryAsync <KanbanTask, int, User, KanbanTask>(
GetByIdAndBoardIdQuery,
map : (task, listId, user) =>
{
if (kanbanTask is null)
{
kanbanTask = task;
kanbanTask.List = new KanbanList
{
Id = listId
};
}
if (user is object)
{
kanbanTask.Assignments.Add(new BoardMember
{
User = user
});
}
return(task);
},
queryParams,
splitOn : "list_id,id"
);
if (kanbanTask is object)
{
kanbanTask.Id = taskId;
kanbanTask.Board = new Board
{
Id = boardId
};
}
return(kanbanTask);
}
public async Task <ActionResult> DeleteKanbanTask(string id)
{
try
{
Guid guid = new Guid(id);
KanbanTask kanbanTask = await _context.KanbanTasks.FindAsync(guid);
_context.KanbanTasks.Remove(kanbanTask);
await _context.SaveChangesAsync();
return(Ok());
}
catch (Exception)
{
return(BadRequest());
}
}
public async Task <ActionResult> SetTaskStatus(string id, string status)
{
try
{
Guid guid = new Guid(id);
KanbanTask kanbanTask = await _context.KanbanTasks.FindAsync(guid);
kanbanTask.Status = status;
await _context.SaveChangesAsync();
return(Ok());
}
catch (Exception)
{
return(BadRequest());
}
}
public async Task <IEnumerable <KanbanTask> > GetAllTasksOfTheBoard(int boardId)
{
object queryParams = new
{
BoardId = boardId
};
using IDbConnection connection = connectionFactory.CreateConnection();
var taskCache = new Dictionary <int, KanbanTask>();
_ = await connection.QueryAsync <KanbanTask, int, int?, KanbanTask>(
GetAllTasksOfTheBoardQuery,
map : (task, listId, assignedUserId) =>
{
if (!taskCache.ContainsKey(task.Id))
{
task.List = new KanbanList
{
Id = listId
};
taskCache.Add(task.Id, task);
}
KanbanTask kanbanTask = taskCache[task.Id];
if (assignedUserId.HasValue)
{
kanbanTask.Assignments.Add(new BoardMember
{
User = new User
{
Id = assignedUserId.Value
}
});
}
return(task);
},
queryParams,
splitOn : "id,list_id,user_id"
);
return(taskCache.Select(task => task.Value));
}
public IActionResult Edit([FromForm] KanbanTask task)
{
task.ResponsibleUser = _context.Users.Find(task.ResponsibleUser?.Id) ?? task.ResponsibleUser;
if (!(User.IsInRole("Organizer") || (User.IsInRole("Team Player"))))
{
if (_signInContext.UserManager.GetUserId(User) != TaskManager.Tasks.Where(a => a.Id == task.Id)?.First()?.OwnerRefId)
{
return(RedirectToAction("Index"));
}
}
KanbanTask oldTask = TaskManager.Tasks.Find(t => t.Id == task.Id);
foreach (var prop in oldTask.GetType().GetProperties())
{
prop.SetValue(oldTask, prop.GetValue(task));
}
TaskManager.UpdateTask(oldTask);
return(RedirectToAction("Index"));
}
public async Task <ActionResult> Delete(int boardId, int taskId, int memberId)
{
bool boardExists = await _boardRepository.Exists(boardId);
if (!boardExists)
{
return(V1NotFound("Board not found"));
}
int userId = int.Parse(HttpContext.User.Identity.Name);
BoardMember userMember = await _memberRepository.GetByBoardIdAndUserId(boardId, userId);
if (userMember is null)
{
return(Forbid());
}
KanbanTask task = await _taskRepository.GetByIdAndBoardId(boardId, taskId);
if (task is null)
{
return(V1NotFound("Task not found"));
}
var member = new BoardMember
{
User = new User
{
Id = memberId
},
Board = new Board
{
Id = boardId
}
};
await _assignmentRepository.Remove(taskId, member);
return(NoContent());
}
public async Task <IActionResult> AddTask(KanbanTaskNewDTO taskToAdd)
{
var clientUsername = User.FindFirst(ClaimTypes.Name).Value;
var newTask = new KanbanTask();
newTask.Name = taskToAdd.Name;
newTask.Status = taskToAdd.Status;
newTask.Notes = taskToAdd.Notes;
newTask.DueDate = taskToAdd.DueDate;
newTask.Priority = taskToAdd.Priority;
try
{
await _kanbanRepo.AddTask(clientUsername, taskToAdd.ProjectName, taskToAdd.StoryName, newTask);
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
return(Ok());
}
public async Task <ActionResult> Create(int boardId, int taskId, int memberId)
{
bool boardExists = await _boardRepository.Exists(boardId);
if (!boardExists)
{
return(V1NotFound("Board not found"));
}
int userId = int.Parse(HttpContext.User.Identity.Name);
BoardMember userMember = await _memberRepository.GetByBoardIdAndUserId(boardId, userId);
if (userMember is null)
{
return(Forbid());
}
KanbanTask task = await _taskRepository.GetByIdAndBoardId(taskId, boardId);
if (task is null)
{
return(V1NotFound("Task not found"));
}
BoardMember member = await _memberRepository.GetByBoardIdAndUserId(boardId, memberId);
if (member is null)
{
return(V1NotFound("Member not found"));
}
bool existsAssignment = await _assignmentRepository.ExistsAssignment(taskId, member);
if (!existsAssignment)
{
await _assignmentRepository.Insert(taskId, member);
}
return(NoContent());
}
public async Task <KanbanTask> Insert(KanbanTask task)
{
using var transactionScope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled);
using IDbConnection connection = connectionFactory.CreateConnection();
object insertParams = new
{
task.Summary,
task.Description,
task.TagColor,
BoardId = task.Board.Id,
task.CreatedOn,
task.ModifiedOn
};
int taskId = await connection.ExecuteScalarAsync <int>(InsertQuery, insertParams);
object queryParams = new
{
TaskId = taskId,
ListId = task.List.Id
};
await connection.ExecuteAsync(InsertListTaskQuery, queryParams);
transactionScope.Complete();
return(new KanbanTask
{
Id = taskId,
Summary = task.Summary,
Description = task.Description,
TagColor = task.TagColor,
Board = task.Board,
List = task.List,
CreatedOn = task.CreatedOn,
ModifiedOn = task.ModifiedOn
});
}
public async Task <ActionResult> AddKanbanTask()
{
try
{
KanbanTask kanbanTask = new KanbanTask
{
TaskId = new Guid(),
Description = "",
DueDate = DateTime.Now,
ForField = "",
Status = "Ready"
};
await _context.KanbanTasks.AddAsync(kanbanTask);
await _context.SaveChangesAsync();
return(Ok(new { id = kanbanTask.TaskId, content = new { description = kanbanTask.Description, dueDate = kanbanTask.DueDate.ToString("MM/dd/yyyy"), forField = kanbanTask.ForField, status = kanbanTask.Status } }));
}
catch (Exception)
{
return(BadRequest());
}
}
public async Task AddTask(string username, string projectName, string storyName, KanbanTask newTask)
{
if (string.IsNullOrWhiteSpace(newTask.Name))
{
throw new Exception("Task name cannot be empty");
}
var user = await _context.Users.FirstOrDefaultAsync(x => x.Username == username);
var project = await _context.KanbanProjects.FirstOrDefaultAsync(x => x.Name == projectName && x.ParentUser == user);
if (project == null)
{
throw new Exception("Invalid project: [" + projectName + "]");
}
var story = await _context.KanbanStories.FirstOrDefaultAsync(x => x.Name == storyName && x.ParentProject == project);
if (story == null)
{
throw new Exception("Invalid story: [" + storyName + "]");
}
if (await _context.KanbanTasks.FirstOrDefaultAsync(x => x.Name == newTask.Name && x.ParentStory == story) != null)
{
throw new Exception("Task name must be unique within story");
}
newTask.CreationDate = DateTime.Now;
newTask.ParentStory = story;
await _context.KanbanTasks.AddAsync(newTask);
_context.SaveChanges();
}
public async Task <Board> GetByIdWithListsTasksAndMembers(int boardId)
{
object queryParams = new
{
BoardId = boardId
};
Board boardCache = null;
Dictionary <int, KanbanList> listCache = new Dictionary <int, KanbanList>();
Dictionary <int, KanbanTask> taskCache = new Dictionary <int, KanbanTask>();
using IDbConnection connection = _connectionFactory.CreateConnection();
IEnumerable <Board> boards = await connection
.QueryAsync <Board, User, BoardMember, KanbanList, KanbanTask, int?, Board>(
GetByIdWithListsTasksAndMembersQuery,
map : (board, user, member, list, task, userId) =>
{
if (boardCache is null)
{
boardCache = board;
}
if (member is object && !boardCache.Members.Any(_member => _member.User.Id == user.Id))
{
member.User = user;
boardCache.Members.Add(member);
}
if (list is object)
{
if (!listCache.ContainsKey(list.Id))
{
listCache.Add(list.Id, list);
}
board.Lists.Add(list);
}
if (task is object)
{
task.List = list;
if (!taskCache.ContainsKey(task.Id))
{
taskCache.Add(task.Id, task);
}
KanbanTask cachedTask = taskCache[task.Id];
if (userId.HasValue && !cachedTask.Assignments.Any(assignedMember => assignedMember.User.Id == userId))
{
cachedTask.Assignments.Add(new BoardMember
{
User = new User
{
Id = userId.Value
}
});
}
}
return(board);
},
queryParams,
splitOn : "id,is_admin,id,id,user_id");
if (boardCache is null)
{
return(boardCache);
}
IEnumerable <KanbanList> lists = listCache.Select(item => item.Value);
IEnumerable <KanbanTask> tasks = taskCache.Select(item => item.Value);
IEnumerable <KanbanList> boardLists = lists.GroupJoin(
inner: tasks,
outerKeySelector: list => list.Id,
innerKeySelector: task => task.List.Id,
resultSelector: (list, tasks) =>
{
list.Tasks = tasks.ToList();
return(list);
});
boardCache.Lists = boardLists.ToList();
boardCache.Id = boardId;
return(boardCache);
}
public async Task CreateTaskAsync(KanbanTask task)
{
await _context.KanbanTasks.AddAsync(task);
_context.SaveChanges();
}
public void DeleteTask(KanbanTask task)
{
_context.KanbanTasks.Remove(task);
_context.SaveChanges();
}
