public Build Parse(string inputXmlData)
        {
            ValidateAndLoadXml(inputXmlData);

            try
            {
                var build = new Build();

                XmlElement integrationProperties = xmlDocument["cruisecontrol"]["integrationProperties"];

                string buildTrigger = integrationProperties["CCNetBuildCondition"].InnerText;
                string buildStatus = integrationProperties["CCNetIntegrationStatus"].InnerText;

                build.Trigger = GetTrigger(buildTrigger);

                build.StartTime = GetStartTime();
                TimeSpan duration = GetBuildDuration();
                build.FinishedTime = build.StartTime + duration;
                build.Status = ParseStatus(buildStatus);

                return build;
            }
            catch (Exception ex)
            {
                throw new CruiseControlRepositoryException(
                    "There was an error parsing the XML-file. " +
                    "Please refer to the inner exception for details.", ex);
            }
        }

        public ProBuilds(String champ)
        {
            Builds = new List<Build>();
            String htmlPage = new WebClient().DownloadString("http://lolbuilder.net/" + champ);
            foreach (Match buildsRegex in new Regex("#(build\\-[0-9]+)\">([a-zA-Z ]+) \\(<span class=\"hover-text\" tooltip=\"Seen in up to ([0-9]+)").Matches(htmlPage))
            {
                Build build = new Build();

                Match buildRegex = new Regex(buildsRegex.Groups[1].ToString()).Matches(htmlPage)[1];
                String buildSectionHtml = htmlPage.Substring(buildRegex.Index);

                String summaryHtml = buildSectionHtml.Substring(buildSectionHtml.IndexOf("build-summary-separator separator"));
                summaryHtml = summaryHtml.Substring(0, summaryHtml.IndexOf("build-box starting-items"));
                String startingHtml = buildSectionHtml.Substring(buildSectionHtml.IndexOf("build-box starting-items"));
                startingHtml = startingHtml.Substring(0, startingHtml.IndexOf("build-box early-game"));
                String orderHtml = buildSectionHtml.Substring(buildSectionHtml.IndexOf("build-box early-game"));
                orderHtml = orderHtml.Substring(0, orderHtml.IndexOf("build-box final-items"));
                String finalHtml = buildSectionHtml.Substring(buildSectionHtml.IndexOf("build-box final-items"));
                if (finalHtml.IndexOf("build-app-text") > 0)
                    finalHtml = finalHtml.Substring(0, finalHtml.IndexOf("build-app-text"));

                build.Name = buildsRegex.Groups[2].ToString();
                build.Popularity = buildsRegex.Groups[3].ToString();
                build.Summary = GetItemsFromHtml(summaryHtml);
                build.StartingItems = GetItemsFromHtml(startingHtml);
                build.Order = GetItemsFromHtml(orderHtml);
                build.BestItems = GetItemsFromHtml(finalHtml);

                Builds.Add(build);
            }
        }

        public shared()
        {
            this.firstDate = new DateTime(2000, 10, 10);
            this.secondDate = new DateTime(2000, 10, 11);
            this.failedBuild1 = new Build() { FinishedTime = firstDate, Status = DomainModel.CI.BuildStatus.FinishedWithFailure };
            this.failedBuild2 = new Build() { FinishedTime = firstDate, Status = DomainModel.CI.BuildStatus.FinishedWithFailure };
            this.failedBuild3 = new Build() { FinishedTime = secondDate, Status = DomainModel.CI.BuildStatus.FinishedWithFailure };
            this.successBuild1 = new Build() { FinishedTime = firstDate, Status = DomainModel.CI.BuildStatus.FinishedSuccefully };
            this.successBuild2 = new Build() { FinishedTime = secondDate, Status = DomainModel.CI.BuildStatus.FinishedSuccefully };

            this.project1 = new CIProject("test one");
            project1.AddBuild(failedBuild1);
            project1.AddBuild(successBuild1);

            this.project2 = new CIProject("test two");
            project2.AddBuild(failedBuild2);
            project2.AddBuild(failedBuild3);
            project2.AddBuild(successBuild2);

            this.ciserver = new CIServer("server", "serverurl");
            ciserver.AddProject(project1);
            ciserver.AddProject(project2);

            repository.Setup(r => r.Get(It.IsAny<AllSpecification<CIServer>>()))
                .Returns(new List<CIServer>() { ciserver });
        }

 public void Can_dispose_of_configuration_after_usage()
 {
     var conf = new FullConfiguration();
     var parserBuilder = new Build().Configuration(conf);
     parserBuilder.Dispose();
     Assert.That(conf.DisposeCalled);
 }

        public void deploy(ArtifactoryBuild task, Build build, BuildInfoLog log) 
        {
            ArtifactoryBuildInfoClient client = new ArtifactoryBuildInfoClient(task.Url, task.User, task.Password, log);
            client.setProxy(build.deployClient);
            client.setConnectionTimeout(build.deployClient);

            try
            {
                if (task.DeployEnabled != null && task.DeployEnabled.Equals("true"))
                {
                    /* Deploy every artifacts from the Map< module.name : artifact.name > => List<DeployDetails> */
                    task.deployableArtifactBuilderMap.ToList().ForEach(entry => entry.Value.ForEach(artifact => client.deployArtifact(artifact)));
                }

                if (task.BuildInfoEnabled != null && task.BuildInfoEnabled.Equals("true"))
                {
                    //Upload Build Info json file to Artifactory
                    log.Info("Uploading build info to Artifactory...");
                    /* Send Build Info  */
                    client.sendBuildInfo(build);
                }
            }
            catch (Exception e)
            {
                log.Error("Exception has append from ArtifactoryBuildInfoClient: " + e.Message, e);
                throw new Exception("Exception has append from ArtifactoryBuildInfoClient: " + e.Message, e);
            }
            finally 
            {
                client.Dispose();
            }         
        }

        public Build Parse(Project project, HtmlNode[] columns)
        {
            _log.DebugFormat("Parsing a build configuration for {0}", project.Name);

            if (columns.Length != 3)
            {
                throw new TeamcityStatusParseException("The build row had the incorrect number of columns");
            }

            var buildConfigurationColumn = columns[0];
            var buildConfigurationLink = buildConfigurationColumn.SelectSingleNode("a");
            var buildConfigurationUrl = buildConfigurationLink.Attributes["href"].Value;
            var currentBuildLink = columns[1].SelectSingleNode("div/a");

            var build = new Build
            {
                Project = project,
                Name = buildConfigurationLink.InnerText,
                Id = GetId(buildConfigurationUrl),
                State = GetBuildState(buildConfigurationColumn),
                Url = buildConfigurationUrl
            };

            if (currentBuildLink != null)
            {
                build.CurrentBuildNumber = currentBuildLink.InnerText.Replace("#", string.Empty);
                build.CurrentBuildUrl = currentBuildLink.Attributes["href"].Value;
            }

            _log.DebugFormat("Parsed build configuration {0} ({1}) - {2}", build.Name, build.Id, build.State);

            return build;
        }

 protected override bool Input()
 {
     Console.WriteLine("Please input script name:");
     _Name = Console.ReadLine();
     build = new Build(_DesPath, _Name);
     return true;
 }

 private Root GetRootModelFromBuild(Build b)
 {
     var server = new Isop.Server.IsopServerFromBuild( ()=> b );
     var data = JsonConvert.SerializeObject(server.GetModel());
     var client = new IsopClient(new JsonHttpClientThatOnlyReturns(data), "http://localhost:666");
     return client.GetModel().Result;
 }

 void AnalysisJson()
 {
     var BuildString = (new WebClient()).DownloadString("https://dewrito.halo.click/api/builds");
     _list = JsonConvert.DeserializeObject<List<JObject>>(BuildString).Select((t) =>
     {
         JArray jar = JArray.Parse(t["artifacts"].ToString());
         Build b = new Build()
         {
             Branch = t["branch"].ToString(),
             BuildVersion = t["buildVersion"].ToString(),
             CommitAuthor = t["commitAuthor"].ToString(),
             CommitId = t["commitId"].ToString(),
             CommitMessage = t["commitMessage"].ToString(),
             downloadUrl = t["downloadUrl"].ToString(),
             CommitDate = Convert.ToDateTime(t["commitDate"])
         };
         for (var i = 0; i < jar.Count; i++)
         {
             JObject j = JObject.Parse(jar[i].ToString());
             b.size = j["size"].ToString();
             b.url = j["url"].ToString();
         }
         return b;
     }).ToList() as List<Build>;
     _list.Reverse();
 }

 public static void OnBuildStarted(BuildStarted e, Build view)
 {
     view.buildId = e.Id;
     view.Tasks = new List<TaskInfo>(e.Status.Tasks);
     view.Tasks.ForEach(info => view.TerminalOutput[info.Id] = new List<string>(){""});
     view.Status = Build.BuildOverallStatus.Started;
 }

 private static Controller Controller(Build that, Type type)
 {
     return new Controller
                {
                    Name = type.ControllerName(),
                    Methods = type.GetControllerActionMethods().Select(m => Method(that, type, m)).ToArray()
                };
 }

 public void AbortBuild(MergeRequest mergeRequest, Build build)
 {
     var projectClient = client.GetRepository(mergeRequest.SourceProjectId);
     var actualBuild = build ?? projectClient.Builds.GetBuilds().FirstOrDefault();
     if (actualBuild == null || (actualBuild.Status != BuildStatus.pending && actualBuild.Status != BuildStatus.running))
         return;
     projectClient.Builds.Cancel(actualBuild);
 }

 public void Can_generate_tree_model_from_configuration_with_controllers()
 {
     var treemodel = new Build()
         .Recognize(new MyController())
         .GetMethodTreeModel();
     Assert.That(treemodel.Controllers.Count(), Is.EqualTo(1));
     Assert.That(treemodel.GlobalParameters.Count(), Is.EqualTo(0));
 }

 protected override void OnStartup(StartupEventArgs e)
 {
     base.OnStartup(e);
     var path = Directory.GetParent(System.Reflection.Assembly.GetExecutingAssembly().Location)
         .FullName;
     ParserBuilder = new Build().ConfigurationFrom(
         path);
 }

 public void Can_read_documentation_for_properties()
 {
     var conf = new FullConfiguration();
     var parserBuilder = new Build().Configuration(conf);
     var globalDesc = parserBuilder.GlobalParameters
         .First(gp => gp.Argument.Prototype.Equals("Global")).Description;
     Assert.That(globalDesc, Is.EqualTo("GLOBAL!!"));
 }

 public void It_can_report_usage_for_actions_with_description()
 {
     var usage = new Build()
                             .Recognize(typeof(DescriptionController))
                             .ShouldRecognizeHelp()
                             .HelpFor("Description","action1");
     Assert.That(LineSplit(usage), Is.EquivalentTo(LineSplit(@"Action1   Some description 1")));
 }

 public MethodTreeModel(IEnumerable<Param> globalParameters, IEnumerable<Controller> controllers, Build build)
 {
     GlobalParameters=globalParameters;
     Controllers=controllers;
     singleEventHandlerScope = new SingleScopeOnly();
     GlobalParameters.RegisterPropertyChanged(globalValueChanged);
     Build = build;
 }

 public void Save(string path, Build build)
 {
     XmlSerializer serializer = new XmlSerializer(typeof(Build));
     using (var stream = new FileStream(path, FileMode.Create))
     {
         serializer.Serialize(stream, build);
     }
 }

        private static void Main(string[] args)
        {
            using (var build = new Build()
                .Recognize(typeof(DotGraphController))
                .Recognize(typeof(GraphController))
                .Recognize(typeof(SerializeController)))
            {
                try
                {
                    var parsedMethod = build.Parse(args);
                    if (parsedMethod.UnRecognizedArguments.Any())//Warning:
                    {
                        var unRecognizedArgumentsMessage = string.Format(
                                                               @"Unrecognized arguments:
            {0}
            Did you mean any of these arguments?
            {1}", String.Join(",", parsedMethod.UnRecognizedArguments.Select(unrec => unrec.Value).ToArray()),
                                                               String.Join(",", parsedMethod.ArgumentWithOptions.Select(rec => rec.Name).ToArray()));
                        Console.WriteLine(unRecognizedArgumentsMessage);
                        Environment.Exit(1);
                    }
                    else
                    {
                        parsedMethod.Invoke(Console.Out);
                    }
                }
                catch (TypeConversionFailedException ex)
                {

                    Console.WriteLine(String.Format("Could not convert argument {0} with value {1} to type {2}",
                            ex.Argument, ex.Value, ex.TargetType));
                    if (null != ex.InnerException)
                    {
                        Console.WriteLine("Inner exception: ");
                        Console.WriteLine(ex.InnerException.Message);
                    }
                    Environment.Exit(1);
                }
                catch (MissingArgumentException ex)
                {
                    Console.WriteLine(String.Format("Missing argument(s): {0}", String.Join(", ", ex.Arguments.ToArray())));
                    if (build.RecognizesHelp)
                        Console.WriteLine(build.Help());
                    Environment.Exit(1);
                }
                #if DEBUG
                catch (Exception ex1)
                {
                    Console.WriteLine(string.Join(Environment.NewLine, new object[]
                            {
                                "The invokation failed with exception:",
                                ex1.Message, ex1.StackTrace
                            }));
                    Environment.Exit(1);
                }
                #endif
            }
        }

        public BuildUpdated(Build entity, IEnumerable<Expression<Func<Build, object>>> updatedValues)
        {
            _buildId = entity.Id;

            foreach (var updatedValue in updatedValues)
            {
                _updatedValues[GetMemberInfo(updatedValue).Member.Name] = updatedValue.Compile().Invoke(entity);
            }
        }