Ejemplo n.º 1
0
        private void RelatedChangesets()
        {
            if (string.IsNullOrEmpty(this.BuildUri))
            {
                this.GetLatestInfo();
            }

            this.LogTaskMessage(string.Format(CultureInfo.CurrentCulture, "Retrieving changesets related to Build {0}", this.BuildUri));
            var build      = this.buildServer.GetAllBuildDetails(new Uri(this.BuildUri));
            var changesets = InformationNodeConverters.GetAssociatedChangesets(build);
            var taskItems  = new List <ITaskItem>();

            changesets.ForEach(
                x =>
            {
                ITaskItem item = new TaskItem(x.ChangesetId.ToString(CultureInfo.CurrentCulture));
                item.SetMetadata("CheckedInBy", x.CheckedInBy ?? string.Empty);
                item.SetMetadata("ChangesetUri", x.ChangesetUri != null ? x.ChangesetUri.ToString() : string.Empty);
                item.SetMetadata("Comment", x.Comment ?? string.Empty);
                taskItems.Add(item);
            });

            this.RelatedItems = taskItems.ToArray();
        }
Ejemplo n.º 2
0
        private List <WordDocumentGenerator.Client.Entities.BuildDetail> GetDataContext()
        {
            var buildDetails = new List <BuildDetail>();

            foreach (var build in this.Builds)
            {
                var buildDetail = new BuildDetail()
                {
                    DocumentDetail              = new DocumentDetail(),
                    Build                       = new Build(),
                    BuildConfigurations         = new List <BuildConfiguration>(),
                    BuildConfigurationSolutions = new List <BuildConfigurationSolution>(),
                    Changesets                  = new List <Changeset>(),
                    ChangesetChangeDetails      = new List <ChangesetChangeDetail>(),
                    WorkItems                   = new List <WordDocumentGenerator.Client.Entities.WorkItem>(),
                    TestResult                  = new TestResult(),
                    TestResultPassedItems       = new List <TestResultPassedItem>(),
                    TestResultFailedItems       = new List <TestResultFailedItem>(),
                    TestResultInconclusiveItems = new List <TestResultInconclusiveItem>()
                };

                // Load Document Details into BuildDetails
                buildDetail.DocumentDetail.Title     = build.BuildNumber;
                buildDetail.DocumentDetail.CreatedOn = DateTime.Now.ToLongDateString();
                buildDetail.DocumentDetail.CreatedBy = Environment.UserName;

                // Load Build Details into BuildDetails
                buildDetail.Build.BuildDefinition = !string.IsNullOrEmpty(build.BuildDefinition.Name) ? build.BuildDefinition.Name : string.Empty;              // "Tailspin Toys";
                // Null check - only if the build controller was removed & the builds not deleted will the controller be null
                buildDetail.Build.BuildController  = build.BuildDefinition.BuildController != null ? build.BuildDefinition.BuildController.Name : "Unavilable"; // "WIN-GS9GMUJITS8 - Controller";
                buildDetail.Build.BuildNumber      = !string.IsNullOrEmpty(build.BuildNumber) ? build.BuildNumber : "Unavilable";                               // "Tailspin Toys - Iteration 2_20100318.2";
                buildDetail.Build.BuildQuality     = !string.IsNullOrEmpty(build.Quality) ? build.Quality : "Not Set";
                buildDetail.Build.BuildState       = build.Status.ToString();                                                                                   // "Succeeded";
                buildDetail.Build.BuildTeamProject = build.TeamProject;                                                                                         // "Tailspin Toys";
                buildDetail.Build.BuildTestStatus  = build.TestStatus.ToString();                                                                               // "Passed";

                // TODO: Add a new function to create this from start and finish time
                buildDetail.Build.BuildTotalExecutionTimeInSeconds = CalculateTotalBuildExecutionTime(build.StartTime, build.FinishTime);          // "86 seconds";

                buildDetail.Build.BuildUri                = build.Uri;                                                                             // new Uri(@"vstfs:///VersionControl/Build/17");
                buildDetail.Build.BuildStartTime          = build.StartTime.ToString("dd MM YYYY hh:mm:ss");                                       // "01-01-2011 12:09:07";
                buildDetail.Build.BuildSourceGetVersion   = !string.IsNullOrEmpty(build.SourceGetVersion) ? build.SourceGetVersion : "Unavilable"; // "70";
                buildDetail.Build.BuildShelvesetName      = !string.IsNullOrEmpty(build.ShelvesetName) ? build.ShelvesetName : "Not Shelved";      // @"Tailspin Toys\@2_20100318.2";
                buildDetail.Build.BuildRetainIndefinitely = build.KeepForever.ToString();                                                          // "false";
                buildDetail.Build.BuildRequestedBy        = !string.IsNullOrEmpty(build.RequestedBy) ? build.RequestedBy : "Unavilable";           // @"WIN-GS9GMUJITS8\abuobe";
                buildDetail.Build.BuildReason             = build.Reason.ToString();                                                               // "CI";
                buildDetail.Build.BuildLogLocation        = !string.IsNullOrEmpty(build.LogLocation) ? build.LogLocation : "Unavailable";          // @"\\Log\\Folder\abc\TailSpin Toys\Tailspin Toys - Iteration 2_20100318.2";
                buildDetail.Build.BuildLastChangedOn      = build.LastChangedOn.ToString();                                                        // "05-01-2012 13:01:37";
                buildDetail.Build.BuildLastChangedBy      = build.LastChangedBy;                                                                   // @"UK\tarora";

                // Todo: create a new function to generate the string for the last modified duration
                buildDetail.Build.BuildLastModifiedNoOfDaysAgo = CalculateTotalBuildExecutionTime(build.LastChangedOn, DateTime.Now);

                buildDetail.Build.BuildLabelName = !string.IsNullOrEmpty(build.LabelName) ? build.LabelName : "Not Labeled"; // @"Tailspin Toys@\Label\2_20100318.2";
                buildDetail.Build.BuildIsDeleted = build.IsDeleted.ToString();                                               // "false";
                buildDetail.Build.BuildEndTime   = build.FinishTime.ToString();                                              // "01-01-2011 12:10:35";

                // ToDo: create a new function to generate the string for the completed no of days ago
                buildDetail.Build.BuildCompletedNoOfDaysAgo = CalculateTotalBuildExecutionTime(build.FinishTime, DateTime.Now);

                buildDetail.Build.BuildDropLocation = !string.IsNullOrEmpty(build.DropLocation) ? build.DropLocation : "Unavailable"; // @"\\Drop\\Folder\abc\TailSpin Toys\Tailspin Toys - Iteration 2_20100318.2";

                if (!this.Exclusions.Contains("BuildConfiguration"))
                {
                    // Load Build Configuration into BuildDetails
                    foreach (IConfigurationSummary configSummary in InformationNodeConverters.GetConfigurationSummaries(build))
                    {
                        var buildConfigSummary = new BuildConfiguration();
                        buildConfigSummary.BuildConfigFlavor        = configSummary.Flavor;                              // "Mixed Platform";
                        buildConfigSummary.BuildConfigPlatform      = configSummary.Platform;                            // "Debug";
                        buildConfigSummary.BuildConfigTotalErrors   = configSummary.TotalCompilationErrors.ToString();   // "0";
                        buildConfigSummary.BuildConfigTotalWarnings = configSummary.TotalCompilationWarnings.ToString(); // "1";

                        buildDetail.BuildConfigurations.Add(buildConfigSummary);
                    }

                    // Load Build Configuration Solutions into BuildDetails
                    foreach (IBuildProjectNode buildConfig in InformationNodeConverters.GetTopLevelProjects(build.Information))
                    {
                        var buildConfigurationSolution = new BuildConfigurationSolution();
                        buildConfigurationSolution.BuildRootNodeSolutionServerPath = buildConfig.ServerPath;
                        buildConfigurationSolution.BuildRootNodeErrorCount         = buildConfig.CompilationErrors.ToString();
                        buildConfigurationSolution.BuildRootNodeWarningCount       = buildConfig.CompilationWarnings.ToString();
                        buildConfigurationSolution.BuildRootNodeLogFile            = buildConfig.LogFile != null ? buildConfig.LogFile.Url.AbsolutePath : string.Empty;

                        buildDetail.BuildConfigurationSolutions.Add(buildConfigurationSolution);
                    }
                }

                if (!this.Exclusions.Contains("Changesets"))
                {
                    // check if the user selected Changesets, Load changesets into BuildDetails
                    foreach (IChangesetSummary changesetInfo in InformationNodeConverters.GetAssociatedChangesets(build.Information))
                    {
                        var changesetDetail = this.VersionControlServer.GetChangeset(changesetInfo.ChangesetId);
                        buildDetail.Changesets.Add(new WordDocumentGenerator.Client.Entities.Changeset
                        {
                            ChangesetId          = changesetDetail.ChangesetId.ToString(),
                            ChangesetUri         = changesetDetail.ArtifactUri,             // new Uri(@"vstfs:///VersionControl/Changeset/63"),
                            ChangesetCommittedOn = changesetDetail.CreationDate.ToString(), // "01-01-2011 12:05:01",
                            ChangesetCommittedBy = changesetDetail.Owner,                   // @"UK\tarora",
                            ChangesetComment     = changesetDetail.Comment                  // "Refactoring code improvements"
                        });

                        var changes = new List <string>();
                        foreach (var ch in changesetDetail.Changes)
                        {
                            changes.Add(ch.Item.ServerItem);
                        }

                        buildDetail.ChangesetChangeDetails.Add(new ChangesetChangeDetail
                        {
                            ChangesetChangeId          = changesetDetail.ChangesetId.ToString(),
                            ChangesetChangeServerPaths = changes
                        });
                    }
                }

                if (!this.Exclusions.Contains("WorkItems"))
                {
                    // check if the user selected WorkItems
                    // Load workItems into BuildDetails
                    foreach (IWorkItemSummary workItemInfo in InformationNodeConverters.GetAssociatedWorkItems(build))
                    {
                        var workItemDetail = WorkItemStore.GetWorkItem(workItemInfo.WorkItemId);
                        buildDetail.WorkItems.Add(new WordDocumentGenerator.Client.Entities.WorkItem()
                        {
                            WorkItemId            = workItemDetail.Id.ToString(),
                            WorkItemUri           = workItemDetail.Uri,
                            WorkItemType          = workItemDetail.Type.Name,
                            WorkItemTitle         = workItemDetail.Title,
                            WorkItemState         = workItemDetail.State,
                            WorkItemIterationPath = workItemDetail.IterationPath,
                            WorkItemAreaPath      = workItemDetail.AreaPath,
                            WorkItemAssignedTo    = workItemInfo.AssignedTo
                        });
                    }

                    string introduction = string.Empty;
                    foreach (var wiT in buildDetail.WorkItems.Select(d => d.WorkItemType).Distinct())
                    {
                        introduction = string.Format("{0} {1}, ", buildDetail.WorkItems.Where(wi => wi.WorkItemType == wiT).ToList().Count, string.Format("{0}(s)", wiT));
                    }

                    if (introduction.Length != 0)
                    {
                        introduction = introduction.Remove(introduction.Length - 2);
                    }

                    buildDetail.WorkItemIntroduction = introduction;
                }

                if (!this.Exclusions.Contains("TestResults"))
                {
                    // check if user selected Test Results
                    // Load test results into BuildDetails
                    foreach (var tr in TestManagementService.GetTeamProject(buildDetail.Build.BuildTeamProject).TestRuns.ByBuild(build.Uri))
                    {
                        buildDetail.TestResult.TestResultId                    = tr.Id.ToString();
                        buildDetail.TestResult.TestResultTitle                 = tr.Title;
                        buildDetail.TestResult.TestResultStatus                = tr.State.ToString();                        // "Complete";
                        buildDetail.TestResult.TestResultTotalTest             = tr.Statistics.TotalTests.ToString();        // "24";
                        buildDetail.TestResult.TestResultTotalTestCompleted    = tr.Statistics.CompletedTests.ToString();    // "24";
                        buildDetail.TestResult.TestResultTotalTestPassed       = tr.Statistics.PassedTests.ToString();       // "22";
                        buildDetail.TestResult.TestResultTotalTestFailed       = tr.Statistics.FailedTests.ToString();       // "1";
                        buildDetail.TestResult.TestResultTotalTestInconclusive = tr.Statistics.InconclusiveTests.ToString(); // "1";

                        double result = 0.0;
                        if (tr.Statistics.TotalTests != 0)
                        {
                            // var passPerc = decimal.MinValue;
                            result = tr.Statistics.PassedTests * 100 / tr.Statistics.TotalTests;
                        }

                        buildDetail.TestResult.TestResultTotalTestPassRate = result.ToString();
                        buildDetail.TestResult.TestResultIsAutomated       = tr.IsAutomated.ToString(); // "false";

                        // Load testResultPassedItems into BuildDetails
                        // Check for passed tests
                        foreach (ITestCaseResult lp in tr.QueryResultsByOutcome(TestOutcome.Passed))
                        {
                            buildDetail.TestResultPassedItems.Add(new WordDocumentGenerator.Client.Entities.TestResultPassedItem()
                            {
                                TestResultPassedListStatus = "Passed",
                                TestResultPassedListTitle  = lp.TestCaseTitle
                            });
                        }

                        // Load testResultsFailedItems into BuildDetails
                        foreach (ITestCaseResult lf in tr.QueryResultsByOutcome(TestOutcome.Failed))
                        {
                            buildDetail.TestResultFailedItems.Add(new WordDocumentGenerator.Client.Entities.TestResultFailedItem()
                            {
                                TestResultFailedListStatus = "Failed",
                                TestResultFailedListTitle  = lf.TestCaseTitle,
                                TestResultFailedListReason = lf.ErrorMessage
                            });
                        }

                        // Load testResultsInconclusiveItems into BuildDetails
                        foreach (ITestCaseResult li in tr.QueryResultsByOutcome(TestOutcome.Inconclusive))
                        {
                            buildDetail.TestResultInconclusiveItems.Add(new WordDocumentGenerator.Client.Entities.TestResultInconclusiveItem()
                            {
                                TestResultInconclusiveListStatus = "Inconclusive",
                                TestResultInconclusiveListTitle  = li.TestCaseTitle
                            });
                        }
                    }
                }

                buildDetails.Add(buildDetail);
            }

            return(buildDetails);
        }
