private async Task <List <ITestAttachment> > GetRunAddtionalData(ITestRunBase run, TestObjectType type)
        {
            try
            {
                ProgressText = string.Format("Collecting attachments for Test Run: {0}", run.Title);
                List <ITestAttachment> runAttachments = new List <ITestAttachment>();
                //IEnumerable<ITestAttachment> attachments = null;
                await Task.Run(() =>
                {
                    //attachments = TestQueryHelper.CreateAttachmentsQuery(run.Id, type);

                    foreach (ITestAttachment attachment in run.Attachments)
                    {
                        if (IsCancelPending())
                        {
                            break;
                        }

                        if ((attachment.Length / 1024f) / 1024f >= MinimumSize && Extensions.Where(s => s.IsSelected).
                            Any(e => e.Title.Equals(Any) ||
                                (e.IsSelected && attachment.Name.EndsWith("." + e.Title))))
                        {
                            runAttachments.Add(attachment);
                        }
                    }
                });

                return(runAttachments);
            }
            catch (Exception ex)
            {
                return(null);
            }
        }
        public TestRunAttachmentInfo(ITestRunBase run, TestObjectType type, List<ITestAttachment> attachments, List<WorkItem> relatedWorkitems)
        {
            Run = run;
            Type = type;
            MatchedAttachments = attachments;
            RelatedWorkitems = relatedWorkitems;

            Title = Run.Title;
            Owner = run.OwnerName;
            DateStarted = Run.DateStarted;

            FormatLength = string.Format(new FileSizeFormatProvider(), "{0:fs}", attachments.Sum(attachment => attachment.Length));
        }
        public TestRunAttachmentInfo(ITestRunBase run, TestObjectType type, List <ITestAttachment> attachments, List <WorkItem> relatedWorkitems)
        {
            Run  = run;
            Type = type;
            MatchedAttachments = attachments;
            RelatedWorkitems   = relatedWorkitems;

            Title       = Run.Title;
            Owner       = run.OwnerName;
            DateStarted = Run.DateStarted;

            FormatLength = string.Format(new FileSizeFormatProvider(), "{0:fs}", attachments.Sum(attachment => attachment.Length));
        }
        internal bool MatchesDateRange(ITestRunBase run)
        {
            DateTime dateCreated = run.DateCreated;

            if (dateCreated.Kind == DateTimeKind.Utc)
            {
                dateCreated = DateTime.SpecifyKind(dateCreated, DateTimeKind.Local);
            }
            if ((this.OlderThan != DateTime.MinValue) && (dateCreated > this.OlderThan))
            {
                return(false);
            }
            return((this.NewerThan == DateTime.MinValue) || (dateCreated >= this.NewerThan));
        }
        private async Task <List <WorkItem> > GetRelatedWorkItems(ITestRunBase run, List <ITestAttachment> attachments)
        {
            try
            {
                ProgressText = string.Format("Collecting related work items for Test Run: {0}", run.Title);
                List <WorkItem> relatedWorkItems = new List <WorkItem>();
                await Task.Run(() =>
                {
                    List <string> source = attachments.Select(attachment => attachment.ArtifactUri.ToString()).ToList();

                    Dictionary <string, int[]> workItemIdsForArtifactUris = new Dictionary <string, int[]>();
                    workItemIdsForArtifactUris = TfsShared.Instance.WorkItemStore.GetWorkItemIdsForArtifactUris(source.ToArray(), DateTime.Now);

                    foreach (var wits in workItemIdsForArtifactUris.Values)
                    {
                        if (IsCancelPending())
                        {
                            break;
                        }

                        if (wits == null)
                        {
                            continue;
                        }
                        foreach (var witId in wits)
                        {
                            if (IsCancelPending())
                            {
                                break;
                            }

                            WorkItem wit = TfsShared.Instance.WorkItemStore.GetWorkItem(witId);
                            if (States.Where(s => s.IsSelected).Any(s => s.Title.Equals(Any) || s.Title.Equals(wit.State)))
                            {
                                relatedWorkItems.Add(wit);
                            }
                        }
                    }
                });

                return(relatedWorkItems);
            }
            catch (Exception ex)
            {
                return(null);
            }
        }
 internal bool MatchesDateRange(ITestRunBase run)
 {
     DateTime dateCreated = run.DateCreated;
     if (dateCreated.Kind == DateTimeKind.Utc)
         dateCreated = DateTime.SpecifyKind(dateCreated, DateTimeKind.Local);
     if ((this.OlderThan != DateTime.MinValue) && (dateCreated > this.OlderThan))
         return false;
     return (this.NewerThan == DateTime.MinValue) || (dateCreated >= this.NewerThan);
 }
        private async Task<List<WorkItem>> GetRelatedWorkItems(ITestRunBase run, List<ITestAttachment> attachments)
        {
            try
            {
                ProgressText = string.Format("Collecting related work items for Test Run: {0}", run.Title);
                List<WorkItem> relatedWorkItems = new List<WorkItem>();
                await Task.Run(() =>
                {
                    List<string> source = attachments.Select(attachment => attachment.ArtifactUri.ToString()).ToList();

                    Dictionary<string, int[]> workItemIdsForArtifactUris = new Dictionary<string, int[]>();
                    workItemIdsForArtifactUris = TfsShared.Instance.WorkItemStore.GetWorkItemIdsForArtifactUris(source.ToArray(), DateTime.Now);

                    foreach (var wits in workItemIdsForArtifactUris.Values)
                    {
                        if (IsCancelPending()) break;

                        if (wits == null) continue;
                        foreach (var witId in wits)
                        {
                            if (IsCancelPending()) break;

                            WorkItem wit = TfsShared.Instance.WorkItemStore.GetWorkItem(witId);
                            if (States.Where(s => s.IsSelected).Any(s => s.Title.Equals(Any) || s.Title.Equals(wit.State)))
                                relatedWorkItems.Add(wit);
                        }
                    }
                });

                return relatedWorkItems;
            }
            catch (Exception ex)
            {
                return null;
            }
        }
        private async Task<List<ITestAttachment>> GetRunAddtionalData(ITestRunBase run, TestObjectType type)
        {
            try
            {
                ProgressText = string.Format("Collecting attachments for Test Run: {0}", run.Title);
                List<ITestAttachment> runAttachments = new List<ITestAttachment>();
                //IEnumerable<ITestAttachment> attachments = null;
                await Task.Run(() =>
                {
                    //attachments = TestQueryHelper.CreateAttachmentsQuery(run.Id, type);

                    foreach (ITestAttachment attachment in run.Attachments)
                    {
                        if (IsCancelPending()) break;

                        if ((attachment.Length / 1024f) / 1024f >= MinimumSize && Extensions.Where(s=>s.IsSelected).
                                                                                  Any(e => e.Title.Equals(Any) || 
                                                                                  (e.IsSelected && attachment.Name.EndsWith("." + e.Title))))
                            runAttachments.Add(attachment);
                    }
                });

                return runAttachments;
            }
            catch (Exception ex)
            {
                return null;
            }
        }