public ConfirmationResponse Execute(AuthorizedIdRequest request)
{
request.ThrowExceptionIfInvalid();
var workTask = _workTaskRepository.Read(request.Id);
var backlog = _projectRepository.ReadProductBacklog(workTask.ProjectId);
var taskInBacklog = backlog.FirstOrDefault(x => x.WorkTaskId == workTask.Id);
if (taskInBacklog != null)
{
foreach (var s in workTask.ChildTasks)
{
if (!backlog.IsTaskInBacklog(s))
{
backlog.AddTaskToBacklog(new ProductBacklog.WorkTaskWithStatus(s, taskInBacklog.Status));
}
}
backlog.RemoveTaskFromBacklog(workTask.Id);
}
_projectRepository.UpdateProductBacklog(backlog);
_workTaskRepository.Delete(workTask.Id);
return(new ConfirmationResponse($"WorkTask {workTask.Name} successfully deleted.")
{
Id = workTask.Id,
});
}
public ViewProjectResponse Execute(AuthorizedIdRequest request)
{
request.ThrowExceptionIfInvalid();
var entity = _projectRepository.Read(request.Id);
var response = new ViewProjectResponse
{
Id = request.Id,
Name = entity.Name,
DefinitionOfDone = entity.DefinitionOfDone.Conditions,
Description = entity.Description,
TeamId = entity.TeamId,
};
var sprint = _sprintRepository.ReadCurrentSprint(request.Id);
if (sprint != null)
{
response.Sprint = _viewSprintUseCase.Execute(new AuthorizedIdRequest(request.UserId)
{
Id = sprint.Id,
});
response.Report = _sprintReportUseCase.Execute(new AuthorizedIdRequest(request.UserId)
{
Id = sprint.Id,
});
}
return(response);
}
public SprintReportResponse Execute(AuthorizedIdRequest request)
{
request.ThrowExceptionIfInvalid();
var sprint = _sprintRepository.Read(request.Id);
var backlog = _sprintRepository.ReadSprintBacklog(sprint.Id);
var records = _sprintRepository.ReadHistoryRecords(sprint.Id);
var groupByDate = records.GroupBy(x => x.Date).Select(x => new SprintReportResponse.Record
{
Date = x.Key,
DoneTasks = x.Average(y => y.DoneTasks),
ToDoTasks = x.Average(y => y.ToDoTasks),
InProgressTasks = x.Average(y => y.InProgressTasks),
}).OrderBy(x => x.Date).ToList();
var stories = backlog.Stories.Select(x =>
{
var story = _workTaskRepository.Read(x);
return(new SprintReportResponse.Story
{
Id = story.Id,
Name = story.Name,
StoryPoints = story.StoryPoints,
Completed = backlog.CompletedStories.Contains(x),
CompletedTasks = backlog.Tasks.Count(y => y.ParentTaskId == x && y.Status == SprintBacklog.WorkTaskStatus.Done),
TotalTasks = backlog.Tasks.Count(y => y.ParentTaskId == x),
});
});
if (groupByDate.Last().Date.Date != sprint.TimeSpan.Item2.Date)
{
var diff = sprint.TimeSpan.Item2.Date.Subtract(groupByDate.Last().Date.Date).Days;
for (var i = 1; i <= diff; ++i)
{
var item = groupByDate.Last();
groupByDate.Add(new SprintReportResponse.Record
{
Date = item.Date.AddDays(i),
DoneTasks = item.DoneTasks,
ToDoTasks = item.ToDoTasks,
InProgressTasks = item.InProgressTasks,
});
}
}
return(new SprintReportResponse
{
Sprint = sprint.ToInfo(),
Goal = sprint.Goal,
ProjectId = sprint.ProjectId,
TimeSpan = sprint.TimeSpan,
Stories = stories.ToArray(),
Records = groupByDate.ToArray(),
});
}
public ConfirmationResponse Execute(AuthorizedIdRequest request)
{
request.ThrowExceptionIfInvalid();
var meeting = _meetingRepository.Read(request.Id);
_meetingRepository.Delete(meeting.Id);
return(new ConfirmationResponse($"Meeting {meeting.Name} successfully deleted.")
{
Id = meeting.Id,
});
}
public ConfirmationResponse Execute(AuthorizedIdRequest request)
{
request.ThrowExceptionIfInvalid();
var document = _documentRepository.Read(request.Id);
_documentRepository.Delete(document.Id);
return(new ConfirmationResponse($"Document {document.Name} successfully deleted.")
{
Id = document.Id,
});
}
public ConfirmationResponse Execute(AuthorizedIdRequest request)
{
request.ThrowExceptionIfInvalid();
var team = _teamRepository.Read(request.Id);
_teamRepository.Delete(team.Id);
return(new ConfirmationResponse($"Team {team.Name} successfully deleted.")
{
Id = team.Id,
});
}
public ViewProjectHistoryResponse Execute(AuthorizedIdRequest request)
{
request.ThrowExceptionIfInvalid();
var team = _teamRepository.Read(request.Id);
var projects = _projectRepository.ReadTeamProjectHistory(team.Id);
return(new ViewProjectHistoryResponse
{
Team = team.ToInfo(),
Projects = projects.Records.Select(x => new ViewProjectHistoryResponse.Project
{
Id = x.RecordId,
To = x.To,
From = x.From
})
});
}
public ViewTeamHistoryResponse Execute(AuthorizedIdRequest request)
{
request.ThrowExceptionIfInvalid();
var project = _projectRepository.Read(request.Id);
var teams = _projectRepository.ReadProjectTeamHistory(project.Id);
return(new ViewTeamHistoryResponse
{
Project = project.ToInfo(),
Teams = teams.Records.Select(x => new ViewTeamHistoryResponse.Team
{
Id = x.RecordId,
To = x.To,
From = x.From,
}),
});
}
public ViewSprintResponse Execute(AuthorizedIdRequest request)
{
request.ThrowExceptionIfInvalid();
var sprint = _sprintRepository.Read(request.Id);
var backlog = _sprintRepository.ReadSprintBacklog(sprint.Id);
if (sprint.Status == SprintStatus.Planned)
{
var tasks = new List <SprintBacklog.WorkTaskWithStatus>();
foreach (var storyId in backlog.Stories)
{
var story = _workTaskRepository.Read(storyId);
tasks.AddRange(
story.ChildTasks
.Select(task => new SprintBacklog.WorkTaskWithStatus(task, storyId, SprintBacklog.WorkTaskStatus.ToDo)));
}
backlog.Tasks = tasks;
}
var responseStories = backlog.Stories.Select(x => new ViewSprintResponse.Story
{
Id = x,
Completed = backlog.CompletedStories.Contains(x),
Tasks = backlog.Tasks
.Where(y => y.ParentTaskId == x)
.Select(y => new Tuple <Identity, SprintBacklog.WorkTaskStatus>(y.WorkTaskId, y.Status)),
});
return(new ViewSprintResponse
{
Id = sprint.Id,
Goal = sprint.Goal,
Name = sprint.Name,
ProjectId = sprint.ProjectId,
TimeSpan = sprint.TimeSpan,
Stories = responseStories,
CanDelete = sprint.Status == SprintStatus.Planned,
Documents = sprint.Documents,
IsReportAvailable = sprint.Status != SprintStatus.Planned,
});
}
public ViewTeamHistoryResponse Execute(AuthorizedIdRequest request)
{
request.ThrowExceptionIfInvalid();
var person = _personRepository.Read(request.Id);
var teams = _teamRepository.ReadPersonTeamHistory(person.Id);
return(new ViewTeamHistoryResponse
{
Person = person.ToInfo(),
Teams = teams.Records.Select(x => new ViewTeamHistoryResponse.Team
{
Id = x.RecordId.Item1,
Roles = x.RecordId.Item2,
To = x.To,
From = x.From,
}),
});
}
public ViewDocumentResponse Execute(AuthorizedIdRequest request)
{
request.ThrowExceptionIfInvalid();
var entity = _documentRepository.ReadWithReferences(request.Id);
return(new ViewDocumentResponse
{
Id = entity.Document.Id,
Name = entity.Document.Name,
Project = entity.Document.Project,
Tasks = entity.Tasks,
Content = entity.Document.Content,
Kind = entity.Document.Kind,
Meetings = entity.Meetings,
Links = entity.Document.Links,
Sprints = entity.Sprints,
});
}
public ViewMeetingResponse Execute(AuthorizedIdRequest request)
{
request.ThrowExceptionIfInvalid();
var entity = _meetingRepository.Read(request.Id);
return(new ViewMeetingResponse
{
Id = entity.Id,
Description = entity.Description,
InvolvedPersons = entity.InvolvedPersons,
Name = entity.Name,
OrganizedBy = entity.OrganizedBy,
ProjectId = entity.ProjectId,
Time = entity.Time,
Duration = entity.Duration,
Log = entity.Log,
Documents = entity.Documents,
});
}
public ProjectReportResponse Execute(AuthorizedIdRequest request)
{
request.ThrowExceptionIfInvalid();
var project = _projectRepository.Read(request.Id);
var records = _projectRepository.ReadHistoryRecords(project.Id);
var sprints = _sprintRepository.ReadSprints(project.Id, SprintStatus.Done);
var recordsByDate = records.GroupBy(x => x.Date).Select(x => new ProjectReportResponse.Record
{
Date = x.Key,
DoneTasks = x.Average(y => y.DoneTasks),
ToDoTasks = x.Average(y => y.ToDoTasks),
InSprintTasks = x.Average(y => y.InSprintTasks),
ReadyTasks = x.Average(y => y.ReadyTasks),
});
var sprintReports = sprints.Select(x =>
{
var sprintBacklog = _sprintRepository.ReadSprintBacklog(x.Id);
return(new ProjectReportResponse.Sprint
{
Id = x.Id,
Name = x.Name,
EndDate = x.TimeSpan.Item2,
PlannedStories = sprintBacklog.Stories.Count,
PlannedValue = sprintBacklog.Stories.Sum(y => _workTaskRepository.Read(y).StoryPoints ?? 0),
CompletedStories = sprintBacklog.CompletedStories.Count,
CompletedValue = sprintBacklog.CompletedStories.Sum(y => _workTaskRepository.Read(y).StoryPoints ?? 0),
});
});
return(new ProjectReportResponse
{
Project = project.ToInfo(),
Records = recordsByDate.ToArray(),
Sprints = sprintReports.ToArray(),
});
}
public ViewMemberHistoryResponse Execute(AuthorizedIdRequest request)
{
request.ThrowExceptionIfInvalid();
var team = _teamRepository.Read(request.Id);
var history = _teamRepository.ReadTeamPersonHistory(team.Id);
return(new ViewMemberHistoryResponse
{
Team = team.ToInfo(),
Members = history.Records.Select(x => new ViewMemberHistoryResponse.TeamMembers(
x.RecordId.Select(y => new ViewMemberHistoryResponse.Member
{
Id = y.Item1,
Role = y.Item2,
}))
{
To = x.To,
From = x.From,
}),
});
}
public ConfirmationResponse Execute(AuthorizedIdRequest request)
{
request.ThrowExceptionIfInvalid();
var sprint = _sprintRepository.Read(request.Id);
var sprintBacklog = _sprintRepository.ReadSprintBacklog(sprint.Id);
var projectBacklog = _projectRepository.ReadProductBacklog(sprint.ProjectId);
foreach (var s in sprintBacklog.Stories)
{
projectBacklog.UpdateTask(new ProductBacklog.WorkTaskWithStatus(s, ProductBacklog.WorkTaskStatus.Ready));
}
_sprintRepository.Delete(sprint.Id);
_projectRepository.UpdateProductBacklog(projectBacklog);
return(new ConfirmationResponse($"Sprint {sprint.Name} successfully deleted.")
{
Id = sprint.Id,
});
}
public ViewWorkTaskResponse Execute(AuthorizedIdRequest request)
{
request.ThrowExceptionIfInvalid();
var entity = _workTaskRepository.Read(request.Id);
return(new ViewWorkTaskResponse
{
Id = entity.Id,
Name = entity.Name,
Description = entity.Description,
ProjectId = entity.ProjectId,
ParentTask = entity.ParentTask,
Type = entity.Type,
ChildTasks = entity.ChildTasks,
StoryPoints = entity.StoryPoints,
Steps = entity.Steps,
Comments = entity.Comments,
CanEdit = CanWorkTaskBeEdited(entity),
CanEditParent = entity.ParentTask.IsBlankIdentity() || CanWorkTaskBeEdited(_workTaskRepository.Read(entity.ParentTask)),
Documents = entity.Documents,
});
}
