private void Validate(ScrumTask task)
{
if (task.Title == null || task.Title.Trim().Length == 0)
{
_validationDictionary.AddError("Content", "Title is required.");
}
if (task.Title != null && task.Title.Trim().Length < 3)
{
_validationDictionary.AddError("Content", "Title must contain at least 3 characters.");
}
if (task.Title != null && task.Title.Trim().Length > 40)
{
_validationDictionary.AddError("Content", "Title must contain less than 40 characters.");
}
if (task.Content == null || task.Content.Trim().Length == 0)
{
_validationDictionary.AddError("Content", "Content is required.");
}
if (task.Content != null && task.Content.Trim().Length < 3)
{
_validationDictionary.AddError("Content", "Content must contain at least 3 characters.");
}
if (task.Content != null && task.Content.Trim().Length > 2000)
{
_validationDictionary.AddError("Content", "Content must contain less than 2000 characters.");
}
if (_unitOfWork.Sprints.Get(task.SprintId) == null)
{
_validationDictionary.AddError("SprintId", "Sprint with this id does not exist.");
}
}
public IActionResult Patch([FromODataUri] int key, [FromBody] Delta <ScrumTask> patch)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
ScrumTask task = _tasks.GetById(key);
if (task == null)
{
return(NotFound());
}
patch.Patch(task);
try
{
_tasks.Save();
}
catch (DbUpdateConcurrencyException)
{
if (!TaskExists(key))
{
return(NotFound());
}
else
{
throw;
}
}
return(Updated(task));
}
private void UpdateTaskType(ScrumTask task, TaskType taskType, int?tookId = null)
{
if (task.TaskType == TaskType.Done)
{
return;
}
if (tookId != null)
{
var took = _unitOfWork.Estimations.Get(tookId.Value);
if (took == null)
{
return;
}
task.Took = took;
task.DoneAt = DateTime.Today;
}
else
{
task.TookId = null;
task.DoneAt = null;
}
task.TaskType = taskType;
CheckIfTaskTypeChangeIsPermitted(task);
}
private void Kanban_CardTapped(object sender, KanbanTappedEventArgs e)
{
SQLiteConnection Connection = new SQLiteConnection("Data Source=" + Environment.CurrentDirectory + Properties.Settings.Default.DBPath);
Connection.Open();
DataContext db = new DataContext(Connection);
// Get a typed table to run queries.
Table <SprintTask> SprintTsks = db.GetTable <SprintTask>();
Table <ScrumTask> ScrumTsks = db.GetTable <ScrumTask>();
int SprintTaskID;
Int32.TryParse((e.SelectedCard.Content as KanbanModel).ID, out SprintTaskID);
ScrumTask tsk = (from sp in SprintTsks
join sc in ScrumTsks on sp.ScrumTaskID equals sc.ID
where sp.ID == SprintTaskID
select sc).SingleOrDefault();
TaskExternalID.Text = tsk.ExternalID.ToString();
TaskExternalID.Tag = e.SelectedCard;
TaskTitle.Text = tsk.Title;
TaskDescription.Text = tsk.Description;
TaskTeamMember.SelectedIndex = -1;
// e.SelectedCard.;
}
public void PostTasks_ReturnsCreatedODataResult()
{
// Arrange
var mockRepository = new Mock <IRepository <ScrumTask> >();
var controller = new TasksController(mockRepository.Object);
ScrumTask task = new ScrumTask
{
ActualHours = 0,
Blocked = false,
Completed = null,
Description = "Set-up SVN, project folders, SharePoint, project page",
PlannedHours = 72,
RemainingHours = 72,
Started = null,
State = TaskState.ToDo,
Story = null,
StoryId = 1,
Summary = "SVN, Project Page",
TaskId = 111,
Type = TaskType.Analyses,
User = null,
UserId = 1
};
// Act
var actionResult = controller.Post(task);
//Assert.IsNotNull(actionResult);
//CreatedODataResult<ScrumTask> result = actionResult as CreatedODataResult<ScrumTask>;
// Assert
Assert.IsNotNull(actionResult);
Assert.IsInstanceOfType(actionResult, typeof(CreatedODataResult <ScrumTask>));
}
private void CheckIfTaskTypeChangeIsPermitted(ScrumTask task)
{
var sprint = _unitOfWork.Sprints.Get(task.SprintId);
if (sprint != null && (sprint.StartsAt > DateTime.Now || sprint.EndsAt < DateTime.Now))
{
_validationDictionary.AddError("SprintId", "This sprint is inactive.");
}
}
private void UpdateEstimation(ScrumTask task, int estimationId)
{
if (task.TaskType == TaskType.Done)
{
return;
}
var estimation = _unitOfWork.Estimations.Get(estimationId);
task.EstimationId = estimation?.Id;
}
private void UpdateUser(ScrumTask task, string userId)
{
if (task.TaskType == TaskType.Done)
{
return;
}
var user = _unitOfWork.Users.Get(userId);
task.UserId = user?.Id;
}
public IActionResult Post([FromBody] ScrumTask task)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_tasks.Create(task);
_tasks.Save();
return(Created(task));
}
public ScrumTask Create(ScrumTask newScrumTask)
{
newScrumTask.CreatedAt = DateTime.Now;
Validate(newScrumTask);
if (_validationDictionary.IsValid)
{
_unitOfWork.ScrumTasks.Add(newScrumTask);
_unitOfWork.Complate();
}
return(newScrumTask);
}
private static void UpdatePriority(ScrumTask task, byte priority)
{
if (task.TaskType == TaskType.Done)
{
return;
}
if (!Enumerable.Range(1, 5).Contains(priority))
{
task.Priority = null;
}
task.Priority = priority;
}
public async Task <ActionResult> Create(TaskCreateViewModel model)
{
//Ensure valid input
if (!ModelState.IsValid)
{
return(View("_Create", model));
}
//Find feature
var feature = _db.Features.Find(model.FeatureId);
if (feature == null)
{
return(HttpNotFound("Feature not found."));
}
//TODO: Ensure user is allowed access to this project
//Create new task
var task = new ScrumTask()
{
Title = model.Title,
Description = model.Description,
State = model.State,
TimeRemaining = model.TimeRemaining,
Priority = feature.Tasks.Count + 1,
};
try
{
//Save new feature
feature.Tasks.Add(task);
await _db.SaveChangesAsync();
return(Json(new { success = true }));
}
catch (Exception exception)
{
model.Error = exception.Message;
return(View("_Create", model));
}
}
public static void FillTasksData()
{
_dbTasks = new Repository <ScrumTask>(_context);
ScrumTask[] tasks = new ScrumTask[]
{
new ScrumTask()
{
Summary = "SVN, Project Page",
Story = _dbStories.GetById(1),
Description = "Set-up SVN, project folders, SharePoint, project page",
User = _dbUsers.GetById(5),
Blocked = false,
PlannedHours = 72,
RemainingHours = 72,
ActualHours = 0,
Started = new DateTime(2018, 7, 6, 12, 45, 30),
Completed = new DateTime(2018, 8, 8, 20, 45, 30),
Type = TaskType.Analyses, State = TaskState.ToDo,
WorkNotes = "This task should be done in 72 hours"
},
new ScrumTask()
{
Summary = "Validating entity classes",
Story = _dbStories.GetById(2),
Description = "Add validation to entity classes",
User = _dbUsers.GetById(13),
Blocked = false,
PlannedHours = 72,
RemainingHours = 48,
ActualHours = 24,
Started = new DateTime(2018, 7, 6, 12, 45, 30),
Completed = new DateTime(2018, 7, 3, 20, 45, 30),
Type = TaskType.Coding, State = TaskState.InProgress,
WorkNotes = "This task should be done in 72 hours"
},
new ScrumTask()
{
Summary = "Manual tests",
Story = _dbStories.GetById(7),
Description = "Run manual tests",
User = _dbUsers.GetById(16),
Blocked = false,
PlannedHours = 26,
RemainingHours = 0,
ActualHours = 24,
Started = new DateTime(2018, 7, 6, 12, 45, 30),
Completed = new DateTime(2018, 8, 7, 12, 45, 30),
Type = TaskType.Documentation, State = TaskState.Done,
WorkNotes = "This task should be done in 26 hours"
},
new ScrumTask()
{
Summary = "User docment draft review",
Story = _dbStories.GetById(8),
Description = "User docment draft review",
User = _dbUsers.GetById(17),
Blocked = false,
PlannedHours = 56,
RemainingHours = 8,
ActualHours = 48,
Started = new DateTime(2018, 7, 6, 12, 45, 30),
Completed = new DateTime(2018, 7, 8, 20, 45, 30),
Type = TaskType.Documentation, State = TaskState.InProgress,
WorkNotes = "This task should be done in 56 hours"
},
new ScrumTask()
{
Summary = "Automated tests",
Story = _dbStories.GetById(9),
Description = "Create automated tests",
User = _dbUsers.GetById(23),
Blocked = false,
PlannedHours = 72,
RemainingHours = 0,
ActualHours = 56,
Started = new DateTime(2018, 7, 6, 12, 45, 30),
Completed = new DateTime(2018, 7, 8, 20, 45, 30),
Type = TaskType.Testing, State = TaskState.Done,
WorkNotes = "This task should be done in 72 hours"
}
};
AddToDatabase(tasks, _dbTasks);
}
private static void UpdateContent(ScrumTask task, string content)
{
task.Content = content;
}
private static void UpdateTitle(ScrumTask task, string title)
{
task.Title = title;
}
