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