Ejemplo n.º 3
0
        private void OnBuildCompletionEvent(BuildCompletionEvent2 e)
        {
            Debug.instance().Write("Process Build Number " + e.BuildNumber + " from " + e.TeamProject);

            var tfs        = Utils.ConnectToTFS();
            var buildStore = (IBuildServer)tfs.GetService(typeof(IBuildServer));

            var url      = new Uri(e.Url);
            var buildUri = HttpUtility.ParseQueryString(url.Query).Get("builduri");
            var detail   = buildStore.GetBuild(new Uri(buildUri));

            detail.RefreshAllDetails();

            var changeSetsData = InformationNodeConverters.GetAssociatedChangesets(detail);

            Debug.instance().Write("Number of ChangeSets: " + changeSetsData.Count);

            var reference = e.DefinitionPath;
            var index     = reference.LastIndexOf("\\");

            if (index >= 0)
            {
                reference = reference.Substring(index + 1);
            }

            var results = v1Component.Value.GetBuildProjects(reference);

            if (results.Count == 0)
            {
                Debug.instance().Write("No results for reference " + reference);
            }

            foreach (var buildProject in results)
            {
                var ts       = DateTime.Parse(e.FinishTime) - DateTime.Parse(e.StartTime);
                var buildRun = v1Component.Value.CreateBuildRun(buildProject, e.BuildNumber, DateTime.Parse(e.FinishTime), ts.Seconds);

                var statuses = v1Component.Value.GetBuildRunStatuses();
                var status   = e.StatusCode == "Succeeded"
                                 ? statuses.First(x => x.Name == "Passed")
                                 : statuses.First(x => x.Name == "Failed");
                buildRun.Status = status;

                v1Component.Value.CreateLink(new Link(e.Url, "TFS Build Results", true), buildRun);

                var descriptionBuilder = new StringBuilder();

                foreach (var csd in changeSetsData)
                {
                    var changeSets = v1Component.Value.GetChangeSets("TFS:" + csd.ChangesetId);

                    foreach (var changeSet in changeSets)
                    {
                        if (descriptionBuilder.Length > 0)
                        {
                            descriptionBuilder.Append(Environment.NewLine);
                        }

                        descriptionBuilder.Append(changeSet.Description);

                        foreach (var primaryWorkitem in v1Component.Value.GetPrimaryWorkitems(changeSet))
                        {
                            var remove = v1Component.Value.GetBuildRuns(primaryWorkitem, buildProject);

                            v1Component.Value.RemoveBuildRunsFromWorkitem(primaryWorkitem, remove);
                            v1Component.Value.Save(primaryWorkitem);

                            v1Component.Value.AddBuildRunsToWorkitem(primaryWorkitem, new[] { buildRun });
                            v1Component.Value.Save(primaryWorkitem);
                        }
                    }

                    v1Component.Value.AddChangeSetsToBuildRun(buildRun, changeSets);
                    v1Component.Value.Save(buildRun);
                }

                buildRun.Description = descriptionBuilder.ToString();
                v1Component.Value.Save(buildRun);
            }

            Debug.instance().Write("BuildRun Save Successful");
        }