public WorkItemDelete DeleteWorkItem()
{
int id = Convert.ToInt32(Context.GetValue <WorkItem>("$newWorkItem2").Id);
// Get a client
VssConnection connection = Context.Connection;
WorkItemTrackingHttpClient workItemTrackingClient = connection.GetClient <WorkItemTrackingHttpClient>();
// Delete the work item (but don't destroy it completely)
WorkItemDelete results = workItemTrackingClient.DeleteWorkItemAsync(id, destroy: false).Result;
return(results);
}
public void GetReadOnlyWorkItemFields()
{
VssConnection connection = Context.Connection;
WorkItemTrackingHttpClient workItemTrackingClient = connection.GetClient <WorkItemTrackingHttpClient>();
List <WorkItemField> result = workItemTrackingClient.GetFieldsAsync().Result;
Console.WriteLine("Read only fields:");
foreach (var workitemField in result.Where(field => field.ReadOnly))
{
Console.WriteLine(" * {0} ({1})", workitemField.Name, workitemField.ReferenceName);
}
}
/// <summary>
/// Extends the project for a specific work item type LINQ Query.
/// </summary>
/// <typeparam name="T">Type of work item</typeparam>
/// <typeparam name="THelper">Related creator provider</typeparam>
/// <param name="workItemTrackingHttpClient"></param>
/// <param name="project">The project.</param>
/// <returns></returns>
internal static IQueryable <T> SetOf <T, THelper>(this WorkItemTrackingHttpClient workItemTrackingHttpClient,
ProjectInfo project)
where T : GenericWorkItem
where THelper : ICustomWorkItemHelper <T>, new()
{
if (project == null)
{
throw new ArgumentNullException(nameof(project));
}
return(new Query <T>(new WorkItemLinqQueryProvider <T>(workItemTrackingHttpClient, project.Name,
new THelper())));
}
public async Task <List <WorkItem> > GetTestCaseByID(int id)
{
WorkItemTrackingHttpClient witClient = connection.GetClient <WorkItemTrackingHttpClient>();
string Wiql = "SELECT [System.Title], [System.WorkItemType] FROM WorkItems WHERE [System.ID] = " + id;
// "'PlayGround' AND" + "[System.WorkItemType] = 'Test Suite'";
WorkItemQueryResult result = await witClient.QueryByWiqlAsync(new Wiql { Query = Wiql });
IEnumerable <int> woritem_ids = result.WorkItems.Select(p => p.Id);
List <WorkItem> workitems = await
witClient.GetWorkItemsAsync(woritem_ids, null, null, null, null, default(System.Threading.CancellationToken));
return(workitems);
}
public WorkItem UpdateWorkItemLinkToCommit()
{
int id = Convert.ToInt32(Context.GetValue <WorkItem>("$newWorkItem2").Id);
System.Guid repositoryId = new Guid("2f3d611a-f012-4b39-b157-8db63f380226");
string commitId = "be67f8871a4d2c75f13a51c1d3c30ac0d74d4ef4";
VssConnection connection = Context.Connection;
GitHttpClient gitClient = connection.GetClient <GitHttpClient>();
//you will need to edit this line and enter a legit repo id and commit id
//these are samples and will not work
var commit = gitClient.GetCommitAsync(commitId, repositoryId).Result;
var commitUri = commit.Url;
JsonPatchDocument patchDocument = new JsonPatchDocument();
patchDocument.Add(
new JsonPatchOperation()
{
Operation = Operation.Test,
Path = "/rev",
Value = "3"
}
);
patchDocument.Add(
new JsonPatchOperation()
{
Operation = Operation.Add,
Path = "/relations/-",
Value = new
{
rel = "ArtifactLink",
url = commitUri,
attributes = new
{
comment = "Fixed in Commit",
name = "commit"
}
}
}
);
WorkItemTrackingHttpClient workItemTrackingClient = connection.GetClient <WorkItemTrackingHttpClient>();
WorkItem result = workItemTrackingClient.UpdateWorkItemAsync(patchDocument, id).Result;
return(result);
}
RunGetTasksQuery(Project project)
{
VssBasicCredential credentials = new VssBasicCredential("", project.PersonalAccessToken);
//create a wiql object and build our query
Wiql wiql = new Wiql()
{
Query = "Select " +
" [System.Id], [System.WorkItemType], [System.Title], [System.CreatedDate] " +
"From WorkItems " +
"Where " +
"[System.TeamProject] = '" + project.Name.ToString() + "' " +
"And [System.State] <> 'Closed' " +
"Order By [State] Asc, [Changed Date] Desc"
};
//create instance of work item tracking http client
using (WorkItemTrackingHttpClient workItemTrackingHttpClient = new WorkItemTrackingHttpClient(new Uri(project.Url.ToString()), credentials))
{
//execute the query to get the list of work items in the results
WorkItemQueryResult workItemQueryResult = await workItemTrackingHttpClient.QueryByWiqlAsync(wiql);
//some error handling
if (workItemQueryResult.WorkItems.Count() != 0)
{
//need to get the list of our work item ids and put them into an array
List <int> list = new List <int>();
foreach (var item in workItemQueryResult.WorkItems)
{
list.Add(item.Id);
}
int[] arr = list.ToArray();
//build a list of the fields we want to see
string[] fields = new string[4];
fields[0] = "System.Id";
fields[1] = "System.WorkItemType";
fields[2] = "System.Title";
fields[3] = "System.CreatedDate";
//get work items for the ids found in query
var workItems = await workItemTrackingHttpClient.GetWorkItemsAsync(arr, fields, workItemQueryResult.AsOf);
Console.WriteLine("Query Results: {0} items found", workItems.Count);
return(workItems);
}
return(null);
}
}
private static void CloneWorkItem(WorkItemTrackingHttpClient witClient, int wiIdToClone, string NewTeamProject = "", bool CopyLink = false)
{
WorkItem wiToClone = (CopyLink) ? witClient.GetWorkItemAsync(wiIdToClone, expand: WorkItemExpand.Relations).Result
: witClient.GetWorkItemAsync(wiIdToClone).Result;
string teamProjectName = (NewTeamProject != "") ? NewTeamProject : wiToClone.Fields["System.TeamProject"].ToString();
string wiType = wiToClone.Fields["System.WorkItemType"].ToString();
JsonPatchDocument patchDocument = new JsonPatchDocument();
foreach (var key in wiToClone.Fields.Keys) //copy fields
{
if (!systemFields.Contains(key) && !customFields.Contains(key))
{
if (NewTeamProject == "" ||
(NewTeamProject != "" && key != "System.AreaPath" && key != "System.IterationPath")) //do not copy area and iteration into another project
{
patchDocument.Add(new JsonPatchOperation()
{
Operation = Operation.Add,
Path = "/fields/" + key,
Value = wiToClone.Fields[key]
});
}
}
}
if (CopyLink) //copy links
{
foreach (var link in wiToClone.Relations)
{
if (link.Rel != ChildRefStr)
{
patchDocument.Add(new JsonPatchOperation()
{
Operation = Operation.Add,
Path = "/relations/-",
Value = new
{
rel = link.Rel,
url = link.Url
}
});
}
}
}
WorkItem clonedWi = witClient.CreateWorkItemAsync(patchDocument, teamProjectName, wiType).Result;
Console.WriteLine("New work item: " + clonedWi.Id);
}
private AttachmentReference UploadAttachment(AzureDevOpsWorkItemAttachment attachment)
{
AttachmentReference uploadedFile;
var name = Path.GetFileName(attachment.AttachmentPath);
using (var attStream = new FileStream(attachment.AttachmentPath, FileMode.Open, FileAccess.Read))
{
uploadedFile = WorkItemTrackingHttpClient.CreateAttachmentAsync(attStream, ProjectName, fileName: name)
.Result;
}
return(uploadedFile);
}
public IEnumerable <WorkItem> GetWorkItemsFromQuery()
{
string project = ClientSampleHelpers.FindAnyProject(this.Context).Name;
string queryName = "Shared Queries/Current Sprint";
VssConnection connection = Context.Connection;
WorkItemTrackingHttpClient workItemTrackingClient = connection.GetClient <WorkItemTrackingHttpClient>();
QueryHierarchyItem queryItem;
try
{
// get the query object based on the query name and project
queryItem = workItemTrackingClient.GetQueryAsync(project, queryName).Result;
}
catch (Exception ex)
{
// query was likely not found
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine(ex.InnerException.Message);
Console.ForegroundColor = ConsoleColor.White;
return(null);
}
// now we have the query, so let'ss execute it and get the results
WorkItemQueryResult queryResult = workItemTrackingClient.QueryByIdAsync(queryItem.Id).Result;
if (queryResult.WorkItems.Count() == 0)
{
return(new List <WorkItem>());
}
else
{
// need to get the list of our work item id's and put them into an array
int[] workItemIds = queryResult.WorkItems.Select <WorkItemReference, int>(wif => { return(wif.Id); }).ToArray();
// build a list of the fields we want to see
string[] fields = new []
{
"System.Id",
"System.Title",
"System.State"
};
IEnumerable <WorkItem> workItems = workItemTrackingClient.GetWorkItemsAsync(workItemIds, fields, queryResult.AsOf).Result;
return(workItems);
}
}
public static async Task <IList <WitBatchResponse> > ExecuteBatchRequest(WorkItemTrackingHttpClient targetWorkItemTrackingClient, IList <WitBatchRequest> witBatchRequests)
{
//we cannot add retrylogic here as we will need to reconstruct the entire content
try
{
return(await targetWorkItemTrackingClient.ExecuteBatchRequest(witBatchRequests));
}
catch (Exception e)
{
Logger.LogError(LogDestination.File, $"Exception in MakeRequest {e.Message}");
throw e;
//we continue migration even if something failed
}
}
public WorkItemDelete RestoreItem(int id)
{
VssConnection connection = new VssConnection(_uri, _credentials);
WorkItemTrackingHttpClient workItemTrackingHttpClient = connection.GetClient <WorkItemTrackingHttpClient>();
WorkItemDeleteUpdate payload = new WorkItemDeleteUpdate()
{
IsDeleted = false
};
WorkItemDelete result = workItemTrackingHttpClient.RestoreWorkItemAsync(payload, id).Result;
return(result);
}
public TFSClient(string url, string username, string passwordOrPAT)
{
_uri = url;
_username = username;
_passwordOrPAT = passwordOrPAT;
VssBasicCredential credentials = new VssBasicCredential(_username, _passwordOrPAT);
Uri uri = new Uri(_uri);
_connection = new VssConnection(uri, credentials);
workItemClient = _connection.GetClient <WorkItemTrackingHttpClient>();
teamClient = _connection.GetClient <TeamHttpClient>();
projectClient = _connection.GetClient <ProjectHttpClient>();
serviceHooksClient = _connection.GetClient <ServiceHooksPublisherHttpClient>();
}
public void PermenentlyDeleteMultipleWorkItems()
{
int[] ids = { 72, 73, 81 }; //TODO
VssConnection connection = Context.Connection;
WorkItemTrackingHttpClient workItemTrackingClient = connection.GetClient <WorkItemTrackingHttpClient>();
List <WorkItemDeleteReference> result = workItemTrackingClient.GetDeletedWorkItemsAsync(ids).Result;
foreach (var item in result)
{
workItemTrackingClient.DestroyWorkItemAsync(Convert.ToInt32(item.Id));
}
}
public void GetReadOnlyWorkItemFields()
{
Uri uri = new Uri(_uri);
VssBasicCredential credentials = new VssBasicCredential("", _personalAccessToken);
WorkItemTrackingHttpClient workItemTrackingClient = new WorkItemTrackingHttpClient(uri, credentials);
List <WorkItemField> result = workItemTrackingClient.GetFieldsAsync().Result;
Console.WriteLine("Read only fields:");
foreach (var workitemField in result)
{
Console.WriteLine(" * {0} ({1})", workitemField.Name, workitemField.ReferenceName);
}
}
private async Task <List <WorkItem> > GetWorkItemsAsync(WorkItemTrackingHttpClient client, IEnumerable <int> ids)
{
var result = new List <WorkItem>();
var batchedIds = Batch(ids, 200);
foreach (var batch in batchedIds)
{
var items = await client.GetWorkItemsAsync(batch, expand : WorkItemExpand.All);
result.AddRange(items);
}
return(result);
}
public static void ChangeState(WorkItemTrackingHttpClient client, int id, string state)
{
var patchDocument = new JsonPatchDocument
{
new JsonPatchOperation()
{
Operation = Operation.Add,
Path = "/fields/System.State",
Value = state
}
};
client.UpdateWorkItemAsync(patchDocument, id).Wait();
}
/// <summary>
/// Execute a WIQL query to return a list of bugs using the .NET client library
/// </summary>
/// <returns>List of Microsoft.TeamFoundation.WorkItemTracking.WebApi.Models.WorkItem</returns>
public async Task <List <WorkItem> > ExecuteWorkItemsQuery()
{
Uri uri = new Uri(GlobalConfiguration.Instance._uri);
string personalAccessToken = GlobalConfiguration.Instance._tokenPA;
string project = GlobalConfiguration.Instance._project;
VssBasicCredential credentials = new VssBasicCredential("", GlobalConfiguration.Instance._tokenPA);
//create a wiql object and build our query
Wiql wiql = new Wiql()
{
Query = "Select [Id], [State], [Title],[Changed Date]" +
"From WorkItems " +
"Order By [State] Asc, [Changed Date] Desc"
};
//create instance of work item tracking http client
using (WorkItemTrackingHttpClient workItemTrackingHttpClient = new WorkItemTrackingHttpClient(uri, credentials))
{
//execute the query to get the list of work items in the results
WorkItemQueryResult workItemQueryResult = await workItemTrackingHttpClient.QueryByWiqlAsync(wiql);
//some error handling
if (workItemQueryResult.WorkItems.Count() != 0)
{
//need to get the list of our work item ids and put them into an array
List <int> list = new List <int>();
foreach (var item in workItemQueryResult.WorkItems)
{
list.Add(item.Id);
}
int[] arrWIQueryResult = list.ToArray();
//build a list of the fields we want to see
string[] wiProperties = new string[4];
wiProperties[0] = "System.Id";
wiProperties[1] = "System.State";
wiProperties[2] = "System.Title";
wiProperties[3] = "System.ChangedDate";
//get work items for the ids found in query
var workItems = await workItemTrackingHttpClient.GetWorkItemsAsync(arrWIQueryResult, wiProperties, workItemQueryResult.AsOf);
return(workItems);
}
return(null);
}
}
public WorkItemMigrationContext(MigrationEngine me, WorkItemMigrationConfig config)
: base(me, config)
{
_config = config;
PopulateIgnoreList();
VssClientCredentials adoCreds = new VssClientCredentials();
_witClient = new WorkItemTrackingHttpClient(me.Target.Collection.Uri, adoCreds);
var workItemServer = me.Source.Collection.GetService <WorkItemServer>();
attachmentOMatic = new AttachmentOMatic(workItemServer, config.AttachmentWorkingPath);
}
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>());
}
return(new List <AzureTestCase>());
}
public WorkItemClassificationNode RenameArea(string project, string path, string name)
{
WorkItemClassificationNode node = new WorkItemClassificationNode()
{
Name = name,
StructureType = TreeNodeStructureType.Area
};
VssConnection connection = new VssConnection(_uri, _credentials);
WorkItemTrackingHttpClient workItemTrackingHttpClient = connection.GetClient <WorkItemTrackingHttpClient>();
WorkItemClassificationNode result = workItemTrackingHttpClient.UpdateClassificationNodeAsync(node, project, TreeStructureGroup.Areas, path).Result;
return(result);
}
public async Task <WorkItem> GetWorkItem(VssConnection connection, int id)
{
using (WorkItemTrackingHttpClient client = connection.GetClient <WorkItemTrackingHttpClient>())
{
try
{
return(await client.GetWorkItemAsync(id, null, null, WorkItemExpand.Relations));
}
catch (Exception)
{
return(null);
}
}
}
public WorkItem UpdateWorkItemBoardColumn()
{
string targetColumn = "Testing"; //need to set to match your board
VssConnection connection = Context.Connection;
WorkItemTrackingHttpClient witClient = connection.GetClient <WorkItemTrackingHttpClient>();
JsonPatchDocument patchDocument = new JsonPatchDocument();
//create a work item that drops into the new column by default
WorkItem workItem = this.CreateWorkItem("Board Column Test", "User Story");
string wefField = "";
//find the WEF field
//todo: do something smarter rather than loop through all fields to find the WEF
foreach (var field in workItem.Fields)
{
if (field.Key.Contains("_Kanban.Column"))
{
wefField = field.Key.ToString();
break;
}
}
//build a patch document to update the WEF field
patchDocument.Add(
new JsonPatchOperation()
{
Operation = Operation.Test,
Path = "/rev",
Value = "1"
}
);
patchDocument.Add(
new JsonPatchOperation()
{
Operation = Operation.Add,
Path = "/fields/" + wefField,
Value = targetColumn
}
);
WorkItem result = witClient.UpdateWorkItemAsync(patchDocument, Convert.ToInt32(workItem.Id)).Result;
Context.Log("Updated work item to teams board column '" + targetColumn + "'");
return(result);
}
public WorkItemClassificationNode MoveIteration(string project, string targetIteration, int id)
{
WorkItemClassificationNode node = new WorkItemClassificationNode()
{
Id = id,
StructureType = TreeNodeStructureType.Iteration
};
VssConnection connection = new VssConnection(_uri, _credentials);
WorkItemTrackingHttpClient workItemTrackingHttpClient = connection.GetClient <WorkItemTrackingHttpClient>();
WorkItemClassificationNode result = workItemTrackingHttpClient.UpdateClassificationNodeAsync(node, project, TreeStructureGroup.Iterations, targetIteration).Result;
return(result);
}
public static async Task <IEnumerable <WorkItem> > GetWorkItemsAsync(this WorkItemTrackingHttpClient source, IEnumerable <int> ids, bool includeChildren, CancellationToken cancellationToken)
{
var expandFlags = WorkItemExpand.Fields;
if (includeChildren)
{
expandFlags = WorkItemExpand.All;
}
var results = await source.TryCatchAsync(c => c.GetWorkItemsAsync(ids, expand: expandFlags, errorPolicy: WorkItemErrorPolicy.Omit, cancellationToken: cancellationToken)).ConfigureAwait(false);
return(results ?? Enumerable.Empty <WorkItem>());
}
/// <summary>
/// Given an int array, get the list of workitems. Retries 5 times for connection timeouts etc.
/// </summary>
/// <param name="client"></param>
/// <param name="ids"></param>
/// <returns></returns>
public async static Task <IList <WorkItem> > GetWorkItemsAsync(WorkItemTrackingHttpClient client, IEnumerable <int> ids, IEnumerable <string> fields = null, WorkItemExpand?expand = null)
{
Logger.LogDebug(LogDestination.File, $"Getting work items for {client.BaseAddress.Host}");
if (ids == null)
{
throw new ArgumentNullException(nameof(ids));
}
return(await RetryHelper.RetryAsync(async() =>
{
return await client.GetWorkItemsAsync(ids, fields: fields, expand: expand);
}, 5));
}
public WorkItem AddAttachment()
{
int id = Convert.ToInt32(Context.GetValue <WorkItem>("$newWorkItem3").Id);
string filePath = ClientSampleHelpers.GetSampleTextFile();
VssConnection connection = Context.Connection;
WorkItemTrackingHttpClient workItemTrackingClient = connection.GetClient <WorkItemTrackingHttpClient>();
// upload attachment to store and get a reference to that file
AttachmentReference attachmentReference = workItemTrackingClient.CreateAttachmentAsync(filePath).Result;
JsonPatchDocument patchDocument = new JsonPatchDocument();
patchDocument.Add(
new JsonPatchOperation()
{
Operation = Operation.Test,
Path = "/rev",
Value = "1"
}
);
patchDocument.Add(
new JsonPatchOperation()
{
Operation = Operation.Add,
Path = "/fields/System.History",
Value = "Adding the necessary spec"
}
);
patchDocument.Add(
new JsonPatchOperation()
{
Operation = Operation.Add,
Path = "/relations/-",
Value = new
{
rel = "AttachedFile",
url = attachmentReference.Url,
attributes = new { comment = "VanDelay Industries - Spec" }
}
}
);
WorkItem result = workItemTrackingClient.UpdateWorkItemAsync(patchDocument, id).Result;
return(result);
}
/// <summary>
/// Upload attachment of file at the given path to the issue with given issue id
/// from "AzureDevOps-dotnet-samples" repo
/// Also adds comment about snapshot to work item
/// </summary>
/// <param name="path">path to file that should be attached</param>
/// <param name="issueId">issue id to attach file to</param>
/// <returns>Task with completed issue ID or null if user is not connected to AzureDevOps</returns>
internal async Task <int?> AttachTestResultToIssue(string path, int issueId)
{
if (!ConnectedToAzureDevOps)
{
return(null);
}
WorkItemTrackingHttpClient wit = _baseServerConnection.GetClient <WorkItemTrackingHttpClient>();
AttachmentReference attachment;
using (FileStream outputStream = new FileStream(path, FileMode.Open))
{
attachment = await wit.CreateAttachmentAsync(outputStream, Invariant($"{issueId}.a11ytest")).ConfigureAwait(false);
}
JsonPatchDocument patchDoc = new JsonPatchDocument();
patchDoc.Add(new JsonPatchOperation()
{
Operation = Operation.Test,
Path = "/rev",
Value = "1"
}
);
patchDoc.Add(new JsonPatchOperation()
{
Operation = Operation.Add,
Path = "/fields/System.History",
Value = "Attached an Accessibility Insights for Windows test file and screenshot."
}
);
patchDoc.Add(new JsonPatchOperation()
{
Operation = Operation.Add,
Path = "/relations/-",
Value = new
{
rel = "AttachedFile",
url = attachment.Url,
attributes = new { comment = "Accessibility Insights for Windows test file" }
}
}
);
#pragma warning disable CA2007 // Do not directly await a Task
#pragma warning disable CA2008 // Do not create tasks without passing a TaskScheduler
return(await wit.UpdateWorkItemAsync(patchDoc, issueId).ContinueWith(t => t.Result.Id));
#pragma warning restore CA2008 // Do not create tasks without passing a TaskScheduler
#pragma warning restore CA2007 // Do not directly await a Task
}
static void Main(string[] args)
{
Uri accountUri = new Uri(Helper.ThisIsMyVSTS);
String personalAccessToken = Helper.ThisIsMyPAT;
var workItemIds = new List <int>();
workItemIds.Add(1744); // this is a random list of work item ids in the tpc
workItemIds.Add(1665);
workItemIds.Add(29);
// Create a connection to the account
VssConnection connection = new VssConnection(accountUri, new VssBasicCredential(string.Empty, personalAccessToken));
// Get an instance of the work item tracking client
WorkItemTrackingHttpClient witClient = connection.GetClient <WorkItemTrackingHttpClient>();
try
{
foreach (var wID in workItemIds)
{
Console.WriteLine("*****************************");
Console.WriteLine("*****************************");
Console.WriteLine("*** WORK ITEM: {0} *******", wID);
Console.WriteLine("*****************************");
Console.WriteLine("*****************************");
// Get the specified work item
WorkItem workitem = witClient.GetWorkItemAsync(wID).Result;
// Output the work item's field values
foreach (var field in workitem.Fields)
{
Console.WriteLine(" {0}: {1}", field.Key, field.Value);
}
Console.WriteLine();
Console.WriteLine();
}
}
catch (AggregateException aex)
{
VssServiceException vssex = aex.InnerException as VssServiceException;
if (vssex != null)
{
Console.WriteLine(vssex.Message);
}
}
}
private static void GetWorkitems(VssConnection connection, bool update = false)
{
Console.WriteLine("Loading workitem info");
WorkItemTrackingHttpClient workItemTrackingClient = connection.GetClient <WorkItemTrackingHttpClient>();
var workitemIds = new int[] { 9, 10 };
string[] fieldNames = new string[] {
"System.Id",
"System.Title",
"System.WorkItemType"
// , "Microsoft.VSTS.Scheduling.RemainingWork"
};
List <WorkItem> workitems = workItemTrackingClient.GetWorkItemsAsync(workitemIds, fieldNames).Result;
foreach (var workitem in workitems)
{
Console.WriteLine($"Workitem found: {workitem.Id}");
foreach (var fieldName in fieldNames)
{
Console.Write(" {0}: {1}", fieldName, workitem.Fields[fieldName]);
}
Console.WriteLine();
}
if (update)
{
// create a patchDocument
JsonPatchDocument patchDocument = new JsonPatchDocument();
patchDocument.Add(
new JsonPatchOperation()
{
Operation = Microsoft.VisualStudio.Services.WebApi.Patch.Operation.Add,
Path = "/fields/System.WorkItemType",
Value = "Epic",
//From = changedBy
}
);
var workItemId = workitemIds[1];
Console.WriteLine($"Updating workitem with id {workItemId}");
// call for the update
//var result = workItemTrackingClient.UpdateWorkItemAsync(patchDocument, workItemId).Result;
// show result
//Console.WriteLine($"Workitem change result: {result.Id}, WorkItemType: {result.Fields["System.WorkItemType"]}");
}
}
public string CreateWorkItem(string projectName)
{
JsonPatchDocument patchDocument = new JsonPatchDocument();
patchDocument.Add(
new JsonPatchOperation()
{
Operation = Operation.Add,
Path = "/fields/System.Title",
Value = "Authorization Errors"
}
);
patchDocument.Add(
new JsonPatchOperation()
{
Operation = Operation.Add,
Path = "/fields/Microsoft.VSTS.TCM.ReproSteps",
Value = "Our authorization logic needs to allow for users with Microsoft accounts (formerly Live Ids) - http:// msdn.microsoft.com/en-us/library/live/hh826547.aspx"
}
);
patchDocument.Add(
new JsonPatchOperation()
{
Operation = Operation.Add,
Path = "/fields/Microsoft.VSTS.Common.Priority",
Value = "1"
}
);
patchDocument.Add(
new JsonPatchOperation()
{
Operation = Operation.Add,
Path = "/fields/Microsoft.VSTS.Common.Severity",
Value = "2 - High"
}
);
using (WorkItemTrackingHttpClient workItemTrackingHttpClient = new WorkItemTrackingHttpClient(_uri, _credentials))
{
WorkItem result = workItemTrackingHttpClient.CreateWorkItemAsync(patchDocument, projectName, "Bug").Result;
}
patchDocument = null;
return("success");
}
/// <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 WorkItemTrackingHttpClient CreateWorkItemHttpClient()
{
var uri = string.Format(CollectionUri, Connection.ServerUrl, Connection.Collection);
WorkItemTrackingHttpClient witClient = null;
if (Regex.IsMatch(uri, "visualstudio.com"))
{
witClient = new WorkItemTrackingHttpClient(new Uri(uri), new VssBasicCredential(Connection.UserName, Connection.Password));
}
else
{
witClient = new WorkItemTrackingHttpClient(new Uri(uri), new VssCredentials(new WindowsCredential(new NetworkCredential(Connection.UserName, Connection.Password))));
}
return witClient;
}
