Esempio n. 1
0
        /// <summary>
        /// Creates the triage item models list.
        /// </summary>
        /// <param name="team">The team.</param>
        /// <param name="groupedTriageIssues">The grouped triage issues.</param>
        /// <returns></returns>
        private async Task <List <TeamMemberTriageIssuesModel> > CreateTriageItemModelsList(TeamModel team, Dictionary <string, List <AgileIssue> > groupedTriageIssues)
        {
            var groupedTriageIssuesModel = new List <TeamMemberTriageIssuesModel>();

            var tasks = team.TeamMembersNames.AsParallel().Select(async teamMember =>
            {
                var issue = groupedTriageIssues.ContainsKey(teamMember)
                    ? groupedTriageIssues[teamMember] : new List <AgileIssue>();

                var teamMemberTriageIssuesModel = new TeamMemberTriageIssuesModel
                {
                    Developer = teamMember.Replace(" (Contractor)", "").Replace(" (contractor)", ""),
                };

                teamMemberTriageIssuesModel = await FilterIssuesByType(teamMemberTriageIssuesModel, issue);

                groupedTriageIssuesModel.Add(teamMemberTriageIssuesModel);
            });

            await Task.WhenAll(tasks);

            return(groupedTriageIssuesModel);
        }
Esempio n. 2
0
        /// <summary>
        /// Filters the type of the issues by.
        /// </summary>
        /// <param name="triageIssues">The team member triage issues model.</param>
        /// <param name="issues">The issues.</param>
        /// <returns></returns>
        private async Task <TeamMemberTriageIssuesModel> FilterIssuesByType(TeamMemberTriageIssuesModel triageIssues, List <AgileIssue> issues)
        {
            triageIssues.GropedImpedimentIssues = issues
                                                  .Where(i => _impededIssueTypes.Contains(i.Fields.Status.Name))
                                                  .ToList();

            triageIssues.GroupedWorkedIssues = issues
                                               .Where(i => i.Fields.Progress.Progress != null && (i.Fields.Progress.Progress >= i.Fields.Progress.Total || i.Fields.Progress.Percent == 100))
                                               .ToList();

            triageIssues.GroupedWillWorkIssues = issues
                                                 .Where(i => !triageIssues.GroupedWorkedIssues.Contains(i) && !triageIssues.GropedImpedimentIssues.Contains(i))
                                                 .ToList();
            // Checking will work issues on estimate present
            triageIssues.GroupedWillWorkIssues = FilterWillWorkIssuesByEstimateTime(triageIssues.GroupedWillWorkIssues);

            // Checking worked on issues that issues were completed after last report creating
            triageIssues.GroupedWorkedIssues = await
                                               _checkLogService.ChechWorkedOnIssues(triageIssues.GroupedWorkedIssues,
                                                                                    triageIssues.Developer);

            return(triageIssues);
        }