コード例 #1
0
        public void HighlightChangesets(TrackProgressParameters trackProgressParams = null)
        {
            bool incrementProgress = false;

            if (trackProgressParams != null)
            {
                if (trackProgressParams.ShouldSetMaximumValue())
                {
                    trackProgressParams.TrackProgress.MaxProgress
                        = WorkItemCache
                          .Where(workItem => workItem.IsSelected)
                          .Select(workItem => workItem.RelatedChangesetCount)
                          .Sum();
                }
                if (!trackProgressParams.ShouldExecute())
                {
                    return;
                }
                incrementProgress = trackProgressParams.ShouldIncrement();
            }

            var changesetsToHighlight = new List <int>();
            var workItemsWithWarnings = new Dictionary <int, string>();
            var map = _changesetCacheMap;

            var warnings = new System.Text.StringBuilder();

            foreach (var item in WorkItemCache.Where(workItem => workItem.IsSelected))
            {
                int countWarnings = 0;
                warnings.Clear();
                foreach (var changeset in item.RelatedChangesetsAsEnumerable)
                {
                    if (trackProgressParams != null)
                    {
                        if (incrementProgress)
                        {
                            trackProgressParams.TrackProgress.Increment();
                        }
                        trackProgressParams.CancellationToken.ThrowIfCancellationRequested();
                    }

                    if (map.ContainsKey(changeset.Changeset.ChangesetId))
                    {
                        changesetsToHighlight.Add(changeset.Changeset.ChangesetId);
                    }
                    if (!map.ContainsKey(changeset.Changeset.ChangesetId) || !map[changeset.Changeset.ChangesetId].IsVisible)
                    {
                        ++countWarnings;
                        warnings.Append(String.Format("Changeset #{0}, Comment: {1}\n", changeset.Changeset.ChangesetId, changeset.Changeset.Comment));
                    }
                }
                if (countWarnings > 0)
                {
                    workItemsWithWarnings[item.TfsWorkItem.Id] =
                        String.Format("The following {0} items were not found in the changeset view:\n", countWarnings)
                        + warnings;
                }
            }

            foreach (var item in ChangesetCache)
            {
                item.IsHighlighted = changesetsToHighlight.Contains(item.TfsChangeset.Changeset.ChangesetId);
            }

            foreach (var item in WorkItemCache)
            {
                string warningText = null;
                item.HasWarning  = workItemsWithWarnings.TryGetValue(item.TfsWorkItem.Id, out warningText);
                item.WarningText = item.HasWarning ? warningText : null;
            }
        }
コード例 #2
0
        /// <summary>
        /// Highlight work items which are referred to by selected changesets
        /// </summary>
        /// <param name="trackProgressParams">TrackProgressParameters</param>
        public void HighlightWorkItems(TrackProgressParameters trackProgressParams = null)
        {
            bool incrementProgress = false;

            if (trackProgressParams != null)
            {
                if (trackProgressParams.ShouldSetMaximumValue())
                {
                    trackProgressParams.TrackProgress.MaxProgress
                        = ChangesetCache
                          .Count(changeset => changeset.IsSelected);
                }
                if (!trackProgressParams.ShouldExecute())
                {
                    return;
                }
                incrementProgress = trackProgressParams.ShouldIncrement();
            }

            var workItemsToHighlight   = new List <int>();
            var changesetsWithWarnings = new Dictionary <int, string>();
            var map      = _workItemCacheMap;
            var warnings = new System.Text.StringBuilder();

            foreach (var item in ChangesetCache.Where(changeset => changeset.IsSelected))
            {
                if (trackProgressParams != null)
                {
                    if (incrementProgress)
                    {
                        trackProgressParams.TrackProgress.Increment();
                    }
                    trackProgressParams.CancellationToken.ThrowIfCancellationRequested();
                }

                int countWarnings = 0;
                warnings.Clear();
                item.HasWarning = false;
                foreach (var workItem in item.TfsChangeset.RelatedWorkItems)
                {
                    if (trackProgressParams != null)
                    {
                        trackProgressParams.CancellationToken.ThrowIfCancellationRequested();
                    }
                    if (map.ContainsKey(workItem.Id))
                    {
                        workItemsToHighlight.Add(workItem.Id);
                    }
                    if (!map.ContainsKey(workItem.Id) || !map[workItem.Id].IsVisible)
                    {
                        ++countWarnings;
                        warnings.Append(String.Format("Work Item #{0}, Title: {1}\n", workItem.Id, workItem.Title));
                    }
                }
                if (countWarnings > 0)
                {
                    changesetsWithWarnings[item.TfsChangeset.Changeset.ChangesetId] = String.Format("The following {0} items were not found in the work item view:\n", countWarnings)
                                                                                      + warnings;
                }
            }

            Repository.Instance.BackgroundTaskManager.Send(
                () =>
            {
                foreach (var item in WorkItemCache)
                {
                    item.IsHighlighted = workItemsToHighlight.Contains(item.TfsWorkItem.Id);
                }

                foreach (var item in ChangesetCache)
                {
                    string warningText = null;
                    item.HasWarning    = changesetsWithWarnings.TryGetValue(item.TfsChangeset.Changeset.ChangesetId, out warningText);
                    item.WarningText   = item.HasWarning ? warningText : null;
                }
                return(true);
            });
        }