private static BuildHttpClient CreateClient(string accessToken) { var collectionUri = new Uri("https://riskfirst.visualstudio.com/DefaultCollection", UriKind.Absolute); var cred = new VssBasicCredential(string.Empty, accessToken); var buildClient = new BuildHttpClient(collectionUri, cred); return buildClient; }
public override VssCredentials GetVssCredentials(IHostContext context) { Tracing trace = context.GetTrace("PersonalAccessToken"); trace.Info("GetVssCredentials()"); VssBasicCredential loginCred = new VssBasicCredential("test", "password"); VssCredentials creds = new VssClientCredentials(loginCred); trace.Verbose("cred created"); return creds; }
private static VssConnection GetVssConnection() { string pat = Environment.GetEnvironmentVariable(Program.PAT_ENV_VAR); if (string.IsNullOrEmpty(pat)) { throw new ArgumentException("On .NET Core, you must set an environment variable " + Program.PAT_ENV_VAR + " with a personal access token."); } var creds = new VssBasicCredential("pat", pat); VssConnection connection = new VssConnection(new Uri("https://fluxys.visualstudio.com"), creds); return(connection); }
public async Task <string> ExecuteAsync(IRule rule, WorkItemEventContext eventContext, CancellationToken cancellationToken) { logger.WriteVerbose($"Connecting to Azure DevOps using {configuration.DevOpsTokenType}..."); if (configuration.DevOpsTokenType == DevOpsTokenType.PAT) { var clientCredentials = new VssBasicCredential(configuration.DevOpsTokenType.ToString(), configuration.DevOpsToken); // see https://rules.sonarsource.com/csharp/RSPEC-4457 return(await ExecAsyncImpl(rule, eventContext, clientCredentials, cancellationToken)); } else { logger.WriteError($"Azure DevOps Token type {configuration.DevOpsTokenType} not supported!"); throw new ArgumentException($"Azure DevOps Token type {configuration.DevOpsTokenType} not supported."); } }
/// <summary> /// Asynchronously initializes the sink. /// </summary> /// <param name="name">The configuration name of the sink.</param> /// <param name="cancellationToken">A token to monitor for cancellation requests. The default value is <see cref="System.Threading.CancellationToken.None" />.</param> /// <returns> /// A <see cref="Task" /> that represents the asynchronous initialize operation. /// </returns> public async Task InitializeAsync(string name, CancellationToken cancellationToken = default(CancellationToken)) { await Task.Delay(0); var element = Configuration.TfsConfigurationSection.Current.Sinks[name]; // todo: support other auth methods, see the auth samples in https://www.visualstudio.com/en-us/integrate/get-started/client-libraries/samples // * OAuth // * ADD //var vssCredentials = new VssCredentials(); // Active directory auth - NTLM against a Team Foundation Server //var vssCredentials = new VssClientCredentials(); // Visual Studio sign-in prompt. Would need work to make this not prompt at every startup var vssCredentials = new VssBasicCredential("", element.AccessToken); var connection = new VssConnection(new Uri(element.ProjectCollection), vssCredentials); _witClient = connection.GetClient<WorkItemTrackingHttpClient>(); }
private static VsWebApi.VssConnection EstablishRestConnection(Settings settings) { try { Logger.Log(LogLevel.Info, "Connecting to Azure DevOps/TFS..."); var credentials = new VssBasicCredential("", settings.Pat); var uri = new Uri(settings.Account); return(new VsWebApi.VssConnection(uri, credentials)); } catch (Exception ex) { Logger.Log(ex, $"Cannot establish connection to Azure DevOps/TFS.", LogLevel.Critical); return(null); } }
public async Task <Release> CreateReleaseAsync(ReleaseDefinition releaseDefinition, Build build) { var clientCredentials = new VssBasicCredential(string.Empty, _connectInfo.PAT); var connection = new VssConnection(_connectInfo.ServerUrl, clientCredentials); var releaseServer = connection.GetClient <ReleaseHttpClient>(); // connect to the build server subpart var releaseStartMetaData = new ReleaseStartMetadata() { DefinitionId = releaseDefinition.Id, IsDraft = false, }; return(await releaseServer.CreateReleaseAsync(releaseStartMetaData, project : _connectInfo.ProjectId)); }
public async Task HandleBuild(BuildRequest build, string pat, Uri projectCollectionUri) { if (string.IsNullOrEmpty(build.SourceBranch)) { return; } var creds = new VssBasicCredential(string.Empty, pat); var connection = new VssConnection(new Uri(projectCollectionUri, "DefaultCollection"), creds); var gitClient = connection.GetClient <GitHttpClient>(); var prs = await gitClient.GetPullRequestsAsync(build.TeamProject, build.RepositoryId, new GitPullRequestSearchCriteria { SourceRefName = build.SourceBranch, Status = PullRequestStatus.Active }); foreach (var pr in prs) { // Delete Status from PRCreate var oldstatuses = await gitClient.GetPullRequestStatusesAsync(build.TeamProject, build.RepositoryId, pr.PullRequestId); var toDeleteStatuses = oldstatuses.Where(s => s.Context.Name == "PrAnnotator"); foreach (var oldstatus in toDeleteStatuses) { await gitClient.DeletePullRequestStatusAsync(build.TeamProject, build.RepositoryId, pr.PullRequestId, oldstatus.Id); } var prStatus = new GitPullRequestStatus { State = build.Status == "completed" ? GitStatusState.Succeeded : GitStatusState.Failed, Description = $"{build.DefinitionName}: Build {build.Status}", Context = new GitStatusContext { Genre = "Build", Name = build.DefinitionName }, TargetUrl = build.BuildUri }; //await gitClient.CreatePullRequestStatusAsync(prStatus, build.TeamProject, pr.Repository.Id, pr.PullRequestId).ConfigureAwait(false); var iterations = await gitClient.GetPullRequestIterationsAsync(pr.Repository.Id, pr.PullRequestId); var id = iterations.Last(i => i.SourceRefCommit.CommitId == build.SourceVersion).Id; if (id != null) { prStatus.Description = $"Update {id.Value}: {prStatus.Description}"; await gitClient.CreatePullRequestIterationStatusAsync(prStatus, pr.Repository.Id, pr.PullRequestId, id.Value); } } }
internal async Task <string> Execute(dynamic data) { string collectionUrl = data.resourceContainers.collection.baseUrl; string eventType = data.eventType; int workItemId = (eventType != "workitem.updated") ? data.resource.id : data.resource.workItemId; Guid teamProjectId = data.resourceContainers.project.id; string teamProjectName = (eventType != "workitem.updated") ? data.resource.fields["System.TeamProject"] : data.resource.revision.fields["System.TeamProject"]; logger.WriteVerbose($"Connecting to Azure DevOps using {configuration.DevOpsTokenType}..."); var clientCredentials = default(VssCredentials); if (configuration.DevOpsTokenType == DevOpsTokenType.PAT) { clientCredentials = new VssBasicCredential(configuration.DevOpsTokenType.ToString(), configuration.DevOpsToken); } else { logger.WriteError($"Azure DevOps Token type {configuration.DevOpsTokenType} not supported!"); throw new ArgumentOutOfRangeException(nameof(configuration.DevOpsTokenType)); } using (var devops = new VssConnection(new Uri(collectionUrl), clientCredentials)) { await devops.ConnectAsync(); logger.WriteInfo($"Connected to Azure DevOps"); using (var witClient = devops.GetClient <WorkItemTrackingHttpClient>()) { string ruleFilePath = Path.Combine(functionDirectory, $"{ruleName}.rule"); if (!File.Exists(ruleFilePath)) { logger.WriteError($"Rule code not found at {ruleFilePath}"); return("Rule file not found!"); } logger.WriteVerbose($"Rule code found at {ruleFilePath}"); string[] ruleCode = File.ReadAllLines(ruleFilePath); var engine = new Engine.RuleEngine(logger, ruleCode, configuration.SaveMode); return(await engine.ExecuteAsync(collectionUrl, teamProjectId, teamProjectName, configuration.DevOpsToken, workItemId, witClient)); } } }
public List <AzureTestCase> FindTestCasesByAssociatedAutomation(string fullTestName, string testStorage) { // Create a wiql object and build our query var wiql = new Wiql() { // NOTE: Even if other columns are specified, only the ID & URL will be available in the WorkItemReference Query = "Select [Id] " + "From WorkItems " + "Where [Work Item Type] = 'Test Case' " + "And [System.TeamProject] = '" + _project + "' " + $"And [Microsoft.VSTS.TCM.AutomatedTestName] = '{fullTestName}'" + $"And [Microsoft.VSTS.TCM.AutomatedTestStorage] = '{testStorage}'", }; var credentials = new VssBasicCredential(string.Empty, _personalAccessToken); try { // create instance of work item tracking http client using var httpClient = new WorkItemTrackingHttpClient(new Uri(_uri), credentials); // execute the query to get the list of work items in the results var result = httpClient.QueryByWiqlAsync(wiql).Result; var ids = result.WorkItems.Select(item => item.Id).ToArray(); // some error handling if (ids.Length == 0) { return(new List <AzureTestCase>()); } var resultTestCases = new List <AzureTestCase>(); // build a list of the fields we want to see var fields = new[] { "System.Id", "System.Title", "System.State" }; foreach (var item in httpClient.GetWorkItemsAsync(ids, expand: WorkItemExpand.Relations).Result) { resultTestCases.Add(ConvertWorkItemToAzureTestCase(item)); } return(resultTestCases); } catch { return(new List <AzureTestCase>()); } }
static public void GetChangesetWorkItemFromLabel(string tfsCollectionUrl, string personalAccessToken) { Console.WriteLine("Loading Labels Items and associated work items ... "); VssBasicCredential credentials = new VssBasicCredential(string.Empty, personalAccessToken); using (TfsTeamProjectCollection tpc = new TfsTeamProjectCollection(new Uri(tfsCollectionUrl), credentials)) { // Can retrieve SOAP service from TfsTeamProjectCollection instance //VersionControlServer vcServer = tpc.GetService<VersionControlServer>(); //ItemSet itemSet = vcServer.GetItems("$/", RecursionType.OneLevel); //foreach (Item item in itemSet.Items) //{ // Console.WriteLine(item.ServerItem); //} // Can retrieve REST client from same TfsTeamProjectCollection instance TfvcHttpClient tfvcClient = tpc.GetClient <TfvcHttpClient>(); //List<TfvcItem> tfvcItems = tfvcClient.GetItemsAsync("$/", VersionControlRecursionType.OneLevel).Result; //foreach (TfvcItem item in tfvcItems) //{ // Console.WriteLine(item.Path); //} TfvcLabelRequestData tfvcLabelRequestData = new TfvcLabelRequestData(); List <TfvcLabelRef> labelRefs = tfvcClient.GetLabelsAsync(tfvcLabelRequestData).Result; foreach (TfvcLabelRef item in labelRefs) { Console.WriteLine("Label Id: " + item.Id + "\tName: " + item.Name + "\t Modified:" + item.ModifiedDate); TfvcLabel tfvcLabel = tfvcClient.GetLabelAsync(item.Id.ToString(), tfvcLabelRequestData).Result; List <TfvcItem> labelItems = tfvcClient.GetLabelItemsAsync(item.Id.ToString()).Result; foreach (TfvcItem vcItem in labelItems) { Console.WriteLine("\tItem:" + vcItem.Path + "\t ChangesetVersion: " + vcItem.ChangesetVersion); List <AssociatedWorkItem> changesetWorkItems = tfvcClient.GetChangesetWorkItemsAsync(vcItem.ChangesetVersion).Result; foreach (AssociatedWorkItem assItem in changesetWorkItems) { Console.WriteLine("\t\t Associated WorkItem Id: " + assItem.Id + "\t Title: " + assItem.Title); } } } } Console.ReadLine(); }
public static void GetTeams(TfsConnection teamProjectCollection) { Uri _uri = teamProjectCollection.Uri; string user = ConfigurationManager.AppSettings["TfsClientUser"]; string password = ConfigurationManager.AppSettings["TfsClientPassword"]; VssBasicCredential _credentials = new VssBasicCredential(user, password); using (ProjectHttpClient projectHttpClient = new ProjectHttpClient(_uri, _credentials)) { IEnumerable <TeamProjectReference> projects = projectHttpClient.GetProjects().Result; IEnumerable <WebApiTeam> teams = GetTeams(projects.First().Name, _credentials, _uri); var configSvc = teamProjectCollection.GetService <TeamSettingsConfigurationService>(); var configs = configSvc.GetTeamConfigurations(teams.Select(x => x.Id)); } }
static void Main(string[] args) { VssCredentials creds = new VssBasicCredential(string.Empty, pat); VssConnection connection = new VssConnection(new Uri(collectionUri), creds); //Console.WriteLine("******Bug List******"); //var bugList = getBugs(connection); Console.WriteLine("******My Code Reviews List******"); var codeReviewsList = getMyCodeReviews(connection); Console.WriteLine("******Update Code Review******"); Console.WriteLine("Please enter CodeReviewRequest Id : "); int id = int.Parse(Console.ReadLine()); ChangeFieldValue(connection, id); }
/// <summary> /// Asynchronously initializes the sink. /// </summary> /// <param name="name">The configuration name of the sink.</param> /// <param name="cancellationToken">A token to monitor for cancellation requests. The default value is <see cref="System.Threading.CancellationToken.None" />.</param> /// <returns> /// A <see cref="Task" /> that represents the asynchronous initialize operation. /// </returns> public async Task InitializeAsync(string name, CancellationToken cancellationToken = default(CancellationToken)) { await Task.Delay(0); var element = Configuration.TfsConfigurationSection.Current.Sinks[name]; // todo: support other auth methods, see the auth samples in https://www.visualstudio.com/en-us/integrate/get-started/client-libraries/samples // * OAuth // * ADD //var vssCredentials = new VssCredentials(); // Active directory auth - NTLM against a Team Foundation Server //var vssCredentials = new VssClientCredentials(); // Visual Studio sign-in prompt. Would need work to make this not prompt at every startup var vssCredentials = new VssBasicCredential("", element.AccessToken); var connection = new VssConnection(new Uri(element.ProjectCollection), vssCredentials); _witClient = connection.GetClient <WorkItemTrackingHttpClient>(); }
// This method will upload attachment and return url for file and Id private static AttachmentReference UploadAttachment(Uri uri, VssBasicCredential credentials) { try { VssConnection _tpc = new VssConnection(uri, credentials); WorkItemTrackingHttpClient workItemTrackingHttpClient = _tpc.GetClient <WorkItemTrackingHttpClient>(); AttachmentReference attachment = workItemTrackingHttpClient.CreateAttachmentAsync(PathOfAttachment).Result; // Save the attachment ID for the "download" sample call later return(attachment); } catch (Exception ex) { Log.Logger.Error("Error occurred while Attaching Attachment in bug" + ex); return(null); } }
static public void GetWorkItem(string tfsCollectionUrl, string personalAccessToken, int id) { Console.WriteLine("Getting WorkItem ID " + id); VssBasicCredential credentials = new VssBasicCredential(string.Empty, personalAccessToken); VssConnection connection = new VssConnection(new Uri(tfsCollectionUrl), credentials); WorkItemTrackingHttpClient workItemTrackingHttpClient = connection.GetClient <WorkItemTrackingHttpClient>(); WorkItem workitem = workItemTrackingHttpClient.GetWorkItemAsync(id).Result; Console.WriteLine(workitem.Fields["System.Title"]); Console.ReadLine(); }
/// <nodoc /> public Api(ILogger logger) { m_logger = logger ?? throw new ArgumentNullException(nameof(logger)); BuildId = Environment.GetEnvironmentVariable(Constants.BuildIdVarName); TeamProject = Environment.GetEnvironmentVariable(Constants.TeamProjectVarName); ServerUri = Environment.GetEnvironmentVariable(Constants.ServerUriVarName); AccessToken = Environment.GetEnvironmentVariable(Constants.AccessTokenVarName); AgentName = Environment.GetEnvironmentVariable(Constants.AgentNameVarName); SourcesDirectory = Environment.GetEnvironmentVariable(Constants.SourcesDirectoryVarName); TeamProjectId = Environment.GetEnvironmentVariable(Constants.TeamProjectIdVarName); TimelineId = Environment.GetEnvironmentVariable(Constants.TimelineIdVarName); PlanId = Environment.GetEnvironmentVariable(Constants.PlanIdVarName); RepositoryUrl = Environment.GetEnvironmentVariable(Constants.RepositoryUrlVariableName); string jobPositionInPhase = Environment.GetEnvironmentVariable(Constants.JobsPositionInPhaseVarName); if (string.IsNullOrWhiteSpace(jobPositionInPhase)) { m_logger.Info("The job position in the build phase could not be determined. Therefore it must be a single machine build"); JobPositionInPhase = 1; TotalJobsInPhase = 1; } else { if (!int.TryParse(jobPositionInPhase, out int position)) { throw new ApplicationException($"The env var {Constants.JobsPositionInPhaseVarName} contains a value that cannot be parsed to int"); } JobPositionInPhase = position; string totalJobsInPhase = Environment.GetEnvironmentVariable(Constants.TotalJobsInPhaseVarName); if (!int.TryParse(totalJobsInPhase, out int totalJobs)) { throw new ApplicationException($"The env var {Constants.TotalJobsInPhaseVarName} contains a value that cannot be parsed to int"); } TotalJobsInPhase = totalJobs; } var server = new Uri(ServerUri); var cred = new VssBasicCredential(string.Empty, AccessToken); m_taskClient = new TaskHttpClient(server, cred); m_buildClient = new BuildHttpClient(server, cred); }
//private JObject ConvertToHierarchy(JArray items) //{ // var dict = new Dictionary<int, JToken>(); // foreach (var item in items) // { // var id = Int32.Parse(item["ID"].ToString()); // dict.Add(id, item); // } // foreach (var item in dict.Values) // { // if (item["System.Parent"] != null) // { // int parentNumber = Int32.Parse(item["System.Parent"].ToString()); // var parentItem = (JObject)dict[parentNumber]; // if (parentItem.ContainsKey("items") == false) { parentItem.Add("items", new JArray()); } // var subItems = (JArray)parentItem["items"]; // subItems.Add(item); // } // } // return (JObject)dict.FirstOrDefault().Value; //} private async Task <List <WorkItem> > GetItems(string uri, string pat, string project) { var credentials = new VssBasicCredential(string.Empty, pat); // create a wiql object and build our query var wiql = new Wiql() { // NOTE: Even if other columns are specified, only the ID & URL will be available in the WorkItemReference Query = "Select [Id] " + "From WorkItems " + //"Where [Work Item Type] = 'Epic' " + "Where [System.TeamProject] = '" + project + "'", }; // create instance of work item tracking http client using (var httpClient = new WorkItemTrackingHttpClient(new Uri(uri), credentials)) { // execute the query to get the list of work items in the results var result = await httpClient.QueryByWiqlAsync(wiql).ConfigureAwait(false); var ids = result.WorkItems.Select(item => item.Id).ToArray(); // some error handling if (ids.Length == 0) { return(null); } // build a list of the fields we want to see //var fields = new[] { "System.Id", "System.Title", "System.State, System.Parent" }; //System.AreaPath //System.TeamProject //System.IterationPath //System.WorkItemType //System.State //System.Reason //System.CreatedDate //System.CreatedBy //System.ChangedDate //System.ChangedBy //System.CommentCount // get work items for the ids found in query //return await httpClient.GetWorkItemsAsync(ids, fields, result.AsOf).ConfigureAwait(false); return(await httpClient.GetWorkItemsAsync(ids, expand : WorkItemExpand.Relations).ConfigureAwait(false)); } }
public ActionResult Index() { var accountUri = new Uri(ConfigurationManager.AppSettings["Vsts.Uri"]); var personalAccessToken = ConfigurationManager.AppSettings["Vsts.PersonalAccessToken"]; var vssBasicCredential = new VssBasicCredential(String.Empty, personalAccessToken); // Create a connection to the account var vssConnection = new VssConnection(accountUri, vssBasicCredential); // Hangs here on subsequent request... doesn't happen on development server but does happen when hosted via IIS using (var workHttpClient = vssConnection.GetClient <WorkHttpClient>()) { } return(View()); }
public static WorkItem CreateBugInVSO(IWebDriver driver, Fields fields) { try { PathOfAttachment = ScreenShotCapture.CaptureScreenShotOfCurrentBrowser(driver, fields.PathOfFile); ListParams.AddRange(GetAllField(fields)); Uri uri = new Uri(_uri); string personalAccessToken = _personalAccessToken; string project = _project; VssBasicCredential credentials = new VssBasicCredential("", _personalAccessToken); AttachmentReference attachment = UploadAttachment(uri, credentials); ListParams.Add(new Params() { Path = "/relations/-", Value = new { rel = "AttachedFile", url = attachment.Url, attributes = new { comment = fields.Comments } } }); JsonPatchDocument patchDocument = new JsonPatchDocument(); //add fields and their values to your patch document foreach (var item in ListParams) { patchDocument.Add( new JsonPatchOperation() { Operation = Operation.Add, Path = item.Path, Value = item.Value, } ); } VssConnection connection = new VssConnection(uri, credentials); WorkItemTrackingHttpClient workItemTrackingHttpClient = connection.GetClient <WorkItemTrackingHttpClient>(); WorkItem result = workItemTrackingHttpClient.CreateWorkItemAsync(patchDocument, project, "Bug").Result; return(result); } catch (AggregateException ex) { Log.Logger.Error("Error occurred while Creating bug in VSO" + ex); return(null); } }
/// <summary> /// Asynchronously initializes the sink. /// </summary> /// <param name="name">The configuration name of the sink.</param> /// <param name="cancellationToken">A token to monitor for cancellation requests. The default value is <see cref="System.Threading.CancellationToken.None" />.</param> /// <returns> /// A <see cref="Task" /> that represents the asynchronous initialize operation. /// </returns> public async Task InitializeAsync( string name, CancellationToken cancellationToken = default(CancellationToken)) { await Task.Delay(0); var element = Configuration.TfsConfigurationSection.Current.Sinks[name]; searchString = element.SearchString; projectName = element.Project; searchPeriod = TimeSpan.FromDays(element.SearchPeriodDays); // todo: support other auth methods, see the auth samples in https://www.visualstudio.com/en-us/integrate/get-started/client-libraries/samples // * OAuth // * ADD //var vssCredentials = new VssCredentials(); // Active directory auth - NTLM against a Team Foundation Server //var vssCredentials = new VssClientCredentials(); // Visual Studio sign-in prompt. Would need work to make this not prompt at every startup VssCredentials vssCredentials; switch (element.LoginMethod) { case 1: /* this is basic auth if on tfs2015 */ // Ultimately you want a VssCredentials instance so... NetworkCredential netCred = new NetworkCredential(element.Username, element.Password); WindowsCredential winCred = new WindowsCredential(netCred); vssCredentials = new VssClientCredentials(winCred); // Bonus - if you want to remain in control when // credentials are wrong, set 'CredentialPromptType.DoNotPrompt'. // This will thrown exception 'TFS30063' (without hanging!). // Then you can handle accordingly. vssCredentials.PromptType = CredentialPromptType.DoNotPrompt; /*********************************************************************/ break; default: vssCredentials = new VssBasicCredential("", element.AccessToken); break; } var connection = new VssConnection(new Uri(element.ProjectCollection), vssCredentials); _witClient = connection.GetClient <WorkItemTrackingHttpClient>(); }
public static WorkItemClientConnection CreateClient(ConfigConnection connection) { Uri url = new Uri(connection.Account.TrimEnd('/')); VssCredentials credentials; if (connection.UseIntegratedAuth) { credentials = new VssCredentials(true); } else { credentials = new VssBasicCredential("", connection.AccessToken); } return(new WorkItemClientConnection(url, credentials)); }
private Boolean ConnectToTfs(String accountUri, String accessToken) { //login for VSTS VssCredentials creds = new VssBasicCredential( String.Empty, accessToken); creds.Storage = new VssClientCredentialStorage(); // Connect to VSTS _tfsCollection = new TfsTeamProjectCollection(new Uri(accountUri), creds); _tfsCollection.Authenticate(); _vssConnection = new VssConnection(new Uri(accountUri), creds); _vssConnection.ConnectAsync().Wait(); return(true); }
public static async Task <string> CreateWIinDevops(string WItitle, string projectName, string WIType) { var PAT = "7awtul6zkle7untncpxvqq25yvwgz6fb2qr6stxozzm6qr7swxca"; var credentials = new VssBasicCredential(string.Empty, PAT); var operations = new JsonPatchDocument(); AddPatch(operations, "/fields/System.Title", WItitle); AddPatch(operations, "/fields/System.Description", WItitle); var witClient = new WorkItemTrackingHttpClient(new Uri("https://dev.azure.com/adfd365"), credentials); var result = await witClient.CreateWorkItemAsync(operations, projectName, WIType); return(result.Id.ToString()); }
private async Task <VssConnection> GetVssConnectionAsync(string organization) { var vssConnectionCacheKey = $"{organization}_vssConnectionCacheKey"; var connection = await cache.GetOrCreateAsync(vssConnectionCacheKey, async (entry) => { var azureDevOpsPersonalAccessToken = await GetAzureDevOpsPersonalAccessTokenAsync(); var credentials = new VssBasicCredential("nobody", azureDevOpsPersonalAccessToken); var baseUri = new Uri($"https://dev.azure.com/{organization}"); var connection = new VssConnection(baseUri, credentials); entry.AbsoluteExpirationRelativeToNow = TimeSpan.FromSeconds(60); return(connection); }); return(connection); }
internal async Task <string> ExecuteAsync(WorkItemEventContext eventContext, CancellationToken cancellationToken) { logger.WriteVerbose($"Connecting to Azure DevOps using {configuration.DevOpsTokenType}..."); var clientCredentials = default(VssCredentials); if (configuration.DevOpsTokenType == DevOpsTokenType.PAT) { clientCredentials = new VssBasicCredential(configuration.DevOpsTokenType.ToString(), configuration.DevOpsToken); } else { logger.WriteError($"Azure DevOps Token type {configuration.DevOpsTokenType} not supported!"); throw new ArgumentOutOfRangeException(nameof(configuration.DevOpsTokenType)); } cancellationToken.ThrowIfCancellationRequested(); // TODO improve from https://github.com/Microsoft/vsts-work-item-migrator using (var devops = new VssConnection(eventContext.CollectionUri, clientCredentials)) { await devops.ConnectAsync(cancellationToken); logger.WriteInfo($"Connected to Azure DevOps"); using (var clientsContext = new AzureDevOpsClientsContext(devops)) { string ruleFilePath = Path.Combine(functionDirectory, $"{ruleName}.rule"); if (!File.Exists(ruleFilePath)) { logger.WriteError($"Rule code not found at {ruleFilePath}"); return("Rule file not found!"); } logger.WriteVerbose($"Rule code found at {ruleFilePath}"); string[] ruleCode; using (var fileStream = File.OpenRead(ruleFilePath)) { var reader = new StreamReader(fileStream); ruleCode = await ReadAllLinesAsync(reader); } var engine = new Engine.RuleEngine(logger, ruleCode, configuration.SaveMode, configuration.DryRun); return(await engine.ExecuteAsync(eventContext.ProjectId, eventContext.WorkItemPayload, clientsContext, cancellationToken)); } } }
private TfsTeamProjectCollection GetTfsCollection() { if (_Collection is null) { var startTime = DateTime.UtcNow; var timer = System.Diagnostics.Stopwatch.StartNew(); VssCredentials vssCredentials; try { Log.LogDebug("TfsWorkItemEndPoint::GetTfsCollection:AuthenticationMode({0})", _Options.AuthenticationMode.ToString()); switch (_Options.AuthenticationMode) { case AuthenticationMode.AccessToken: Log.LogDebug("TfsWorkItemEndPoint::GetTfsCollection: Connecting Using PAT Authentication ", _Options.Organisation); vssCredentials = new VssBasicCredential(string.Empty, _Options.AccessToken); _Collection = new TfsTeamProjectCollection(new Uri(_Options.Organisation), vssCredentials); break; case AuthenticationMode.Prompt: Log.LogDebug("TfsWorkItemEndPoint::EnsureDataSource: Connecting Using Interactive Authentication ", _Options.Organisation); _Collection = new TfsTeamProjectCollection(new Uri(_Options.Organisation)); break; default: Log.LogDebug("TfsWorkItemEndPoint::EnsureDataSource: Connecting Using Interactive Authentication ", _Options.Organisation); _Collection = new TfsTeamProjectCollection(new Uri(_Options.Organisation)); break; } Log.LogDebug("TfsWorkItemEndPoint::GetTfsCollection: Connected "); Log.LogDebug("TfsWorkItemEndPoint::GetTfsCollection: validating security for {@AuthorizedIdentity} ", _Collection.AuthorizedIdentity); _Collection.EnsureAuthenticated(); timer.Stop(); Log.LogInformation("TfsWorkItemEndPoint::GetTfsCollection: Access granted to {CollectionUrl} for {Name} ({Account})", _Options.Organisation, _Collection.AuthorizedIdentity.DisplayName, _Collection.AuthorizedIdentity.UniqueName); Telemetry.TrackDependency(new DependencyTelemetry("TfsObjectModel", _Options.Organisation, "GetTfsCollection", null, startTime, timer.Elapsed, "200", true)); } catch (Exception ex) { timer.Stop(); Telemetry.TrackDependency(new DependencyTelemetry("TfsObjectModel", _Options.Organisation, "GetTfsCollection", null, startTime, timer.Elapsed, "500", false)); Log.LogError(ex, "Unable to connect to {Organisation}", _Options.Organisation); throw; } } return(_Collection); }
private VssConnection GetConnection() { VssConnection result = null; if (_accessToken != null) { var creds = new VssBasicCredential(string.Empty, _accessToken); result = new VssConnection(_uri, creds); if (!_connected) { _connected = true; Connected?.Invoke(this, _uri.AbsoluteUri); } } return(result); }
private WorkItemQueryResult WorkItemResponse(Uri azureDevOpsUri, VssBasicCredential personalAccessToken, string azureDevOpsWiqlString) { WorkItemQueryResult workItemQueryResult; Wiql azureDevOpsWiqlQuery = new Wiql() { Query = azureDevOpsWiqlString }; using (WorkItemTrackingHttpClient workItemTrackingHttpClient = new WorkItemTrackingHttpClient(azureDevOpsUri, personalAccessToken)) { //execute the query to get the list of work items in the results workItemQueryResult = workItemTrackingHttpClient.QueryByWiqlAsync(azureDevOpsWiqlQuery).Result; } return(workItemQueryResult); }
/// <summary> /// Execute une requete WIQL pour retourner une liste de workItem en utilisant la librairie .NET client /// </summary> /// <returns>List of Microsoft.TeamFoundation.WorkItemTracking.WebApi.Models.WorkItem</returns> public async Task <List <WorkItem> > GetWorkItemByQuery(string query) { Uri uri = new Uri(_uri); VssBasicCredential credentials = new VssBasicCredential("", _personalAccessToken); // Création de la requete Wiql wiql = new Wiql() { Query = query }; // instance http client using (WorkItemTrackingHttpClient workItemTrackingHttpClient = new WorkItemTrackingHttpClient(uri, credentials)) { // execute la requete WorkItemQueryResult workItemQueryResult = await workItemTrackingHttpClient.QueryByWiqlAsync(wiql); //Au cas ou il y aurait un problème ou qu'il n'y ai pas de workitem if (workItemQueryResult.WorkItems.Count() != 0) { //listing des ID des WorkItem à charger List <int> list = new List <int>(); foreach (var item in workItemQueryResult.WorkItems) { list.Add(item.Id); } int[] arr = list.ToArray(); //List des champs a récuperer dans le workItem //string[] fields = new string[3]; //fields[0] = "System.Id"; //fields[1] = "System.Title"; //fields[2] = "System.State"; //var workItems = await workItemTrackingHttpClient.GetWorkItemsAsync(arr, fields, workItemQueryResult.AsOf); //Récupération des workItems selon leurs ID avec tous leur champs var workItems = await workItemTrackingHttpClient.GetWorkItemsAsync(arr, asOf : workItemQueryResult.AsOf); return(workItems); } return(null); } }
public static List <WorkItem> GetWorkItems(string workItemId) { var credentials = new VssBasicCredential(string.Empty, _personalAccessToken); try { // create instance of work item tracking http client using var httpClient = new WorkItemTrackingHttpClient(new Uri(_uri), credentials); // execute the query to get the list of work items in the results var result = httpClient.GetWorkItemsAsync(new int[] { workItemId.ToInt() }).Result; return(httpClient.GetWorkItemsAsync(new int[] { workItemId.ToInt() }).Result); } catch { return(new List <WorkItem>()); } }
public static async Task LinkWIinDevOpstoEachother(int mainwiid, int childwiid) { var PAT = "7awtul6zkle7untncpxvqq25yvwgz6fb2qr6stxozzm6qr7swxca"; var projectName = "The Hershey Corporation various affiliates H Choc World"; // var workItemType = "Product Backlog Item"; var credentials = new VssBasicCredential(string.Empty, PAT); var operations = new JsonPatchDocument(); AddPatchTest(operations, $"https://dev.azure.com/adfd365/_apis/wit/workItems/{childwiid}"); // AddPatch(operations, "/relations/-", values); // AddPatch(operations, "/fields/System.Description", "Implementation Model"); var witClient = new WorkItemTrackingHttpClient(new Uri("https://dev.azure.com/adfd365"), credentials); var resukt = await witClient.UpdateWorkItemAsync(operations, projectName, mainwiid); }
private static VssConnection CreateConnection(AbstractCommandLineOptions options) { VssCredentials creds; if (!string.IsNullOrEmpty(options.PersonalAccessToken)) { creds = new VssBasicCredential(string.Empty, options.PersonalAccessToken); } else if (!string.IsNullOrEmpty(options.Username)) { creds = new VssCredentials(new WindowsCredential(new NetworkCredential(options.Username, options.Password))); } else { creds = new VssCredentials(new WindowsCredential(true)); } return(new VssConnection(new Uri(options.CollectionUrl), creds)); }
public override VssCredentials GetVssCredentials(IHostContext context) { ArgUtil.NotNull(context, nameof(context)); Tracing trace = context.GetTrace(nameof(PersonalAccessToken)); trace.Info(nameof(GetVssCredentials)); ArgUtil.NotNull(CredentialData, nameof(CredentialData)); string token; if (!CredentialData.Data.TryGetValue(Constants.Agent.CommandLine.Args.Token, out token)) { token = null; } ArgUtil.NotNullOrEmpty(token, nameof(token)); trace.Info("token retrieved: {0} chars", token.Length); // PAT uses a basic credential VssBasicCredential basicCred = new VssBasicCredential("VstsAgent", token); VssCredentials creds = new VssClientCredentials(basicCred); trace.Verbose("cred created"); return creds; }