protected override void OnNavigatedTo(NavigationEventArgs e)
        {
            base.OnNavigatedTo(e);
            SetDefaultUI();
            buildReceived = e.Parameter as Build;
            buildTB.Text = buildReceived.BuildNumber;
            //if (BuildP != null && pivotIndex >= 0)
            //{
            //    BuildP.SelectedIndex = pivotIndex;
            //}
            GetAndSetPItems();

        }
 private QueuedBuild queueBuild(Build b, string branch)
 {
     bool success = false;
     QueuedBuild queuedB = new QueuedBuild();
     if(String.IsNullOrWhiteSpace(branch) )
     {
         branch = b.SourceBranch;
     }
     if (b.Definition != null)
     {
         success = VSTSService.QueueBuild(b.Definition.Id, branch, "", out queuedB);
     }
     return queuedB;
 }
        private async void showQueueBuildContentDialog(Build b)
        {
            QueuedBuild qb = new QueuedBuild();
            if (b == null) return;

            QueueBuildCB.DataContext = b;
            QueueBuildCB.HorizontalAlignment = HorizontalAlignment.Center;
            QueueBuildCB.VerticalAlignment = VerticalAlignment.Center;

            var result = await QueueBuildCB.ShowAsync();

            if (result == ContentDialogResult.Primary)
            {
                qb = queueBuild(b, "");

                if (!String.IsNullOrWhiteSpace(qb.BuildNumber))
                {
                    Utility.ShowToastMessage("Build queued successfully!", qb.BuildNumber);
                    ifRefresh = true;
                }
                else
                {
                    Utility.ShowToastMessage("Failed to queue build.", "Please retry later...");
                }
            }
        }
        private void GetAndSetPItems()
        {
            Pivot p = BuildP;
            if (p != null)
            {
                PivotItem pi = p.SelectedItem as PivotItem;
                if (pi == null) return;

                if (pi.Name.Equals("summaryPI"))
                {
                    if (build == null)
                    {
                        summarySP.Visibility = Visibility.Collapsed;
                        ShowProgressBar();
                        Task.Factory.StartNew(() =>
                        {
                            build = VSTSService.GetABuild(buildReceived.Url);
                        }).ContinueWith(async (Task t) =>
                        {
                            await this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
                            {
                                summaryPI.DataContext = build;
                                if (build.FinishTime != null && build.StartTime != null)
                                {
                                    durationTB.Text = build.FinishTime.Subtract(build.StartTime).TotalMinutes + " mins";
                                }
                                HideProgressBar();
                                summarySP.Visibility = Visibility.Visible;
                            });
                        });
                    }
                    else
                    {
                        summaryPI.DataContext = build;
                        summarySP.Visibility = Visibility.Visible;
                    }
                }
                else if (pi.Name.Equals("timelinePI"))
                {
                    ShowProgressBar();
                    if (timelineRecords != null)
                    {
                        HideProgressBar();
                        timelineLV.ItemsSource = timelineRecords;
                    }
                    else {
                        Task.Factory.StartNew(() =>
                        {
                            timelineRecords = VSTSService.GetBuildTimeLineRecords(build.Url + "/timeline");
                        }).ContinueWith(async (Task t) =>
                        {
                            await this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
                            {
                                timelineLV.ItemsSource = timelineRecords;
                                HideProgressBar();
                            });
                        });
                    }
                }
                else if (pi.Name.Equals("artifactsPI"))
                {
                    ShowProgressBar();
                    if (artifactsList != null)
                    {
                        HideProgressBar();
                        artifactsLV.ItemsSource = artifactsList;
                    }
                    else {
                        Task.Factory.StartNew(() =>
                        {
                            artifactsList = VSTSService.GetBuildArtifactss(build.Url + "/artifacts");
                        }).ContinueWith(async (Task t) =>
                        {
                            await this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
                            {
                                artifactsLV.ItemsSource = artifactsList;
                                HideProgressBar();
                            });
                        });
                    }
                }
                //if (BuildP != null)
                //{
                //    pivotIndex = BuildP.SelectedIndex;
                //}
            }
        }
        private static Build getABuildFromJson(dynamic bb)
        {
            Build build = new Build
            {
                Id = bb.id,
                BuildNumber = bb.buildNumber,
                Status = bb.status,
                Result = bb.result,
                Url = bb.url,
                QueueTime = bb.queueTime,
                FinishTime = bb.finishTime,
                StartTime = bb.startTime,
                SourceBranch = bb.sourceBranch,
                SourceVersion = bb.sourceVersion,
                Priority = bb.priority,
                Reason = bb.reason
            };
            
            dynamic queueJson = bb.queue;

            if(queueJson != null)
            {
                build.Queue = new Queue
                {
                    Id = queueJson.id,
                    Name = queueJson.name
                };
            }

            dynamic identityJson = bb.requestedFor;
            if(identityJson != null)
            {
                build.RequestedFor = getIdentityFronJson(identityJson);
            }

            identityJson = bb.requestedBy;
            if (identityJson != null)
            {
                build.RequestedBy = getIdentityFronJson(identityJson);
            }

            dynamic defJson = bb.definition;
            if(defJson != null)
            {
                build.Definition = getABuildDefinitionFromJson(defJson);
            }

            build.LogsUrl = bb.logs == null ? "" : bb.logs.url;
            
            return build;
        }