private async void btnOk_Click(object sender, EventArgs e)
        {
            if (!ValidateUrl())
            {
                return;
            }

            var client = new VSOClient(Output);

            if (!await TryGetClient(client))
            {
                return;
            }

            string selectedProject = lbProjects.SelectedItem?.ToString();

            if (string.IsNullOrEmpty(selectedProject))
            {
                MessageBox.Show(Resources.Please_select_a_valid_project);
                return;
            }

            Output.Name = string.IsNullOrWhiteSpace(txtOutputName.Text)
                ? Output.Name
                : txtOutputName.Text;

            Output.ProjectName         = selectedProject;
            Output.IterationName       = lbIterations.SelectedItem?.ToString();
            Output.BuildDefinitionName = lbBuildDefinitions.SelectedItem?.ToString();

            DialogResult = DialogResult.OK;
            Close();
        }
        private async Task GetBuildConfigurations()
        {
            string selectedProject = lbProjects.SelectedItem?.ToString();

            if (string.IsNullOrEmpty(selectedProject))
            {
                lbBuildDefinitions.DataSource = new List <string>();
                return;
            }

            lbBuildDefinitions.Enabled = false;

            try
            {
                VSOClient client = new VSOClient(Output);
                if (!await TryGetClient(client))
                {
                    return;
                }

                var    buildDefinitions = (await client.GetBuildConfigurations(selectedProject)).ToList();
                string selectedItem     = lbBuildDefinitions.SelectedItem?.ToString() ?? Output.BuildDefinitionName;
                SetDataSourceAndSelectedItem(lbBuildDefinitions, buildDefinitions, selectedItem);
            }
            finally
            {
                lbBuildDefinitions.Enabled = true;
            }
        }
        private async Task GetIterations()
        {
            string selectedProject = lbProjects.SelectedItem?.ToString();

            if (string.IsNullOrEmpty(selectedProject))
            {
                lbIterations.DataSource = new List <string>();
                return;
            }

            lbIterations.Enabled = false;

            try
            {
                var client = new VSOClient(Output);
                if (!await TryGetClient(client))
                {
                    return;
                }

                lbIterations.SelectedIndexChanged -= lbIterations_SelectedIndexChanged;

                var    iterations   = (await client.GetIterations(selectedProject)).ToList();
                string selectedItem = lbIterations.SelectedItem?.ToString() ?? Output.IterationName;
                SetDataSourceAndSelectedItem(lbIterations, iterations, selectedItem);

                await GetBuildConfigurations();

                lbIterations.SelectedIndexChanged += lbIterations_SelectedIndexChanged;
            }
            finally
            {
                lbIterations.Enabled = true;
            }
        }
        private static async Task <bool> TryGetClient(VSOClient client)
        {
            if (await client.Connect())
            {
                return(true);
            }

            MessageBox.Show(Resources.Something_went_wrong_while_attempting_to_connect_to_VSO);
            return(false);
        }
Ejemplo n.º 5
0
        private async void GetBuilds(VSOOutput output)
        {
            var client = new VSOClient(output);

            if (!await client.Connect())
            {
                MessageBox.Show(Resources.Something_went_wrong_while_attempting_to_connect_to_VSO);
                return;
            }

            var builds = await client.GetBuilds(output.ProjectName, output.BuildDefinitionName);

            var list = builds.OrderByDescending(b => b, new VersionNumberComparer()).ToList();

            list.Insert(0, string.Empty);
            lbBuilds.DataSource = list;
        }
        private async Task GetProjects()
        {
            var client = new VSOClient(Output);

            if (!ValidateUrl() || !await TryGetClient(client))
            {
                lbProjects.DataSource         = new List <string>();
                lbIterations.DataSource       = new List <string>();
                lbBuildDefinitions.DataSource = new List <string>();
                return;
            }

            btnGetProjects.Enabled     = false;
            lbProjects.Enabled         = false;
            lbIterations.Enabled       = false;
            lbBuildDefinitions.Enabled = false;
            string oldText = btnGetProjects.Text;

            btnGetProjects.Text = Resources.Loading;

            try
            {
                var projects = (await client.GetProjects()).ToList();

                lbProjects.SelectedIndexChanged -= lbProjects_SelectedIndexChanged;

                string selectedItem = lbProjects.SelectedItem?.ToString() ?? Output.ProjectName;
                SetDataSourceAndSelectedItem(lbProjects, projects, selectedItem);

                await GetIterations();

                lbProjects.SelectedIndexChanged += lbProjects_SelectedIndexChanged;
            }
            finally
            {
                btnGetProjects.Text        = oldText;
                btnGetProjects.Enabled     = true;
                lbProjects.Enabled         = true;
                lbIterations.Enabled       = true;
                lbBuildDefinitions.Enabled = true;
            }
        }
Ejemplo n.º 7
0
        protected override async Task <SendResult> Send(IWin32Window owner, VSOOutput vsoOutput, ImageData imageData)
        {
            var client = new VSOClient(vsoOutput);
            await client.Connect();

            bool cancelled = false;
            var  options   = GetSendOptions(owner, vsoOutput, ref cancelled);

            if (!cancelled)
            {
                try
                {
                    await client.CreateBug(options, imageData);
                }
                catch (Exception ex)
                {
                    MessageBox.Show(string.Format(Resources.Failed_to_upload_bug, ex.Message));
                    return(new SendResult(Result.Failed));
                }
            }

            return(new SendResult(cancelled ? Result.Canceled : Result.Success));
        }