public static CatalogNode GetTeamProjectCollection(TfsConfigurationServer tfs)
{
ReadOnlyCollection<CatalogNode> teamProjectCatalogs = tfs.CatalogNode.QueryChildren(
new[] { CatalogResourceTypes.ProjectCollection }, false, CatalogQueryOptions.None);
return teamProjectCatalogs.FirstOrDefault(p => p.Resource.DisplayName == GetConfigValue("$Instance.TeamProjectCollectionName$"));
}
public TFS(string servername, string domain, string username, string password)
{
if (string.IsNullOrEmpty(servername))
{
throw new ArgumentException("Parameter named:servername cannot be null or empty.");
}
if (string.IsNullOrEmpty(username))
{
throw new ArgumentException("Parameter named:username cannot be null or empty.");
}
if (string.IsNullOrEmpty(password))
{
throw new ArgumentException("Parameter named:password cannot be null or empty.");
}
try
{
var tfsConfigurationServer = new TfsConfigurationServer(new Uri(servername),
new NetworkCredential(username, password, domain));
store = (WorkItemStore) tfsConfigurationServer.GetService(typeof (WorkItemStore));
}
catch (Exception)
{
var tfsServer = new TeamFoundationServer(servername, new NetworkCredential(username, password, domain));
store = (WorkItemStore) tfsServer.GetService(typeof (WorkItemStore));
}
}
public List <String> GetTFSProjects()
{
TfsConfigurationServer server = GetTFSServerInformation();
ReadOnlyCollection <CatalogNode> catalog = GetTFSCollectionNodes(server);
return(GetTFSListOfProjects(server, catalog));
}
public TfsClient( Uri tfsUri, NetworkCredential credential,
string collenctionName, string projectName )
{
configurationServer =
new TfsConfigurationServer( tfsUri, credential );
GetTfsProject( collenctionName, projectName );
}
public static TfsTeamProjectCollection Get_TeamProjectCollection(
TfsConfigurationServer configurationServer,
CatalogNode teamProjectCollectionNode)
{
Int64 startTicks = Log.DOMAINSERVICES("Enter", Common.LOG_APPNAME);
Guid collectionId = new Guid(teamProjectCollectionNode.Resource.Properties["InstanceId"]);
TfsTeamProjectCollection teamProjectCollection;
try
{
teamProjectCollection = configurationServer.GetTeamProjectCollection(collectionId);
}
catch (TimeoutException)
{
throw;
}
catch
{
throw;
}
Log.DOMAINSERVICES("Exit", Common.LOG_APPNAME, startTicks);
return(teamProjectCollection);
}
public static TfsConfigurationServer AuthenticateToTFSService()
{
Uri tfsUri = new Uri(GetConfigValue("$Instance.VSOnlineUri$"));
string username = GetConfigValue("$Instance.Username$");
string password = GetConfigValue("$Instance.Password$");
NetworkCredential netCred = new NetworkCredential(username, password);
BasicAuthCredential basicCred = new BasicAuthCredential(netCred);
TfsClientCredentials tfsCred = new TfsClientCredentials(basicCred);
tfsCred.AllowInteractive = false;
TfsConfigurationServer configurationServer = new TfsConfigurationServer(new Uri(tfsUrl), tfsCred);
configurationServer.Authenticate();
return(configurationServer);
//If you specify a provider, the user will be provided with a prompt to provide non-default credentials
ICredentialsProvider provider = new UICredentialsProvider();
TfsConfigurationServer tfs = TfsConfigurationServerFactory.GetConfigurationServer(tfsUri, provider);
try
{
//Prompts the user for credentials if they have not already been authenticated
tfs.EnsureAuthenticated();
}
catch (TeamFoundationServerUnauthorizedException)
{
//Handle the TeamFoundationServerUnauthorizedException that is thrown when the user clicks 'Cancel'
//in the authentication prompt or if they are otherwise unable to be successfully authenticated
tfs = null;
}
return(tfs);
}
internal static XlHlp.XlLocation AddSection_ConfigurationServer_Info(
XlHlp.XlLocation insertAt,
TfsConfigurationServer configurationServer)
{
insertAt.MarkStart(XlHlp.MarkType.None);
XlHlp.AddLabeledInfo(insertAt.AddRow(2), "Name:", configurationServer.Name);
XlHlp.AddLabeledInfo(insertAt.AddRow(2), "Culture:", configurationServer.Culture.DisplayName);
XlHlp.AddLabeledInfo(insertAt.AddRow(2), "InstanceId:", configurationServer.InstanceId.ToString());
XlHlp.AddLabeledInfo(insertAt.AddRow(2), "ServerCapabilities:", configurationServer.ServerCapabilities.ToString());
XlHlp.AddLabeledInfo(insertAt.AddRow(2), "SessionId:", configurationServer.SessionId.ToString());
XlHlp.AddLabeledInfo(insertAt.AddRow(2), "TimeZone:", configurationServer.TimeZone.ToString());
XlHlp.AddLabeledInfo(insertAt.AddRow(2), "UICulture", configurationServer.UICulture.ToString());
XlHlp.AddLabeledInfo(insertAt.AddRow(2), "Uri", configurationServer.Uri.ToString());
XlHlp.AddLabeledInfo(insertAt.AddRow(2), "AuthorizedIdentity:", configurationServer.AuthorizedIdentity.DisplayName);
XlHlp.AddLabeledInfo(insertAt.AddRow(2), "CatalogNode:", configurationServer.CatalogNode.FullPath);
XlHlp.AddLabeledInfo(insertAt.AddRow(2), "HasAuthenticated:", configurationServer.HasAuthenticated.ToString());
XlHlp.AddLabeledInfo(insertAt.AddRow(2), "IsHostedServer:", configurationServer.IsHostedServer.ToString());
XlHlp.AddLabeledInfo(insertAt.AddRow(2), "ClientCacheDirectoryForInstance:", configurationServer.ClientCacheDirectoryForInstance);
XlHlp.AddLabeledInfo(insertAt.AddRow(2), "ClientCacheDirectoryForUser:", configurationServer.ClientCacheDirectoryForUser);
insertAt.MarkEnd(XlHlp.MarkType.None);
if (!insertAt.OrientVertical)
{
// Skip past the info just added.
insertAt.SetLocation(insertAt.RowStart, insertAt.MarkEndColumn + 1);
}
return(insertAt);
}
public static void Main(string[] args)
{
LogArguments(args);
Uri projectCollectionUri = new Uri(args.ElementAt(0));
Guid projectCollectionId = Guid.Parse(args.ElementAt(1));
Guid requestedByUserId = Guid.Parse(args.ElementAt(2));
string artifactsFolder = Path.GetFullPath(args.ElementAt(3));
string emailSubject = args.ElementAt(4);
string emailBody = args.ElementAt(5);
Console.WriteLine("Project collection URI: " + projectCollectionUri);
Console.WriteLine("Project collection id: " + projectCollectionId);
Console.WriteLine("User identifier: " + requestedByUserId);
Console.WriteLine("Artifacts folder: " + artifactsFolder);
Console.WriteLine("Email subject: " + emailSubject);
Console.WriteLine("Email body: " + emailBody);
string tfsUriFromCollectionUri = projectCollectionUri.AbsoluteUri.Replace(projectCollectionUri.Segments.Last(), string.Empty);
TfsConfigurationServer configurationServer = TfsConfigurationServerFactory.GetConfigurationServer(new Uri(tfsUriFromCollectionUri));
TfsTeamProjectCollection teamProjectCollection = configurationServer.GetTeamProjectCollection(projectCollectionId);
IIdentityManagementService identityServiceManager = teamProjectCollection.GetService <IIdentityManagementService>();
TeamFoundationIdentity[] tfsIdentities = identityServiceManager.ReadIdentities(new Guid[1] {
requestedByUserId
}, MembershipQuery.Direct);
SendArtifacs(tfsIdentities, emailSubject, emailBody, artifactsFolder);
}
/// <summary>
/// Connects to the TFS server.
/// </summary>
public void Connect()
{
configurationServer = new TfsConfigurationServer(ServerUri, System.Net.CredentialCache.DefaultCredentials);
// Get the catalog of team project collections
ReadOnlyCollection <CatalogNode> collectionNodes = configurationServer.CatalogNode.QueryChildren(
new[] { CatalogResourceTypes.ProjectCollection },
false, CatalogQueryOptions.None);
// List the team project collections
foreach (CatalogNode collectionNode in collectionNodes)
{
// Use the InstanceId property to get the team project collection
Guid collectionId = new Guid(collectionNode.Resource.Properties["InstanceId"]);
TfsTeamProjectCollection teamProjectCollection = configurationServer.GetTeamProjectCollection(collectionId);
// Find the requested team project collection
if (teamProjectCollection.Name.ToUpper(CultureInfo.InvariantCulture).EndsWith(this.TeamProjectCollectionName.ToUpper(CultureInfo.InvariantCulture), StringComparison.Ordinal))
{
SourceControl = (VersionControlServer)teamProjectCollection.GetService(typeof(VersionControlServer));
this.TeamProjects = new ReadOnlyCollection <TeamProject>(SourceControl.GetAllTeamProjects(false));
break; // We got what we want, now exit the loop
}
}
}
static void Main()
{
var tfsUri = new Uri("http://xx.xx.xx.xx:8080/tfs");
TfsConfigurationServer configurationServer =
TfsConfigurationServerFactory.GetConfigurationServer(tfsUri);
// Get the catalog of team project collections
ReadOnlyCollection <CatalogNode> collectionNodes = configurationServer.CatalogNode.QueryChildren(
new[] { CatalogResourceTypes.ProjectCollection },
false, CatalogQueryOptions.None);
// List the team project collections
foreach (CatalogNode collectionNode in collectionNodes)
{
// Use the InstanceId property to get the team project collection
Guid collectionId = new Guid(collectionNode.Resource.Properties["InstanceId"]);
TfsTeamProjectCollection teamProjectCollection = configurationServer.GetTeamProjectCollection(collectionId);
// Print the name of the team project collection
Console.WriteLine("Collection: " + teamProjectCollection.Name);
// Get a catalog of team projects for the collection
ReadOnlyCollection <CatalogNode> projectNodes = collectionNode.QueryChildren(
new[] { CatalogResourceTypes.TeamProject },
false, CatalogQueryOptions.None);
// List the team projects in the collection
foreach (CatalogNode projectNode in projectNodes)
{
Console.WriteLine(" Team Project: " + projectNode.Resource.DisplayName);
}
}
}
public static WorkItemStore GetWorkItemStore(TfsConfigurationServer tfs, CatalogNode teamProjectColCatalog)
{
Guid teamProjectCatalogId = new Guid(teamProjectColCatalog.Resource.Properties["InstanceId"]);
TfsTeamProjectCollection teamProjectCollection = tfs.GetTeamProjectCollection(teamProjectCatalogId);
return(new WorkItemStore(teamProjectCollection));
}
public TFS(string servername, string domain, string username, string password)
{
if (string.IsNullOrEmpty(servername))
{
throw new ArgumentException("Parameter named:servername cannot be null or empty.");
}
if (string.IsNullOrEmpty(username))
{
throw new ArgumentException("Parameter named:username cannot be null or empty.");
}
if (string.IsNullOrEmpty(password))
{
throw new ArgumentException("Parameter named:password cannot be null or empty.");
}
//ICredentialsProvider provider = new UICredentialsProvider();
//tfsServer = TeamFoundationServerFactory.GetServer(serverName, provider);
//if (!tfsServer.HasAuthenticated)
// tfsServer.Authenticate();
try
{
var tfsConfigurationServer = new TfsConfigurationServer(new Uri(servername),
new NetworkCredential(username, password, domain));
store = (WorkItemStore) tfsConfigurationServer.GetService(typeof (WorkItemStore));
}
catch (Exception)
{
var tfsServer = new TeamFoundationServer(servername, new NetworkCredential(username, password, domain));
store = (WorkItemStore) tfsServer.GetService(typeof (WorkItemStore));
}
}
public MyTfsProjectCollection(CatalogNode teamProjectCollectionNode, TfsConfigurationServer tfsConfigurationServer, NetworkCredential networkCredential)
{
try
{
Name = teamProjectCollectionNode.Resource.DisplayName;
ServiceDefinition tpcServiceDefinition = teamProjectCollectionNode.Resource.ServiceReferences["Location"];
var configLocationService = tfsConfigurationServer.GetService<ILocationService>();
var tpcUri = new Uri(configLocationService.LocationForCurrentConnection(tpcServiceDefinition));
_tfsTeamProjectCollection = TfsTeamProjectCollectionFactory.GetTeamProjectCollection(tpcUri, new MyCredentials(networkCredential));
_commonStructureService = _tfsTeamProjectCollection.GetService<ICommonStructureService>();
_buildServer = _tfsTeamProjectCollection.GetService<IBuildServer>();
_tswaClientHyperlinkService = _tfsTeamProjectCollection.GetService<TswaClientHyperlinkService>();
CurrentUserHasAccess = true;
}
catch (TeamFoundationServiceUnavailableException ex)
{
_log.Debug("Can't access " + Name + ". This could be because the project collection is currently offline.", ex);
CurrentUserHasAccess = false;
}
catch (TeamFoundationServerUnauthorizedException ex)
{
_log.Debug("Unauthorized access to " + teamProjectCollectionNode, ex);
CurrentUserHasAccess = false;
}
}
/// <summary>
/// connect to a TFS Server.
/// </summary>
/// <param name="tfsUri">Possible URI of the TFS Server</param>
/// <returns>The correct Tfs Uri</returns>
public Uri ConnectToTfsServer(Uri tfsUri)
{
bool tfsIsConnected = false;
//The URI we get from FoundationServerExt_ProjectContextChanged does not allow us to connect to the server
//Trim the URI from back to front till connection can be established
while (!tfsIsConnected && tfsUri.AbsolutePath != tfsUri.Authority)
{
m_TfsConfigurationServer =
TfsConfigurationServerFactory.GetConfigurationServer(tfsUri);
tfsUri =
new Uri(
tfsUri.OriginalString.Substring(0, tfsUri.OriginalString.LastIndexOf('/')));
// workaround: if tfsConfigurationServer.EnsureAuthenticated() fails it doesn't set tfsIsConnected to true and continues to trim uri
try
{
m_TfsConfigurationServer.EnsureAuthenticated();
tfsIsConnected = true;
}
catch (TeamFoundationServerException)
{
tfsIsConnected = false;
}
}
if (tfsIsConnected)
{
FetchProjects();
}
return(tfsUri);
}
/// <summary>
/// Lists all TFS collection from server, each collection can have project
/// </summary>
public void ListAllCollections()
{
try
{
TfsConfigurationServer server = TfsConfigurationServerFactory.GetConfigurationServer(new Uri(_tfsAddress));
ReadOnlyCollection <CatalogNode> collectionNodes = server.CatalogNode.QueryChildren(new[] { CatalogResourceTypes.ProjectCollection }, false, CatalogQueryOptions.None);
foreach (CatalogNode node in collectionNodes)
{
Guid collectionId = new Guid(node.Resource.Properties["InstanceId"]);
TfsTeamProjectCollection teamProjectCollection = server.GetTeamProjectCollection(collectionId);
Console.WriteLine("Collection: " + teamProjectCollection.Name);
// TODO - temporary list all projects also here
ReadOnlyCollection <CatalogNode> projectNodes = node.QueryChildren(new[] { CatalogResourceTypes.TeamProject }, false, CatalogQueryOptions.None);
foreach (CatalogNode elem in projectNodes)
{
Console.WriteLine("Team project name is: " + elem.Resource.DisplayName);
}
}
}
catch (Exception ex)
{
// custom exception handling - TODO throw custom exception
_logger.Error("Tfs conection error: " + ex.Message);
throw;
}
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="username">Username on the service.</param>
/// <param name="password">Password on the service.</param>
/// <param name="domain">Domain on the service.</param>
/// <param name="host">Root path of the service.</paparam>
internal TeamFoundationServerService(String username, String password, String domain, String host)
{
_username = username;
_configurationServer = GetConfigurationServer(username, password, domain, host);
try
{
_configurationServer.Authenticate();
}
catch (Exception)
{
try
{
Uri url = new Uri(host);
String ip = Dns.GetHostAddresses(url.DnsSafeHost).First().ToString();
String newHost = url.Scheme + "://" + ip + ":" + url.Port + url.PathAndQuery;
_configurationServer = GetConfigurationServer(username, password, domain, newHost);
_configurationServer.Authenticate();
}
catch (TeamFoundationServiceUnavailableException)
{
//if authentication fail
return;
}
}
}
public static BuildDefinitionDtoCollection GetBuildDefinitions(this TfsConfigurationServer tfsConfigurationServer, Guid teamProjectCollectionId, string teamProjectName)
{
if (tfsConfigurationServer == null)
{
throw new ArgumentNullException("tfsConfigurationServer");
}
TfsTeamProjectCollection tfsTeamProjectCollection = tfsConfigurationServer.GetTeamProjectCollection(teamProjectCollectionId);
IBuildServer buildServer = tfsTeamProjectCollection.GetService <IBuildServer>();
IBuildDefinition[] buildDefinitions = buildServer.QueryBuildDefinitions(teamProjectName);
BuildDefinitionDtoCollection buildDefinitionDtoCollection = new BuildDefinitionDtoCollection();
foreach (IBuildDefinition buildDefinition in buildDefinitions)
{
BuildDefinitionDto buildDefinitionDto = new BuildDefinitionDto();
buildDefinitionDto.TeamProjectName = buildDefinition.TeamProject;
buildDefinitionDto.Name = buildDefinition.Name;
buildDefinitionDto.Id = buildDefinition.Id;
buildDefinitionDto.Uri = buildDefinition.Uri;
buildDefinitionDtoCollection.Add(buildDefinitionDto);
}
return(buildDefinitionDtoCollection);
}
public static IEnumerable <WorkItemDto> GetWorkItemsFromTeamBuilds(this TfsConfigurationServer tfsConfigurationServer, Guid teamProjectCollectionId, IEnumerable <WorkItemSummaryDto> workItems)
{
if (tfsConfigurationServer == null)
{
throw new ArgumentNullException("tfsConfigurationServer");
}
if (workItems == null)
{
throw new ArgumentNullException("workItems");
}
TfsTeamProjectCollection tfsTeamProjectCollection = tfsConfigurationServer.GetTeamProjectCollection(teamProjectCollectionId);
WorkItemStore workItemStore = tfsTeamProjectCollection.GetService <WorkItemStore>();
WorkItemDtoCollection workItemDtoCollection = new WorkItemDtoCollection();
foreach (WorkItemSummaryDto workItemSummaryDto in workItems)
{
WorkItem workItem = workItemStore.GetWorkItem(workItemSummaryDto.Id);
WorkItemDto workItemDto = WorkItemDto.CreateFromWorkItem(workItem, workItemSummaryDto.AssociatedBuildNumber);
workItemDtoCollection.Add(workItemDto);
}
return(workItemDtoCollection);
}
public static TeamBuildDtoCollection GetTeamBuilds(this TfsConfigurationServer tfsConfigurationServer, Guid teamProjectCollectionId, string teamProjectName, IEnumerable <string> teamBuildDefinitionNames)
{
if (tfsConfigurationServer == null)
{
throw new ArgumentNullException("tfsConfigurationServer");
}
if (teamBuildDefinitionNames == null)
{
throw new ArgumentNullException("teamBuildDefinitionNames");
}
TfsTeamProjectCollection tfsTeamProjectCollection = tfsConfigurationServer.GetTeamProjectCollection(teamProjectCollectionId);
IBuildServer buildServer = tfsTeamProjectCollection.GetService <IBuildServer>();
TeamBuildDtoCollection teamBuildDtoCollection = new TeamBuildDtoCollection();
foreach (string teamBuildDefinitionName in teamBuildDefinitionNames)
{
IBuildDetailSpec buildDetailSpec = buildServer.CreateBuildDetailSpec(teamProjectName, teamBuildDefinitionName);
buildDetailSpec.Reason = BuildReason.All;
buildDetailSpec.QueryOrder = BuildQueryOrder.FinishTimeDescending;
buildDetailSpec.QueryDeletedOption = QueryDeletedOption.ExcludeDeleted;
IBuildQueryResult buildQueryResult = buildServer.QueryBuilds(buildDetailSpec);
foreach (IBuildDetail buildDetail in buildQueryResult.Builds)
{
TeamBuildDto teamBuildDto = new TeamBuildDto();
teamBuildDto.BuildNumber = buildDetail.BuildNumber;
teamBuildDto.Uri = buildDetail.Uri;
teamBuildDto.DefinitionName = teamBuildDefinitionName;
teamBuildDtoCollection.Add(teamBuildDto);
}
}
return(teamBuildDtoCollection);
}
public void createConfigurationServer(Uri uri)
{
TfsConfigurationServer configurationServer =
TfsConfigurationServerFactory.GetConfigurationServer(uri);
_configurationServer = configurationServer;
}
public static CatalogNode GetTeamProjectCollection(TfsConfigurationServer tfs)
{
ReadOnlyCollection <CatalogNode> teamProjectCatalogs = tfs.CatalogNode.QueryChildren(
new[] { CatalogResourceTypes.ProjectCollection }, false, CatalogQueryOptions.None);
return(teamProjectCatalogs.FirstOrDefault(p => p.Resource.DisplayName == GetConfigValue("$Instance.TeamProjectCollectionName$")));
}
private static async Task <bool> CanLogIn(string username, string password, string uri, string configType)
{
bool response = false;
// VSO check
if (configType == "VSO")
{
using (var client = new HttpClient())
{
client.BaseAddress = new Uri(uri);
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic",
Convert.ToBase64String(
Encoding.ASCII.GetBytes(string.Format("{0}:{1}", username, password))));
Debug.WriteLine("Code: " + client.GetAsync("").Result.StatusCode);
response = client.GetAsync("").Result.StatusCode == HttpStatusCode.OK;
}
}
// TFS check
else if (configType == "TFS")
{
var credentials = new TfsClientCredentials(new WindowsCredential(new NetworkCredential(username, password)));
var server = new TfsConfigurationServer(new Uri(uri), credentials);
try
{
server.EnsureAuthenticated();
}
catch (TeamFoundationServerUnauthorizedException e)
{
return(false);
}
response = server.HasAuthenticated;
}
return(response);
}
private void btnConnect_Click(object sender, EventArgs e)
{
if (txtServerUrl.Enabled)
{
string strServerUrl = txtServerUrl.Text;
try
{
// get the configuartion service
#if UsingVssClientCredentials
// TODO: find a way for TFS 2017 to always ask for credentials
srvConfiguration = new TfsConfigurationServer(new Uri(strServerUrl), new Microsoft.VisualStudio.Services.Client.VssClientCredentials(new Microsoft.VisualStudio.Services.Common.WindowsCredential(true), Microsoft.VisualStudio.Services.Common.CredentialPromptType.PromptIfNeeded));
#else
srvConfiguration = new TfsConfigurationServer(new Uri(strServerUrl), null, new UICredentialsProvider(this));
#endif
// get the registry service
tfsRegServiceConfiguration = srvConfiguration.GetService <ITeamFoundationRegistry>();
ReadRegistry();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
return;
}
EnableControls(true);
}
else
{
EnableControls(false);
}
}
static void Main(string[] args)
{
// Connect to Team Foundation Server
// Server is the name of the server that is running the application tier for Team Foundation.
// Port is the port that Team Foundation uses. The default port is 8080.
// VDir is the virtual path to the Team Foundation application. The default path is tfs.
Uri tfsUri = (args.Length < 1) ?
new Uri("http://pro-pggm-manoj:8080/tfs") : new Uri(args[0]);
TfsConfigurationServer configurationServer =
TfsConfigurationServerFactory.GetConfigurationServer(tfsUri);
// Get the catalog of team project collections
ReadOnlyCollection <CatalogNode> collectionNodes = configurationServer.CatalogNode.QueryChildren(
new[] { CatalogResourceTypes.ProjectCollection },
false, CatalogQueryOptions.None);
// Use the InstanceId property to get the team project collection
Guid collectionId = new Guid(collectionNodes[0].Resource.Properties["InstanceId"]);
TfsTeamProjectCollection teamProjectCollection = configurationServer.GetTeamProjectCollection(collectionId);
ClientObjectModel.UpdateChangeSetComments(teamProjectCollection, "Updated Thru Code");
ClientObjectModel.DisplayWorkItemsInConsole(teamProjectCollection);
}
public MyTfsProjectCollection(CatalogNode teamProjectCollectionNode, TfsConfigurationServer tfsConfigurationServer, NetworkCredential networkCredential)
{
try
{
Name = teamProjectCollectionNode.Resource.DisplayName;
ServiceDefinition tpcServiceDefinition = teamProjectCollectionNode.Resource.ServiceReferences["Location"];
var configLocationService = tfsConfigurationServer.GetService <ILocationService>();
var tpcUri = new Uri(configLocationService.LocationForCurrentConnection(tpcServiceDefinition));
_tfsTeamProjectCollection = TfsTeamProjectCollectionFactory.GetTeamProjectCollection(tpcUri, new MyCredentials(networkCredential));
_commonStructureService = _tfsTeamProjectCollection.GetService <ICommonStructureService>();
_buildServer = _tfsTeamProjectCollection.GetService <IBuildServer>();
_tswaClientHyperlinkService = _tfsTeamProjectCollection.GetService <TswaClientHyperlinkService>();
CurrentUserHasAccess = true;
}
catch (TeamFoundationServiceUnavailableException ex)
{
_log.Debug("Can't access " + Name + ". This could be because the project collection is currently offline.", ex);
CurrentUserHasAccess = false;
}
catch (TeamFoundationServerUnauthorizedException ex)
{
_log.Debug("Unauthorized access to " + teamProjectCollectionNode, ex);
CurrentUserHasAccess = false;
}
}
public static TfsConfigurationServer GetConfigurationServerAndAuthenticate(Uri tfsUrl)
{
TfsConfigurationServer tfsConfigurationServer = TfsConfigurationServerFactory.GetConfigurationServer(tfsUrl);
tfsConfigurationServer.Authenticate();
return(tfsConfigurationServer);
}
public void ConnectToTFSServer(string ServerURL)
{
// Connect to Team Foundation Server
// Server is the name of the server that is running the application tier for Team Foundation.
// Port is the port that Team Foundation uses. The default port is 8080.
// VDir is the virtual path to the Team Foundation application. The default path is tfs.
Uri tfsUri = new Uri(ServerURL);
TfsConfigurationServer configurationServer =
TfsConfigurationServerFactory.GetConfigurationServer(tfsUri);
// Get the catalog of team project collections
ReadOnlyCollection <CatalogNode> collectionNodes = configurationServer.CatalogNode.QueryChildren(
new[] { CatalogResourceTypes.ProjectCollection },
false, CatalogQueryOptions.None);
// List the team project collections
foreach (CatalogNode collectionNode in collectionNodes)
{
// Use the InstanceId property to get the team project collection
Guid collectionId = new Guid(collectionNode.Resource.Properties["InstanceId"]);
TfsTeamProjectCollection teamProjectCollection = configurationServer.GetTeamProjectCollection(collectionId);
// Print the name of the team project collection
Console.WriteLine("Collection: " + teamProjectCollection.Name);
// Get a catalog of team projects for the collection
ReadOnlyCollection <CatalogNode> projectNodes = collectionNode.QueryChildren(
new[] { CatalogResourceTypes.TeamProject },
false, CatalogQueryOptions.None);
}
}
protected RepositoryBase(String username, String password, string domain, string projectCollection, String url)
{
string fullUrl = url;
bool collectionExists = !String.IsNullOrEmpty(projectCollection);
if (String.IsNullOrEmpty(username))
throw new ArgumentNullException(username, "Username is null or empty!");
if (String.IsNullOrEmpty(password))
throw new ArgumentNullException(password, "Password is null or empty!");
if (collectionExists)
fullUrl = url.LastIndexOf('/') == url.Length - 1
? String.Concat(url, projectCollection)
: String.Concat(url, "/", projectCollection);
if (String.IsNullOrEmpty(url))
throw new ArgumentNullException(url, "TFSServerUrl is null or empty!");
var credentials = new NetworkCredential(username, password, domain);
_configuration = new TfsConfigurationServer(new Uri(url), credentials);
_configuration.EnsureAuthenticated();
if (collectionExists)
{
_tfs = new TfsTeamProjectCollection(new Uri(fullUrl), credentials);
_tfs.EnsureAuthenticated();
}
}
private static void ListProjects()
{
// URI of the team project collection
string _myUri = @"https://bupa-international.visualstudio.com";
TfsConfigurationServer configurationServer =
TfsConfigurationServerFactory.GetConfigurationServer(new Uri(_myUri));
CatalogNode catalogNode = configurationServer.CatalogNode;
ReadOnlyCollection <CatalogNode> tpcNodes = catalogNode.QueryChildren(
new Guid[] { CatalogResourceTypes.ProjectCollection },
false, CatalogQueryOptions.None);
// tpc = Team Project Collection
foreach (CatalogNode tpcNode in tpcNodes)
{
Guid tpcId = new Guid(tpcNode.Resource.Properties["InstanceId"]);
TfsTeamProjectCollection tpc = configurationServer.GetTeamProjectCollection(tpcId);
// Get catalog of tp = 'Team Projects' for the tpc = 'Team Project Collection'
var tpNodes = tpcNode.QueryChildren(
new Guid[] { CatalogResourceTypes.TeamProject },
false, CatalogQueryOptions.None);
foreach (var p in tpNodes)
{
Debug.Write(Environment.NewLine + " Team Project : " + p.Resource.DisplayName + " - " + p.Resource.Description + Environment.NewLine);
}
}
}
static void Main(string[] args)
{
TfsConfigurationServer tcs = new TfsConfigurationServer(new Uri("http://server:8080/tfs"));
IIdentityManagementService ims = tcs.GetService <IIdentityManagementService>();
TeamFoundationIdentity tfi = ims.ReadIdentity(IdentitySearchFactor.AccountName, "Project Collection Valid Users", MembershipQuery.Expanded, ReadIdentityOptions.None);
TeamFoundationIdentity[] ids = ims.ReadIdentities(tfi.Members, MembershipQuery.None, ReadIdentityOptions.None);
using (StreamWriter file = new StreamWriter("userlist.txt"))
foreach (TeamFoundationIdentity id in ids)
{
if (id.Descriptor.IdentityType == "System.Security.Principal.WindowsIdentity")
{
Console.WriteLine(id.DisplayName);
}
//{ Console.WriteLine(id.UniqueName); }
file.WriteLine("[{0}]", id.DisplayName);
}
var count = ids.Count(x => ids.Contains(x));
Console.WriteLine(count);
Console.ReadLine();
}
public static TfsConfigurationServer GetConfigurationServerAndAuthenticate(Uri tfsUrl, string domain, string userName, string password)
{
TfsConfigurationServer tfsConfigurationServer = TfsConfigurationServerFactory.GetConfigurationServer(tfsUrl);
tfsConfigurationServer.Credentials = new NetworkCredential(userName, password, domain);
tfsConfigurationServer.Authenticate();
return(tfsConfigurationServer);
}
public TfsTeamProjectCollection GetTfsTeamProjectCollection(Guid collectionId, Uri tfsServer)
{
TfsConfigurationServer configurationServer =
TfsConfigurationServerFactory.GetConfigurationServer(tfsServer);
var collection = configurationServer.GetTeamProjectCollection(collectionId);
return(collection);
}
public void Connect()
{
Uri tfsUri = _serverAddress;
TfsConfigurationServer configurationServer = TfsConfigurationServerFactory.GetConfigurationServer(tfsUri);
configurationServer.Credentials = _credentials;
configurationServer.EnsureAuthenticated();
_configurationServer = configurationServer;
}
public TeamProjectCollections(Uri tfsUri, ITfsCredentials tfsCredentials)
{
this._tfsUri = tfsUri;
this._tfsCredentials = tfsCredentials;
this._tfsTeamProjectCollection = TfsTeamProjectCollectionFactory.GetTeamProjectCollection(tfsUri, this._tfsCredentials);
this._tfsConfigurationServer = this._tfsTeamProjectCollection.GetConfigurationServer();
this._registration = (IRegistration)this._tfsTeamProjectCollection.GetService(typeof(IRegistration));
this._teamProjectCollectionService = this._tfsConfigurationServer.GetService <ITeamProjectCollectionService>();
}
public static void GetAllCollections(string tfsCollectionUri)
{
Uri configurationServerUri = new Uri(tfsCollectionUri);
TfsConfigurationServer configurationServer = TfsConfigurationServerFactory.GetConfigurationServer(configurationServerUri);
ITeamProjectCollectionService tpcService = configurationServer.GetService <ITeamProjectCollectionService>();
var tpc = tpcService.GetCollections();
}
public void createCatalogTeamProjectCollections(TfsConfigurationServer cs)
{
// Get the catalog of team project collections
ReadOnlyCollection <CatalogNode> collectionNodes = cs.CatalogNode.QueryChildren(
new[] { CatalogResourceTypes.ProjectCollection },
false, CatalogQueryOptions.None);
_collectionNodes = collectionNodes;
}
public TeamProjectCollections(Uri tfsUri, ITfsCredentials tfsCredentials)
{
this._tfsUri = tfsUri;
this._tfsCredentials = tfsCredentials;
this._tfsTeamProjectCollection = TfsTeamProjectCollectionFactory.GetTeamProjectCollection(tfsUri, this._tfsCredentials);
this._tfsConfigurationServer = this._tfsTeamProjectCollection.GetConfigurationServer();
this._registration = (IRegistration)this._tfsTeamProjectCollection.GetService(typeof(IRegistration));
this._teamProjectCollectionService = this._tfsConfigurationServer.GetService<ITeamProjectCollectionService>();
}
/// <summary>
/// The get catalog nodes.
/// </summary>
/// <param name="uri">
/// The uri.
/// </param>
/// <returns>
/// The <see cref="List"/>.
/// </returns>
private List <CatalogNode> GetCatalogNodes(Uri uri, ICredentials cred, bool anotherUser)
{
List <CatalogNode> catalogNodes = null;
try
{
connectUri = uri;
TfsClientCredentials tfsClientCredentials;
if (anotherUser)
{
if (connectUri.ToString().Contains(".visualstudio.com"))
{
tfsClientCredentials = new TfsClientCredentials(false);
}
else
{
Microsoft.TeamFoundation.Client.WindowsCredential wcred = new Microsoft.TeamFoundation.Client.WindowsCredential(false);
tfsClientCredentials = new TfsClientCredentials(wcred);
}
}
else
{
if (connectUri.ToString().Contains(".visualstudio.com"))
{
tfsClientCredentials = new TfsClientCredentials();
}
else
{
Microsoft.TeamFoundation.Client.WindowsCredential wcred = new Microsoft.TeamFoundation.Client.WindowsCredential(true);
tfsClientCredentials = new TfsClientCredentials(wcred);
}
}
using (TfsConfigurationServer serverConfig = new TfsConfigurationServer(uri, tfsClientCredentials))
{
serverConfig.Authenticate();
serverConfig.EnsureAuthenticated();
if (serverConfig.HasAuthenticated)
{
Credential = serverConfig.Credentials;
catalogNodes = serverConfig.CatalogNode.QueryChildren(new[] { CatalogResourceTypes.ProjectCollection }, false, CatalogQueryOptions.None).OrderBy(f => f.Resource.DisplayName).ToList();
}
}
}
catch (TeamFoundationServiceUnavailableException ex)
{
MessageBox.Show(ResourceHelper.GetResourceString("MSG_TFS_SERVER_IS_INACCESSIBLE") + "\n" + uri.OriginalString, ResourceHelper.GetResourceString("ERROR_TEXT"), MessageBoxButton.OK, MessageBoxImage.Error);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, ResourceHelper.GetResourceString("ERROR_TEXT"), MessageBoxButton.OK, MessageBoxImage.Error);
return(catalogNodes);
}
return(catalogNodes);
}
public MyTfsServer(CiEntryPointSetting ciEntryPointSetting)
{
try {
_tfsConfigurationServer = GetTfsConfigurationServer(ciEntryPointSetting.Url, ciEntryPointSetting.UserName, ciEntryPointSetting.GetPassword());
_tfsConfigurationServer.EnsureAuthenticated();
} catch (TeamFoundationServiceUnavailableException ex) {
_log.Debug(ex);
throw new ServerUnavailableException(ex.Message, ex);
}
}
public MyTfsServer(CiEntryPointSetting ciEntryPointSetting)
{
try {
_tfsConfigurationServer = GetTfsConfigurationServer(ciEntryPointSetting.Url, ciEntryPointSetting.UserName, ciEntryPointSetting.GetPassword());
_tfsConfigurationServer.EnsureAuthenticated();
} catch (TeamFoundationServiceUnavailableException ex) {
_log.Debug(ex);
throw new ServerUnavailableException(ex.Message, ex);
}
}
public static void ConnectTFServer(TFSCmdletBase cmdlet, string url, ICredentials credentials)
{
try
{
Uri uri =
new Uri(url);
TfsConfigurationServer tfsServer =
new TfsConfigurationServer(
uri,
credentials);
cmdlet.WriteVerbose(
cmdlet,
"Connected, checking the connection");
try {
tfsServer.EnsureAuthenticated();
}
catch (Exception eTfsServerConnected) {
cmdlet.WriteError(
cmdlet,
"Failed to connect to server '" +
url +
"'." +
eTfsServerConnected.Message,
"FailedToConnect",
ErrorCategory.InvalidResult,
true);
}
CurrentData.CurrentServer = tfsServer;
cmdlet.WriteVerbose(cmdlet,
"Connected to: '" +
url +
"'");
cmdlet.WriteObject(cmdlet, tfsServer);
}
// catch (TeamFoundationServerUnauthorizedException ex)
// {
// // handle access denied
// }
// catch (TeamFoundationServiceUnavailableException ex)
// {
// // handle service unavailable
// }
catch (WebException ex)
{
// handle other web exception
}
}
private static CollectionInformation BuildCollectionInformation(TfsConfigurationServer server, string collectionName)
{
var sqlServer = GetTfsSqlServerInstance(server);
var connectionStringBuilder = new SqlConnectionStringBuilder
{
DataSource = sqlServer,
IntegratedSecurity = true,
InitialCatalog = "Tfs_" + collectionName
};
return new CollectionInformation
{
Name = collectionName,
ConnectionString = connectionStringBuilder.ConnectionString,
VirtualDir = string.Format("~/{0}/", collectionName)
};
}
public static void ResetCollection(string testCollectionName, string databaseBackupFile, bool cloneCollection)
{
const string testServerUri = "http://localhost:8080/tfs";
Assert.IsTrue(File.Exists(databaseBackupFile), "Collection database backup not found at '{0}'", databaseBackupFile);
var server = new TfsConfigurationServer(new Uri(testServerUri));
var collectionInfo = DetachCollectionWithInformation(server, testCollectionName)
?? BuildCollectionInformation(server, testCollectionName);
RestoreDatabase(collectionInfo, databaseBackupFile);
var attachedCollection = AttachCollection(server, collectionInfo, cloneCollection);
Assert.AreEqual(TeamFoundationServiceHostStatus.Started, attachedCollection.State, "Collection not started");
}
public void ConnectToTFS(Uri serverUri, string userName)
{
baseUserConnection = new TfsConfigurationServer(serverUri);
// Get the identity management service
IIdentityManagementService ims = baseUserConnection.GetService<IIdentityManagementService>();
identity = ims.ReadIdentity(IdentitySearchFactor.AccountName, userName, MembershipQuery.None, ReadIdentityOptions.None);
impersonatedConnection = new TfsConfigurationServer(serverUri, identity.Descriptor);
collectionNodes = impersonatedConnection.CatalogNode.QueryChildren(
new[] { CatalogResourceTypes.ProjectCollection },
false, CatalogQueryOptions.None);
if (identity != null)
fullName = identity.DisplayName;
}
private static TfsTeamProjectCollection GetProjectCollection(TfsConfigurationServer configurationServer)
{
// Get the catalog of team project collections
ReadOnlyCollection<CatalogNode> collectionNodes = configurationServer.CatalogNode.QueryChildren(
new[] { CatalogResourceTypes.ProjectCollection },
false, CatalogQueryOptions.None);
foreach (CatalogNode collectionNode in collectionNodes)
{
if (collectionNode.Resource.DisplayName == projectCollectionName)
{
Guid collectionId = new Guid(collectionNode.Resource.Properties["InstanceId"]);
return configurationServer.GetTeamProjectCollection(collectionId);
}
}
return null;
}
public TfsConfigurationServer GetTfsServer()
{
TfsConfigurationServer server = null;
try
{
var tfsUri = new Uri(_configurationTfsService.Uri);
var credentials = new TfsClientCredentials(new WindowsCredential(new NetworkCredential(_configurationTfsService.Username, _configurationTfsService.Password)));
server = new TfsConfigurationServer(tfsUri, credentials);
server.EnsureAuthenticated();
}
catch (Exception e)
{
LogService.WriteError(e);
throw;
}
return server;
}
public bool CanConnect(Uri tfsUri, NetworkCredential credentials)
{
Guard.NotNull(tfsUri, credentials);
bool canConnect;
using (var server = new TfsConfigurationServer(tfsUri, credentials))
{
try
{
server.EnsureAuthenticated();
canConnect = true;
}
catch (Exception)
{
canConnect = false;
}
}
return canConnect;
}
void DoStuffForSpecificCatalog(TfsConfigurationServer configurationServer,CatalogNode collectionNode)
{
// Use the InstanceId property to get the team project collection
Guid collectionId = new Guid(collectionNode.Resource.Properties["InstanceId"]);
TfsTeamProjectCollection teamProjectCollection = configurationServer.GetTeamProjectCollection(collectionId);
GetChangesets(teamProjectCollection);
// Print the name of the team project collection
Console.WriteLine("Collection: " + teamProjectCollection.Name);
// Get a catalog of team projects for the collection
ReadOnlyCollection<CatalogNode> projectNodes = collectionNode.QueryChildren(
new[] { CatalogResourceTypes.TeamProject },
false, CatalogQueryOptions.None);
// List the team projects in the collection
foreach (CatalogNode projectNode in projectNodes)
{
Console.WriteLine(" Team Project: " + projectNode.Resource.DisplayName);
}
}
public bool CanConnect(Uri tfsUri)
{
Guard.NotNull(tfsUri);
bool canConnect;
using (var server = new TfsConfigurationServer(tfsUri))
{
try
{
server.Authenticate();
canConnect = server.HasAuthenticated;
}
catch (Exception)
{
canConnect = false;
}
}
return canConnect;
}
public override void OnActionExecuting(HttpActionContext actionContext)
{
bool fromCookie = false;
var userDataPrincipal = HttpContext.Current.User as UserDataPrincipal;
if (userDataPrincipal == null)
{
userDataPrincipal = UserDataPrincipal.InitFromHeaders(actionContext.Request.Headers);
}
if (userDataPrincipal == null)
{
userDataPrincipal = UserDataPrincipal.InitFromAuthCookie(actionContext.Request.Headers);
fromCookie = true;
}
if (userDataPrincipal == null)
{
SetUnauthorizedResponse(actionContext);
return;
}
try
{
var configUri = new Uri(userDataPrincipal.TfsUrl);
var provider = userDataPrincipal.GetCredentialsProvider();
var tfsConfigServer = new TfsConfigurationServer(configUri, provider.GetCredentials(null, null), provider);
tfsConfigServer.EnsureAuthenticated();
HttpContext.Current.Items["TFS_CONFIG_SERVER"] = tfsConfigServer;
}
catch (TeamFoundationServerUnauthorizedException ex)
{
SetUnauthorizedResponse(actionContext, ex.Message, fromCookie);
return;
}
HttpContext.Current.User = userDataPrincipal;
base.OnActionExecuting(actionContext);
}
private IEnumerable<BuildInfoDto> GetBuildInfoDtosPerTeamProject(CatalogNode teamProjectCollectionNode,
TfsConfigurationServer tfsServer, DateTime filterDate)
{
var buildInfoDtos = new List<BuildInfoDto>();
try
{
// Use the InstanceId property to get the team project collection
var collectionId = new Guid(teamProjectCollectionNode.Resource.Properties["InstanceId"]);
var teamProjectCollection = tfsServer.GetTeamProjectCollection(collectionId);
var buildServer = (IBuildServer)teamProjectCollection.GetService(typeof(IBuildServer));
var testService = teamProjectCollection.GetService<ITestManagementService>();
// Get a catalog of team projects for the collection
var teamProjectNodes = teamProjectCollectionNode.QueryChildren(
new[] { CatalogResourceTypes.TeamProject },
false, CatalogQueryOptions.None);
// List the team projects in the collection
Parallel.ForEach(teamProjectNodes, teamProjectNode =>
{
var buildDefinitionList =
new List<IBuildDefinition>(buildServer.QueryBuildDefinitions(teamProjectNode.Resource.DisplayName));
lock (buildInfoDtos)
{
buildInfoDtos.AddRange(GetBuildInfoDtosPerBuildDefinition(buildDefinitionList, buildServer,
teamProjectNode,
teamProjectCollection, testService, filterDate));
}
});
}
catch (Exception e)
{
LogService.WriteError(e);
throw;
}
return buildInfoDtos;
}
public IEnumerable<Node> GetTfsProjects(TfsConnection conn)
{
var cols = new List<Node>();
var configServer = new TfsConfigurationServer(
new Uri(conn.TfsUrl),
new NetworkCredential(conn.Username, conn.Password, conn.Domain));
configServer.Authenticate();
var catalog = configServer.CatalogNode;
var tpcNodes = catalog.QueryChildren(
new Guid[] { CatalogResourceTypes.ProjectCollection },
false, CatalogQueryOptions.None);
foreach (var tpcNode in tpcNodes)
{
Node nd = new Node();
Guid tpcId = new Guid(tpcNode.Resource.Properties["InstanceId"]);
nd.Properties.Add(new Item("guid", tpcId.ToString()));
nd.Name = tpcNode.Resource.DisplayName;
cols.Add(nd);
var tpc = configServer.GetTeamProjectCollection(tpcId);
// Get catalog of tp = 'Team Projects' for the tpc = 'Team Project Collection'
var tpNodes = tpcNode.QueryChildren(
new Guid[] { CatalogResourceTypes.TeamProject },
false, CatalogQueryOptions.None);
foreach (var p in tpNodes)
{
var ndProj = new Node();
ndProj.Name = p.Resource.DisplayName;
nd.Children.Add(ndProj);
}
}
return cols;
/*
WorkItemStore workItemStore = (WorkItemStore)collection.GetService(typeof(WorkItemStore));
string qry = "SELECT [Title] From WorkItems Where [Work Item Type] = 'Bug' " +
" AND [Iteration Path] = 'AML_Module\\Release 3\\Sprint 4' AND [Team Project]='AML_Module'";
var res = workItemStore.Query(qry);
foreach (var wi in res)
{
string s = wi.ToString();
}*/
}
private static CollectionInformation DetachCollectionWithInformation(TfsConfigurationServer server, string collectionName)
{
var collectionService = server.GetService<ITeamProjectCollectionService>();
var collection = collectionService.GetCollections()
.FirstOrDefault(c => c.Name.Equals(collectionName, StringComparison.OrdinalIgnoreCase));
if (collection == null) return null;
string connectionString;
var jobDetail = collectionService.QueueDetachCollection(collection, null, null, out connectionString);
var detachedCollection = collectionService.WaitForCollectionServicingToComplete(jobDetail);
return new CollectionInformation
{
Name = detachedCollection.Name,
ConnectionString = connectionString,
VirtualDir = detachedCollection.VirtualDirectory
};
}
public void createConfigurationServer(Uri uri)
{
TfsConfigurationServer configurationServer =
TfsConfigurationServerFactory.GetConfigurationServer(uri);
_configurationServer = configurationServer;
}
public void createCatalogTeamProjectCollections(TfsConfigurationServer cs)
{
// Get the catalog of team project collections
ReadOnlyCollection<CatalogNode> collectionNodes = cs.CatalogNode.QueryChildren(
new[] { CatalogResourceTypes.ProjectCollection },
false, CatalogQueryOptions.None);
_collectionNodes = collectionNodes;
}
private static async Task<bool> CanLogIn(string username, string password, string uri, string configType)
{
bool response = false;
HttpClientHandler httpClientHandler = null;
// VSO check
if (configType == "VSO")
{
using (var client = CreateAuthenticationClient(uri, username, password))
{
client.BaseAddress = new Uri(uri);
Debug.WriteLine("Code: " + client.GetAsync("").Result.StatusCode);
response = client.GetAsync("").Result.StatusCode == HttpStatusCode.OK;
}
}
// TFS check
else if (configType == "TFS")
{
var credentials = new TfsClientCredentials(new WindowsCredential(new NetworkCredential(username, password)));
var server = new TfsConfigurationServer(new Uri(uri), credentials);
try
{
server.EnsureAuthenticated();
}
catch (TeamFoundationServerUnauthorizedException e)
{
return false;
}
response = server.HasAuthenticated;
}
return response;
}
private void Test()
{
TfsConfigurationServer configServer = new TfsConfigurationServer(
new Uri("https://cmr.wkglobal.com:8088/tfs"),
new NetworkCredential("Shafqat.Ahmed", "Hello123", "NA"));
configServer.Authenticate();
var catalog = configServer.CatalogNode;
var tpcNodes = catalog.QueryChildren(
new Guid[] { CatalogResourceTypes.ProjectCollection },
false, CatalogQueryOptions.None);
TfsTeamProjectCollection collection = null;
foreach (var tpcNode in tpcNodes)
{
Guid tpcId = new Guid(tpcNode.Resource.Properties["InstanceId"]);
var tpc = configServer.GetTeamProjectCollection(tpcId);
// Get catalog of tp = 'Team Projects' for the tpc = 'Team Project Collection'
var tpNodes = tpcNode.QueryChildren(
new Guid[] { CatalogResourceTypes.TeamProject },
false, CatalogQueryOptions.None);
foreach (var p in tpNodes)
{
if (p.Resource.DisplayName == "AML_Module")
{
collection = tpc;
}
}
}
WorkItemStore workItemStore = (WorkItemStore) collection.GetService(typeof(WorkItemStore));
string qry = "SELECT [Title] From WorkItems Where [Work Item Type] = 'Bug' " +
" AND [Iteration Path] = 'AML_Module\\Release 3\\Sprint 4' AND [Team Project]='AML_Module'";
var res = workItemStore.Query (qry);
foreach ( var wi in res)
{
string s = wi.ToString();
}
}
/// <summary>
/// The get catalog nodes.
/// </summary>
/// <param name="uri">
/// The uri.
/// </param>
/// <returns>
/// The <see cref="List"/>.
/// </returns>
private List<CatalogNode> GetCatalogNodes(Uri uri, ICredentials cred, bool anotherUser)
{
List<CatalogNode> catalogNodes = null;
try
{
connectUri = uri;
TfsClientCredentials tfsClientCredentials;
if (anotherUser)
{
tfsClientCredentials = new TfsClientCredentials(false);
ICredentialsProvider provider = new UICredentialsProvider();
WindowsCredential wcred = new WindowsCredential(cred, provider);
tfsClientCredentials.Windows = wcred;
//Credential = tfsClientCredentials;
}
else
{
tfsClientCredentials = new TfsClientCredentials(true);
ICredentialsProvider provider = new UICredentialsProvider();
WindowsCredential wcred = new WindowsCredential(cred, provider);
tfsClientCredentials.Windows = wcred;
}
using (TfsConfigurationServer serverConfig = new TfsConfigurationServer(uri, tfsClientCredentials))
{
serverConfig.EnsureAuthenticated();
if (serverConfig.HasAuthenticated)
{
Credential = serverConfig.Credentials;
catalogNodes = serverConfig.CatalogNode.QueryChildren(new[] { CatalogResourceTypes.ProjectCollection }, false, CatalogQueryOptions.None).OrderBy(f => f.Resource.DisplayName).ToList();
}
}
}
catch (TeamFoundationServiceUnavailableException ex)
{
MessageBox.Show(ResourceHelper.GetResourceString("MSG_TFS_SERVER_IS_INACCESSIBLE") + "\n" + uri.OriginalString, ResourceHelper.GetResourceString("ERROR_TEXT"), MessageBoxButton.OK, MessageBoxImage.Error);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, ResourceHelper.GetResourceString("ERROR_TEXT"), MessageBoxButton.OK, MessageBoxImage.Error);
return catalogNodes;
}
return catalogNodes;
}
public TfsTeamProjectCollection tfsTeamProjectCollectionConfigServer(TfsConfigurationServer configurationServer, Guid collectionId)
{
TfsTeamProjectCollection teamProjectCollection = configurationServer.GetTeamProjectCollection(collectionId);
return teamProjectCollection;
}
public void Connect(Uri tfsUri)
{
var projectCollectionName = tfsUri.Segments[tfsUri.Segments.Length - 1];
var tfsConnection = tfsUri.AbsoluteUri.Substring(0, tfsUri.AbsoluteUri.Length - projectCollectionName.Length);
m_configurationServer = TfsConfigurationServerFactory.GetConfigurationServer(new Uri(tfsConnection));
//m_configurationServer.Connect(ConnectOptions.IncludeServices);
CatalogNode configurationServerNode = m_configurationServer.CatalogNode;
// Query the children of the configuration server node for all of the team project collection nodes
ReadOnlyCollection<CatalogNode> tpcNodes = configurationServerNode.QueryChildren(
new Guid[] { CatalogResourceTypes.ProjectCollection },
false,
CatalogQueryOptions.None);
foreach (CatalogNode tpcNode in tpcNodes)
{
if (tpcNode.Resource.DisplayName.ToUpper() == GetWithoutTralingSlash(projectCollectionName).ToUpper())
{
Guid tpcId = new Guid(tpcNode.Resource.Properties["InstanceId"]);
TfsTeamProjectCollection tpc = m_configurationServer.GetTeamProjectCollection(tpcId);
m_versionControlServer = tpc.GetService<VersionControlServer>();
break;
}
}
if (m_versionControlServer == null)
{
throw new Exception(string.Format("Project collection name '{0}' not found",projectCollectionName));
}
}