Esempio n. 1
0
        private async Task ProcessWorkItemRevision(WorkItem workItemRev, WorkItemRevisionBuilder revs)
        {
            var stateChange = new StateChange
            {
                State  = workItemRev.State(),
                Reason = workItemRev.Reason(),
                By     = workItemRev.ChangedByNameOnly()
            };

            if (revs.TfsInfo == null)
            {
                // we just want the latest info for work item. might be able to grab from just the
                // last revision
                var workItem = await this.workItemClient.GetWorkItemAsync(workItemRev.Id.Value);

                revs.TfsInfo = new TfsInfo
                {
                    Id         = workItem.Id.Value,
                    Title      = workItem.Title(),
                    Type       = workItem.Type(),
                    State      = workItem.State(),
                    Iteration  = workItem.IterationPath(),
                    Tags       = workItem.Tags(),
                    Priority   = workItem.Priority(),
                    ClosedDate = workItem.ClosedDate()
                };

                if (workItemRev.IsBug())
                {
                    revs.TfsInfo.Severity = workItem.Severity();
                }
            }

            var stateChangeDate = workItemRev.StateChangeDate();

            if (stateChangeDate != null)
            {
                if (revs.LastStateChangeDate != null)
                {
                    stateChange.StateChangeDate = stateChangeDate.Value;

                    var diff = stateChange.StateChangeDate - revs.LastStateChangeDate.Value;
                    stateChange.DurationText = diff.Humanize();
                }
                else
                {
                    stateChange.StateChangeDate = workItemRev.CreatedDate();
                }

                revs.LastStateChangeDate = stateChangeDate;
            }

            revs.States.Add(stateChange);

            lock (this.lockObject)
            {
                this.revisionsCount++;
            }
        }
Esempio n. 2
0
        private async Task <TfsInfo> ProcessWorkItemRevisions(WorkItemReference workItemRef)
        {
            var revisions = await this.workItemClient.GetRevisionsAsync(
                workItemRef.Id,
                expand : WorkItemExpand.Fields);

            string lastState = null;
            var    revs      = new WorkItemRevisionBuilder();

            foreach (var workItemRev in revisions)
            {
                var state = workItemRev.State();

                if (state != null && lastState != state)
                {
                    lastState = state;
                    await ProcessWorkItemRevision(workItemRev, revs);
                }
            }

            if (revs.States.Count > 1)
            {
                var sbTemp = new StringBuilder();

                for (int i = 0; i < revs.States.Count; i++)
                {
                    sbTemp.Append(revs.States[i].Summary);

                    if (i + 1 < revs.States.Count)
                    {
                        sbTemp.AppendLine();
                    }

                    revs.TfsInfo.Transitions = sbTemp.ToString().Trim();
                }

                revs.TfsInfo.TransitionCount = revs.States.Count;
            }

            lock (this.lockObject)
            {
                this.processedCount++;

                var progress = new ReportProgress
                {
                    Message            = $"{revs.TfsInfo.Title}",
                    WorkItemsProcessed = this.processedCount,
                    TotalCount         = this.totalCount
                };

                this.broadcastService.ReportProgress(progress);
            }

            return(revs.TfsInfo);
        }