public TfsSourceControlClient(string projectCollectionUrl, string userName, string password, string domain, ILogSink log)
{
var uri = new Uri(projectCollectionUrl, UriKind.Absolute);
if (string.IsNullOrEmpty(userName))
{
this.collection = TfsTeamProjectCollectionFactory.GetTeamProjectCollection(uri);
}
else
{
TfsClientCredentials credentials;
if (string.IsNullOrEmpty(domain))
{
credentials = new TfsClientCredentials(new BasicAuthCredential(new NetworkCredential(userName, password)));
}
else
{
credentials = new TfsClientCredentials(new WindowsCredential(new NetworkCredential(userName, password, domain)));
}
this.collection = new TfsTeamProjectCollection(uri, credentials);
}
this.log = log;
}
public static ITestManagementTeamProject GetProject(Uri tfsUri, string projectName, string username, string password)
{
try
{
Trace.TraceInformation($"Connecting to VSTS {tfsUri.AbsoluteUri}, Project: {projectName}");
var networkCredential = new NetworkCredential(username, password);
BasicAuthCredential basicCred = new BasicAuthCredential(networkCredential);
TfsClientCredentials tfsCred = new TfsClientCredentials(basicCred);
tfsCred.AllowInteractive = false;
TfsTeamProjectCollection projectsCollection = new TfsTeamProjectCollection(tfsUri, tfsCred);
ITestManagementService service = (ITestManagementService)projectsCollection.GetService(typeof(ITestManagementService));
ITestManagementTeamProject project = service.GetTeamProject(projectName);
Trace.TraceInformation($"project {projectName} found");
return(project);
}
catch (TestObjectNotFoundException)
{
Trace.TraceError($"Project {projectName} not found");
return(null);
}
catch (Exception ex)
{
Trace.TraceError(ex.Message);
return(null);
}
}
private TfsTeamProjectCollection GetTeamProjectCollection()
{
if (this.UseSystemCredentials)
{
var projectCollection = TfsTeamProjectCollectionFactory.GetTeamProjectCollection(this.BaseUri);
projectCollection.EnsureAuthenticated();
return(projectCollection);
}
else
{
TfsClientCredentials credentials;
if (string.IsNullOrEmpty(this.Domain))
{
credentials = new TfsClientCredentials(new BasicAuthCredential(new NetworkCredential(this.UserName, this.Password)));
}
else
{
credentials = new TfsClientCredentials(new WindowsCredential(new NetworkCredential(this.UserName, this.Password, this.Domain)));
}
var projectColleciton = new TfsTeamProjectCollection(this.BaseUri, credentials);
projectColleciton.EnsureAuthenticated();
return(projectColleciton);
}
}
// see http://msdn.microsoft.com/en-us/library/bb130306.aspx
public void Connect()
{
if (this.Credential != null && !string.IsNullOrWhiteSpace(this.Credential.UserName))
{
if (IsVSO(this.CollectionUrl))
{
// source http://blogs.msdn.com/b/buckh/archive/2013/01/07/how-to-connect-to-tf-service-without-a-prompt-for-liveid-credentials.aspx
BasicAuthCredential basicCred = new BasicAuthCredential(this.Credential);
TfsClientCredentials tfsCred = new TfsClientCredentials(basicCred);
tfsCred.AllowInteractive = false;
this.Collection = new TfsTeamProjectCollection(this.CollectionUrl, tfsCred);
}
else
{
this.Collection = new TfsTeamProjectCollection(this.CollectionUrl, this.Credential);
}//if
}
else
{
if (IsVSO(this.CollectionUrl))
{
throw new SecurityException("VSO requires user and password");
}
else
{
this.Collection = new TfsTeamProjectCollection(this.CollectionUrl);
}
}
this.Collection.EnsureAuthenticated();
}
private TfsTeamProjectCollection TfsConnect()
{
try
{
// Determine if local TFS or VSTS
if ((!AccountURL.ToLower().Contains("https")) || AccountURL.ToLower().Contains("8080"))
{
// Authenticate to on-premises TFS
TfsTeamProjectCollection tpc = new TfsTeamProjectCollection(new Uri(AccountURL));
tpc.EnsureAuthenticated();
return(tpc);
}
else
{
// Authenticate to VSTS
NetworkCredential netCred = new NetworkCredential(MicrosoftAccountAlias, MicrosoftAccountPassword);
BasicAuthCredential basicCred = new BasicAuthCredential(netCred);
TfsClientCredentials tfsCred = new TfsClientCredentials(basicCred);
tfsCred.AllowInteractive = false;
TfsTeamProjectCollection tpc = new TfsTeamProjectCollection(new Uri(AccountURL), tfsCred);
tpc.Authenticate();
return(tpc);
}
}
catch (Exception ex)
{
Console.WriteLine("Error: " + ex.Message);
throw;
}
}
public static TfsTeamProjectCollection GetTeamProjectCollection(Uri tfsCollectionUri, ITfsCredentials tfsCredentials)
{
TfsTeamProjectCollection result;
TfsClientCredentials credential = null;
if (tfsCredentials != null)
{
credential = tfsCredentials.GetCredentials();
}
else
{
if (Defaults.GetDefaultCredentials(tfsCollectionUri) != null)
{
credential = Defaults.GetDefaultCredentials(tfsCollectionUri).GetCredentials();
}
}
if (credential != null)
{
result = new TfsTeamProjectCollection(tfsCollectionUri, credential);
result.Connect(ConnectOptions.IncludeServices);
}
else
{
result = new TfsTeamProjectCollection(tfsCollectionUri);
}
return(result);
}
private TfsTeamProjectCollection ConnectAndCacheCredentials()
{
Uri serverUri = null;
try
{
serverUri = new Uri(tbServer.Text);
}
catch (FormatException ex)
{
MessageBox.Show(this, "Invalid server URL: " + ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return(null);
}
TfsClientCredentials cred = GetCredentials(serverUri);
TfsTeamProjectCollection cfgServer = new TfsTeamProjectCollection(serverUri, cred);
try
{
cfgServer.Connect(ConnectOptions.IncludeServices);
return(cfgServer);
}
catch (Exception ex)
{
MessageBox.Show(this, "Cannot login: "******"Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return(null);
}
}
/// <summary>
/// Get the parameters of the test case
/// </summary>
/// <param name="testCaseId">Test case id (work item id#) displayed into TFS</param>
/// <returns>Returns the test case parameters in datatable format. If there are no parameters then it will return null</returns>
public static DataTable GetTestCaseParameters(int testCaseId)
{
ITestManagementService TestMgrService;
ITestCase TestCase = null;
DataTable TestCaseParameters = null;
NetworkCredential netCred = new NetworkCredential(
Constants.TFS_USER_NAME,
Constants.TFS_USER_PASSWORD);
BasicAuthCredential basicCred = new BasicAuthCredential(netCred);
TfsClientCredentials tfsCred = new TfsClientCredentials(basicCred);
tfsCred.AllowInteractive = false;
TfsTeamProjectCollection teamProjectCollection = new TfsTeamProjectCollection(
new Uri(Constants.TFS_URL),
tfsCred);
teamProjectCollection.Authenticate();
TestMgrService = teamProjectCollection.GetService<ITestManagementService>();
TestCase = TestMgrService.GetTeamProject(Constants.TFS_PROJECT_NAME).TestCases.Find(testCaseId);
if (TestCase != null)
{
if (TestCase.Data.Tables.Count > 0)
{
TestCaseParameters = TestCase.Data.Tables[0];
}
}
return TestCaseParameters;
}
/// <inheritdoc/>
public async Task ConfigureAsync(TfsServiceProviderConfiguration configuration)
{
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
if(string.IsNullOrEmpty(configuration.WorkItemType))
{
throw new ArgumentNullException(nameof(configuration.WorkItemType));
}
this.logger.Debug("Configure of TfsSoapServiceProvider started...");
var networkCredential = new NetworkCredential(configuration.Username, configuration.Password);
var tfsClientCredentials = new TfsClientCredentials(new BasicAuthCredential(networkCredential)) { AllowInteractive = false };
var tfsProjectCollection = new TfsTeamProjectCollection(this.serviceUri, tfsClientCredentials);
this.workItemType = configuration.WorkItemType;
tfsProjectCollection.Authenticate();
tfsProjectCollection.EnsureAuthenticated();
this.logger.Debug("Authentication successful for {serviceUri}.", this.serviceUri.AbsoluteUri);
await Task.Run(
() =>
{
this.logger.Debug("Fetching workitem for id {parentWorkItemId}.", configuration.ParentWorkItemId);
this.workItemStore = new WorkItemStore(tfsProjectCollection);
this.parentWorkItem = this.workItemStore.GetWorkItem(configuration.ParentWorkItemId);
this.logger.Debug("Found parent work item '{title}'.", this.parentWorkItem.Title);
});
this.logger.Verbose("Tfs service provider configuration complete.");
}
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);
}
protected TfsConfigurationServer GetServer()
{
ICredentials credentials = new NetworkCredential(Principal.Login, Principal.Password, Principal.Domain);
TfsClientCredentials tfsCredentials = new TfsClientCredentials(new WindowsCredential(credentials), new SimpleWebTokenCredential(null, null), false);
return(new TfsConfigurationServer(new Uri(Principal.Url), tfsCredentials));
}
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);
}
public ConnectionResult Connect(string host, string user, string password)
{
string.Format("Connecting to TFS '{0}'", host).Debug();
try
{
_projectCollectionUri = new Uri(host);
}
catch (UriFormatException ex)
{
string.Format("Invalid project URL '{0}': {1}", host, ex.Message).Error();
return ConnectionResult.InvalidUrl;
}
//This is used to query TFS for new WorkItems
try
{
if (_projectCollectionNetworkCredentials == null)
{
_projectCollectionNetworkCredentials = new NetworkCredential(user, password);
// if this is hosted TFS then we need to authenticate a little different
// see this for setup to do on visualstudio.com site:
// http://blogs.msdn.com/b/buckh/archive/2013/01/07/how-to-connect-to-tf-service-without-a-prompt-for-liveid-credentials.aspx
if (_projectCollectionUri.Host.ToLowerInvariant().Contains(".visualstudio.com"))
{
if (_basicAuthCredential == null)
_basicAuthCredential = new BasicAuthCredential(_projectCollectionNetworkCredentials);
if (_tfsClientCredentials == null)
{
_tfsClientCredentials = new TfsClientCredentials(_basicAuthCredential);
_tfsClientCredentials.AllowInteractive = false;
}
}
if (_projectCollection == null)
{
_projectCollection = _tfsClientCredentials != null
? new TfsTeamProjectCollection(_projectCollectionUri, _tfsClientCredentials)
: new TfsTeamProjectCollection(_projectCollectionUri, _projectCollectionNetworkCredentials);
}
_projectCollectionWorkItemStore = new WorkItemStore(_projectCollection);
}
if (_projectCollectionWorkItemStore == null)
_projectCollectionWorkItemStore = new WorkItemStore(_projectCollection);
}
catch (Exception e)
{
string.Format("Failed to connect: {0}", e.Message).Error(e);
return ConnectionResult.FailedToConnect;
}
return ConnectionResult.Success;
}
public ConnectionResult Connect(string host, string user, string password)
{
string.Format("Connecting to TFS '{0}'", host).Debug();
try
{
_projectCollectionUri = new Uri(host);
}
catch (UriFormatException ex)
{
string.Format("Invalid project URL '{0}': {1}", host, ex.Message).Error();
return(ConnectionResult.InvalidUrl);
}
//This is used to query TFS for new WorkItems
try
{
if (_projectCollectionNetworkCredentials == null)
{
_projectCollectionNetworkCredentials = new NetworkCredential(user, password);
// if this is hosted TFS then we need to authenticate a little different
// see this for setup to do on visualstudio.com site:
// http://blogs.msdn.com/b/buckh/archive/2013/01/07/how-to-connect-to-tf-service-without-a-prompt-for-liveid-credentials.aspx
if (_projectCollectionUri.Host.ToLowerInvariant().Contains(".visualstudio.com"))
{
if (_basicAuthCredential == null)
{
_basicAuthCredential = new BasicAuthCredential(_projectCollectionNetworkCredentials);
}
if (_tfsClientCredentials == null)
{
_tfsClientCredentials = new TfsClientCredentials(_basicAuthCredential);
_tfsClientCredentials.AllowInteractive = false;
}
}
if (_projectCollection == null)
{
_projectCollection = _tfsClientCredentials != null
? new TfsTeamProjectCollection(_projectCollectionUri, _tfsClientCredentials)
: new TfsTeamProjectCollection(_projectCollectionUri, _projectCollectionNetworkCredentials);
}
_projectCollectionWorkItemStore = new WorkItemStore(_projectCollection);
}
if (_projectCollectionWorkItemStore == null)
{
_projectCollectionWorkItemStore = new WorkItemStore(_projectCollection);
}
}
catch (Exception e)
{
string.Format("Failed to connect: {0}", e.Message).Error(e);
return(ConnectionResult.FailedToConnect);
}
return(ConnectionResult.Success);
}
public TfsTeamProjectCollection Authorize(IDictionary<string, string> authorizeInformation)
{
var tfsCredentials = new TfsClientCredentials();
TfsTeamProjectCollection tfs = new TfsTeamProjectCollection(new Uri(this.tfsUri));
tfs.Authenticate();
return tfs;
}
public void Connect()
{
NetworkCredential netCred = new NetworkCredential(m_username, m_password);
BasicAuthCredential basicCred = new BasicAuthCredential(netCred);
TfsClientCredentials tfsCred = new TfsClientCredentials(basicCred);
m_tpc = new TfsTeamProjectCollection(new Uri(m_url), tfsCred);
}
public TFS(Uri server, NetworkCredential credential)
{
BasicAuthCredential basicCred = new BasicAuthCredential(credential);
var tfsCred = new TfsClientCredentials(basicCred);
tfsCred.AllowInteractive = false;
_connection.ClientCredentials = tfsCred;
Initialize(server, tfsCred);
}
/// <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 TfsClient(string url)
{
if (String.IsNullOrEmpty(url))
throw new ArgumentNullException(nameof(url));
var credentials = new TfsClientCredentials();
var collection = new TfsTeamProjectCollection(new Uri(url), credentials);
m_server = collection.GetService<VersionControlServer>();
}
public static void Main(string[] args)
{
var tfsUrl = "http://rufc-devbuild.cneu.cnwk:8080/tfs/sed";
//var tfs = new TfsClient(tfsUrl);
var credentials = new TfsClientCredentials();
var collection = new TfsTeamProjectCollection(new Uri(tfsUrl), credentials);
var server = collection.GetService<VersionControlServer>();
var test = GetChildItems(server);
}
public void Initialize(BuildConfig config)
{
NetworkCredential credentials = new NetworkCredential(config.Username, config.Password);
BasicAuthCredential basicCredentials = new BasicAuthCredential(credentials);
TfsClientCredentials cred = new TfsClientCredentials(basicCredentials);
cred.AllowInteractive = false;
tpc = new TfsTeamProjectCollection(new Uri(config.SourceUrl + "/" + config.Collection),cred);
tpc.Authenticate();
this.Server = tpc.GetService<Microsoft.TeamFoundation.VersionControl.Client.VersionControlServer>();
}
public TfsClient(string url)
{
if (String.IsNullOrEmpty(url))
{
throw new ArgumentNullException("url");
}
var credentials = new TfsClientCredentials();
var collection = new TfsTeamProjectCollection(new Uri(url), credentials);
m_server = collection.GetService <VersionControlServer>();
}
/// <summary>
/// Conecta a un servidor
/// </summary>
public void Connect()
{
WindowsCredential objWindowsCredentials = new WindowsCredential(new NetworkCredential(User.Login, User.Pasword));
TfsClientCredentials objCredentials = new TfsClientCredentials(objWindowsCredentials);
// Cierra la conexión
Close();
// Crea una conexión
tfsTeamProject = new TfsTeamProjectCollection(Server.FullUrl, objCredentials);
// Autentifica
tfsTeamProject.Authenticate();
}
/// <summary>
/// Prevents a default instance of the <see cref="TfsProjects"/> class from being created.
/// This might change if the project name can be optional.
/// </summary>
public TfsProjects(string tfsUri, string username, string password, string projectName = null)
{
NetworkCredential netCred = new NetworkCredential(username, password);
BasicAuthCredential basicCred = new BasicAuthCredential(netCred);
TfsClientCredentials tfsCred = new TfsClientCredentials(basicCred);
tfsCred.AllowInteractive = false;
ProjectCollection = new TfsTeamProjectCollection(new Uri(tfsUri), tfsCred);
ProjectCollection.Authenticate();
Store = new WorkItemStore(ProjectCollection);
ProjectName = projectName;
}
/// <summary>
/// Initializes a new instance of the <see cref="TfsProjects"/> class.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="projectName">Name of the project.</param>
public TfsProjects(ITfsContext context)
{
NetworkCredential netCred = new NetworkCredential(context.Username, context.Password);
BasicAuthCredential basicCred = new BasicAuthCredential(netCred);
TfsClientCredentials tfsCred = new TfsClientCredentials(basicCred);
tfsCred.AllowInteractive = false;
ProjectCollection = new TfsTeamProjectCollection(new Uri(context.Uri), tfsCred);
ProjectCollection.Authenticate();
Store = new WorkItemStore(ProjectCollection);
ProjectName = context.ProjectName;
}
public override void ExecuteCommand()
{
TfsClientCredentials cred = new TfsClientCredentials(new WindowsCredential(new NetworkCredential(UserName, Password)), true);
cred.AllowInteractive = true;
tfs = new TfsTeamProjectCollection(TfsTeamProjectCollection.GetFullyQualifiedUriForName(HostUrl), cred);
//Get data store that contains all workitems on a particular server
store = tfs.GetService <WorkItemStore>();
//Get particular Team Project
project = store.Projects[ProjectName];
Console.WriteLine("Connected to project: " + project.Name);
CreatereportForSupportRequestsByCategory();
CreatereportForSupportRequestSummary();
}
public override TfsTeamProjectCollection GetCollection(Uri tfsCollectionUri)
{
#if TFS2017
var tfsCred = new VssCredentials(
new VssBasicCredential(
new System.Net.NetworkCredential(this.username, this.password)));
#else
var tfsCred = new TfsClientCredentials(
new BasicAuthCredential(
new System.Net.NetworkCredential(this.username, this.password)));
tfsCred.AllowInteractive = false;
#endif
return(new TfsTeamProjectCollection(tfsCollectionUri, tfsCred));
}
internal static TfsClientCredentialsWrapper GetInstance()
{
var real = new TfsClientCredentials();
RealInstanceFactory(ref real);
var instance = (TfsClientCredentialsWrapper)TfsClientCredentialsWrapper.GetWrapper(real);
InstanceFactory(ref instance);
if (instance == null)
{
Assert.Inconclusive("Could not Create Test Instance");
}
return(instance);
}
private static TfsTeamProjectCollection ConnectToTfsCollection(
Uri endpoint,
TfsClientCredentials credentials)
{
var tfsServer = new TfsTeamProjectCollection(endpoint, credentials);
tfsServer.EnsureAuthenticated();
#if DEBUG
// The base class TfsConnection integrates various information about the connect with TFS (as well as ways to control that connection)
System.Diagnostics.Debug.Print($"Connected to {endpoint}");
System.Diagnostics.Debug.Print($"Authenticated: {tfsServer.AuthorizedIdentity.Descriptor.Identifier}");
#endif
return(tfsServer);
}
public static TfsTeamProjectCollection GetTeamProjectCollection(Uri collectionUri, out NetworkCredential credential)
{
string user = ConfigurationManager.AppSettings["TfsClientUser"];
string password = ConfigurationManager.AppSettings["TfsClientPassword"];
credential = new NetworkCredential(user, password);
BasicAuthCredential basicCred = new BasicAuthCredential(credential);
TfsClientCredentials tfsCred = new TfsClientCredentials(basicCred);
tfsCred.AllowInteractive = false;
TfsTeamProjectCollection teamProjectCollection = new TfsTeamProjectCollection(collectionUri, tfsCred);
teamProjectCollection.Authenticate();
return(teamProjectCollection);
}
/// <summary>
/// Prevents a default instance of the <see cref="TfsProjects"/> class from being created.
/// This might change if the project name can be optional.
/// </summary>
public TfsProjects(string tfsUri, string username, string password, string projectName = null)
{
NetworkCredential netCred = new NetworkCredential(username, password);
BasicAuthCredential basicCred = new BasicAuthCredential(netCred);
TfsClientCredentials tfsCred = new TfsClientCredentials(basicCred);
tfsCred.AllowInteractive = false;
ProjectCollection = new TfsTeamProjectCollection(new Uri(tfsUri), tfsCred);
ProjectCollection.Authenticate();
Store = new WorkItemStore(ProjectCollection);
ProjectName = projectName;
}
/// <summary>
/// Initializes a new instance of the <see cref="TfsProjects"/> class.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="projectName">Name of the project.</param>
public TfsProjects(ITfsContext context)
{
NetworkCredential netCred = new NetworkCredential(context.Username, context.Password);
BasicAuthCredential basicCred = new BasicAuthCredential(netCred);
TfsClientCredentials tfsCred = new TfsClientCredentials(basicCred);
tfsCred.AllowInteractive = false;
ProjectCollection = new TfsTeamProjectCollection(new Uri(context.Uri), tfsCred);
ProjectCollection.Authenticate();
Store = new WorkItemStore(ProjectCollection);
ProjectName = context.ProjectName;
}
internal static void CastNonGenericIEnumerable(TfsClientCredentials credentials)
{
using (TfsTeamProjectCollection projectCollection = new TfsTeamProjectCollection(
new Uri("https://dixin.visualstudio.com/DefaultCollection"), credentials))
{
const string wiql = "SELECT * FROM WorkItems WHERE [Work Item Type] = 'Bug' AND State != 'Closed'"; // WIQL does not support GROUP BY.
WorkItemStore workItemStore = (WorkItemStore)projectCollection.GetService(typeof(WorkItemStore));
WorkItemCollection workItems = workItemStore.Query(wiql); // WorkItemCollection implements IEnumerable.
IEnumerable <IGrouping <string, WorkItem> > workItemGroups =
from WorkItem workItem in workItems
group workItem by workItem.CreatedBy; // Group work items in local memory.
// ...
}
}
private void Initialize(Uri server, TfsClientCredentials credential)
{
_connection = TfsTeamProjectCollectionFactory.GetTeamProjectCollection(server);
if (credential != null)
{
_connection.ClientCredentials = credential;
}
_connection.EnsureAuthenticated();
_versionControlServer = _connection.GetService <VersionControlServer>();
_linkingService = _connection.GetService <ILinking>();
Url = server.AbsoluteUri;
}
/// <inheritdoc/>
public async Task ConfigureAsync(TfsServiceProviderConfiguration configuration)
{
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
if (string.IsNullOrEmpty(configuration.WorkItemType))
{
throw new ArgumentNullException(nameof(configuration.WorkItemType));
}
this.logger.Debug("Configure of TfsSoapServiceProvider started...");
var networkCredential = new NetworkCredential(configuration.Username, configuration.Password);
TfsClientCredentials tfsClientCredentials = new TfsClientCredentials(new BasicAuthCredential(networkCredential))
{
AllowInteractive = false
};
var tfsProjectCollection = new TfsTeamProjectCollection(this.serviceUri, tfsClientCredentials);
this.workItemType = configuration.WorkItemType;
try
{
tfsProjectCollection.Authenticate();
}
catch
{
tfsClientCredentials = new TfsClientCredentials(); // fall back to login page
tfsProjectCollection = new TfsTeamProjectCollection(this.serviceUri, tfsClientCredentials);
tfsProjectCollection.Authenticate();
}
tfsProjectCollection.EnsureAuthenticated();
this.logger.Debug("Authentication successful for {serviceUri}.", this.serviceUri.AbsoluteUri);
await Task.Run(
() =>
{
this.logger.Debug("Fetching workitem for id {parentWorkItemId}.", configuration.ParentWorkItemId);
this.workItemStore = new WorkItemStore(tfsProjectCollection);
this.parentWorkItem = this.workItemStore.GetWorkItem(configuration.ParentWorkItemId);
this.logger.Debug("Found parent work item '{title}'.", this.parentWorkItem.Title);
});
this.logger.Verbose("Tfs service provider configuration complete.");
}
protected override void OnCreateMockObjects()
{
base.OnCreateMockObjects();
MockCredentials = new Mock<ICredentials>();
Credentials = MockCredentials.Object;
BasicAuthCredential = new BasicAuthCredential(Credentials);
TfsClientCredentials = new TfsClientCredentials(BasicAuthCredential);
TfsClientCredentials.AllowInteractive = false;
MockProjectCollection = new Mock<TfsTeamProjectCollection>(new Uri("http://localhost"), Credentials);
ProjectCollection = MockProjectCollection.Object;
ProjectHyperlinkService = null;
WorkItemStore = null;
TFSUsers = new List<Microsoft.TeamFoundation.Server.Identity>();
}
public static TfsTeamProjectCollection GetTeamProjectCollection(Server server)
{
if (string.IsNullOrEmpty(server.UserName) || string.IsNullOrEmpty(server.Password))
{
return new TfsTeamProjectCollection(server.Uri);
}
var tfsCredentials = new TfsClientCredentials(new BasicAuthCredential(new NetworkCredential(server.UserName, server.Password)))
{
AllowInteractive = false
};
var teamProjectCollection = new TfsTeamProjectCollection(server.Uri, tfsCredentials);
return teamProjectCollection;
}
public TfsTeamProjectCollection Authorize(IDictionary<string, string> authorizeInformation)
{
NetworkCredential netCred = new NetworkCredential(
"*****@*****.**",
"yourbasicauthpassword");
BasicAuthCredential basicCred = new BasicAuthCredential(netCred);
TfsClientCredentials tfsCred = new TfsClientCredentials(basicCred);
tfsCred.AllowInteractive = false;
TfsTeamProjectCollection tpc = new TfsTeamProjectCollection(
new Uri("https://YourAccountName.visualstudio.com/DefaultCollection"),
tfsCred);
tpc.Authenticate();
return tpc;
}
private static TfsTeamProjectCollection GetProjectCollection()
{
var networkCredential = new NetworkCredential(tfsServiceProviderTestUser, tfsServiceProviderTestPassword);
var tfsClientCredentials = new TfsClientCredentials(new BasicAuthCredential(networkCredential))
{
AllowInteractive = false
};
var tfsProjectCollection = new TfsTeamProjectCollection(
new Uri(tfsServiceProviderUri),
tfsClientCredentials);
tfsProjectCollection.Authenticate();
return(tfsProjectCollection);
}
protected override void OnCreateMockObjects()
{
base.OnCreateMockObjects();
MockCredentials = new Mock <ICredentials>();
Credentials = MockCredentials.Object;
BasicAuthCredential = new BasicAuthCredential(Credentials);
TfsClientCredentials = new TfsClientCredentials(BasicAuthCredential);
TfsClientCredentials.AllowInteractive = false;
MockProjectCollection = new Mock <TfsTeamProjectCollection>(new Uri("http://localhost"), Credentials);
ProjectCollection = MockProjectCollection.Object;
ProjectHyperlinkService = null;
WorkItemStore = null;
TFSUsers = new List <Microsoft.TeamFoundation.Server.Identity>();
}
public override TfsTeamProjectCollection GetCollection(Uri tfsCollectionUri)
{
// username is not important, we use it to identify ourselves to callee
#if TFS2017
var tfsCred = new VssCredentials(
new VssBasicCredential(
new System.Net.NetworkCredential(
"tfsaggregator2-webhooks", this.personalToken)));
#else
var tfsCred = new TfsClientCredentials(
new BasicAuthCredential(
new System.Net.NetworkCredential(
"tfsaggregator2-webhooks", this.personalToken)));
tfsCred.AllowInteractive = false;
#endif
return(new TfsTeamProjectCollection(tfsCollectionUri, tfsCred));
}
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 static void MyClassInitialize(TestContext testContext)
{
NetworkCredential networkCredential = new NetworkCredential(@"*****@*****.**","zippyd00da");
BasicAuthToken basicAuthToken = new BasicAuthToken(networkCredential);
BasicAuthCredential basicAuthCredential = new BasicAuthCredential(basicAuthToken);
TfsClientCredentials tfsClientCredentials = new TfsClientCredentials(basicAuthCredential);
tfsClientCredentials.AllowInteractive = false;
server2 = new TfsTeamProjectCollection(new Uri("https://rdavis.visualstudio.com/DefaultCollection"), tfsClientCredentials);
server2.Connect(Microsoft.TeamFoundation.Framework.Common.ConnectOptions.None);
server2.EnsureAuthenticated();
server2.Authenticate();
if (!server2.HasAuthenticated)
throw new InvalidOperationException("Not authenticated");
store = new WorkItemStore(server2);
}
public Tfs(IBoardSubscriptionManager subscriptions,
IConfigurationProvider<Configuration> configurationProvider,
ILocalStorage<AppSettings> localStorage,
ILeanKitClientFactory leanKitClientFactory,
ICredentials projectCollectionNetworkCredentials,
BasicAuthCredential basicAuthCredential,
TfsClientCredentials tfsClientCredentials,
TfsTeamProjectCollection projectCollection,
TswaClientHyperlinkService projectHyperlinkService,
WorkItemStore projectCollectionWorkItemStore,
List<Microsoft.TeamFoundation.Server.Identity> tfsUsers)
: base(subscriptions, configurationProvider, localStorage, leanKitClientFactory)
{
_projectCollectionNetworkCredentials = projectCollectionNetworkCredentials;
_projectCollection = projectCollection;
_projectHyperlinkService = projectHyperlinkService;
_projectCollectionWorkItemStore = projectCollectionWorkItemStore;
_basicAuthCredential = basicAuthCredential;
_tfsClientCredentials = tfsClientCredentials;
_tfsUsers = tfsUsers;
}
public override void Init()
{
if (Configuration == null) return;
try
{
_projectCollectionUri = new Uri(Configuration.Target.Url);
}
catch (UriFormatException ex)
{
Log.Error("Error connection to TFS. Ensure the Target Host is a valid URL: {0} - {1}", ex.GetType(), ex.Message);
return;
}
Log.Info("Connecting to TFS...");
//This is used to query TFS for new WorkItems
try
{
if (_projectCollectionNetworkCredentials == null)
{
// if this is hosted TFS then we need to authenticate a little different
// see this for setup to do on visualstudio.com site:
// http://blogs.msdn.com/b/buckh/archive/2013/01/07/how-to-connect-to-tf-service-without-a-prompt-for-liveid-credentials.aspx
if (_projectCollectionUri.Host.ToLowerInvariant().Contains(".visualstudio.com"))
{
_projectCollectionNetworkCredentials = new NetworkCredential(Configuration.Target.User, Configuration.Target.Password);
if (_basicAuthCredential == null)
_basicAuthCredential = new BasicAuthCredential(_projectCollectionNetworkCredentials);
if (_tfsClientCredentials == null)
{
_tfsClientCredentials = new TfsClientCredentials(_basicAuthCredential);
_tfsClientCredentials.AllowInteractive = false;
}
if (_projectCollection == null)
{
_projectCollection = new TfsTeamProjectCollection(_projectCollectionUri, _tfsClientCredentials);
_projectHyperlinkService = _projectCollection.GetService<TswaClientHyperlinkService>();
_projectCollectionWorkItemStore = new WorkItemStore(_projectCollection);
}
}
else
{
// Check for common NTLM/Windows Auth convention
// ("DOMAIN\Username") in User input and separate
// domain from username:
string domain = null;
string username = null;
if (Configuration.Target.User.Contains("\\"))
{
string[] domainUser = Configuration.Target.User.Split('\\');
domain = domainUser[0];
username = domainUser[1];
}
if (domain != null)
{
Log.Debug("Logging in using NTLM auth (using domain: {0}, username: {1})", domain, username);
_projectCollectionNetworkCredentials = new NetworkCredential(username, Configuration.Target.Password, domain);
}
else
{
_projectCollectionNetworkCredentials = new NetworkCredential(Configuration.Target.User, Configuration.Target.Password);
}
if (_projectCollection == null)
{
_projectCollection = new TfsTeamProjectCollection(_projectCollectionUri, _projectCollectionNetworkCredentials);
_projectHyperlinkService = _projectCollection.GetService<TswaClientHyperlinkService>();
_projectCollectionWorkItemStore = new WorkItemStore(_projectCollection);
}
}
}
if (_projectCollectionWorkItemStore == null)
_projectCollectionWorkItemStore = new WorkItemStore(_projectCollection);
if (_projectCollection != null && _tfsUsers == null)
LoadTfsUsers();
}
catch (Exception e)
{
Log.Error("Error connecting to TFS: {0} - {1}", e.GetType(), e.Message);
}
// per project, if exclusions are defined, build type filter to exclude them
foreach (var mapping in Configuration.Mappings)
{
mapping.ExcludedTypeQuery = "";
if (mapping.Excludes == null) continue;
var excludedTypes = mapping.Excludes.Split(',');
Log.Debug("Excluded WorkItemTypes for [{0}]:", mapping.Identity.Target);
foreach (var type in excludedTypes)
{
var trimmedType = type.Trim();
Log.Debug(">> [{0}]", trimmedType);
mapping.ExcludedTypeQuery += String.Format(" AND [System.WorkItemType] <> '{0}'", trimmedType);
}
}
}
private static bool CheckTfsServerPath(string path, TfsClientCredentials credential)
{
TfsConfigurationServer tfsServer = null;
try
{
tfsServer = new TfsConfigurationServer(new Uri(path), credential);
tfsServer.Connect(ConnectOptions.None);
return true;
}
catch
{
if (tfsServer != null)
tfsServer.Dispose();
}
return false;
}
private static TfsTeamProjectCollection GetProjectCollection()
{
var networkCredential = new NetworkCredential(tfsServiceProviderTestUser, tfsServiceProviderTestPassword);
var tfsClientCredentials = new TfsClientCredentials(new BasicAuthCredential(networkCredential))
{
AllowInteractive = false
};
var tfsProjectCollection = new TfsTeamProjectCollection(
new Uri(tfsServiceProviderUri),
tfsClientCredentials);
tfsProjectCollection.Authenticate();
return tfsProjectCollection;
}
private static async Task<bool> CanLogIn(string username, string password, string uri, string configType)
{
bool response = false;
try
{
// 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);
server.EnsureAuthenticated();
response = server.HasAuthenticated;
}
}
catch (Exception e)
{
LogService.WriteError(e);
throw;
}
return response;
}
static int Main(string[] args)
{
if (args.Length == 0)
{
Console.Error.WriteLine("Expected exactly one argument, the file to annotate. " + args.Length + " given.");
return 1;
}
String path = args[args.Length - 1];
if (!File.Exists(path))
{
Console.Error.WriteLine("The given file does not exist: " + path);
return 2;
}
if (!Workstation.Current.IsMapped(path))
{
Console.Error.WriteLine("The given file is not in a mapped TFS workspace: " + path);
return 3;
}
WorkspaceInfo workspaceInfo = Workstation.Current.GetLocalWorkspaceInfo(path);
Uri serverUri = workspaceInfo.ServerUri;
WorkspaceVersionSpec version = new WorkspaceVersionSpec(workspaceInfo);
TfsClientCredentials credentials = new TfsClientCredentials(true);
using (TfsTeamProjectCollection collection = new TfsTeamProjectCollection(serverUri, credentials))
{
VersionControlServer server = collection.GetService<VersionControlServer>();
IAnnotatedFile annotatedFile = new FileAnnotator(server).Annotate(path, version);
if (annotatedFile == null)
{
Console.Error.WriteLine("The given file has not yet been checked-in: " + path);
return 4;
}
if (annotatedFile.IsBinary())
{
Console.Error.WriteLine("The given file is a binary one: " + path);
return 5;
}
for (int i = 0; i < annotatedFile.Lines(); i++)
{
switch (annotatedFile.State(i))
{
case AnnotationState.UNKNOWN:
Console.Write("unknown ");
break;
case AnnotationState.LOCAL:
Console.Write("local ");
break;
case AnnotationState.COMMITTED:
Changeset changeset = annotatedFile.Changeset(i);
Console.Write(changeset.ChangesetId);
Console.Write(' ');
Console.Write(changeset.Owner);
Console.Write(' ');
Console.Write(changeset.CreationDate.ToString("MM/dd/yyyy"));
Console.Write(' ');
break;
default:
throw new InvalidOperationException("Unsupported annotation state: " + annotatedFile.State(i));
}
Console.WriteLine(annotatedFile.Data(i));
}
}
return 0;
}
private static TfsClientCredentials CreateCredentials(string username, string password)
{
NetworkCredential netCred = new NetworkCredential(username, password);
WindowsCredential windowsCredential = new WindowsCredential(netCred);
TfsClientCredentials tfsCred = new TfsClientCredentials(windowsCredential) { AllowInteractive = false };
return tfsCred;
}
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;
}
static int Main(string[] args)
{
Console.InputEncoding = Encoding.UTF8;
Console.OutputEncoding = Encoding.UTF8;
if (args.Length != 0)
{
Console.Error.WriteLine("This program is only expected to be called by the SonarQube TFS SCM plugin.");
return 1;
}
Console.WriteLine("Enter your credentials");
Console.Out.Flush();
var username = Console.ReadLine();
var password = Console.ReadLine();
TfsClientCredentials credentials;
if (!String.IsNullOrEmpty(username) || !String.IsNullOrEmpty(password))
{
credentials = new TfsClientCredentials(new WindowsCredential(new NetworkCredential(username, password)));
}
else
{
credentials = new TfsClientCredentials(true);
}
credentials.AllowInteractive = false;
Console.WriteLine("Enter the Collection URI");
Console.Out.Flush();
var serverUriString = Console.ReadLine();
if (!string.IsNullOrEmpty(serverUriString))
{
if (!SetServerUri(serverUriString))
{
return 1;
}
}
using (var cache = new TfsCache(credentials))
{
if (serverUri != null)
{
if (!UpdateCache(cache, serverUri))
{
return 1;
}
}
Console.Out.WriteLine("Enter the paths to annotate");
Console.Out.Flush();
string path;
while ((path = Console.ReadLine()) != null)
{
Console.Out.Flush();
Console.WriteLine(path);
if (!File.Exists(path))
{
FailOnFile("does not exist: " + path);
continue;
}
if (!Workstation.Current.IsMapped(path))
{
FailOnFile("is not in a mapped TFS workspace: " + path);
continue;
}
WorkspaceInfo workspaceInfo = Workstation.Current.GetLocalWorkspaceInfo(path);
WorkspaceVersionSpec version = new WorkspaceVersionSpec(workspaceInfo);
if (serverUri == null || workspaceInfo.ServerUri.AbsoluteUri != serverUri.AbsoluteUri)
{
serverUri = workspaceInfo.ServerUri;
if (!UpdateCache(cache, serverUri))
{
return 1;
}
}
var versionControlServer = cache.GetVersionControlServer(serverUri);
IAnnotatedFile annotatedFile = new FileAnnotator(versionControlServer).Annotate(path, version);
if (annotatedFile == null)
{
FailOnFile("is not yet checked-in: " + path);
continue;
}
if (annotatedFile.IsBinary())
{
FailOnFile("is a binary one: " + path);
continue;
}
bool failed = false;
for (int i = 0; !failed && i < annotatedFile.Lines(); i++)
{
var state = annotatedFile.State(i);
if (state != AnnotationState.COMMITTED)
{
FailOnFile("line " + (i + 1) + " has not yet been checked-in (" + state + "): " + path);
failed = true;
}
}
if (failed)
{
continue;
}
Console.WriteLine(annotatedFile.Lines());
for (int i = 0; i < annotatedFile.Lines(); i++)
{
Changeset changeset = annotatedFile.Changeset(i);
Console.Write(changeset.ChangesetId);
Console.Write('\t');
Console.Write(cache.GetEmailOrAccountName(serverUri, changeset.Owner));
Console.Write('\t');
Console.Write(ToUnixTimestampInMs(changeset.CreationDate));
Console.Write('\t');
Console.WriteLine(annotatedFile.Data(i));
}
}
Console.Out.Flush();
}
return 0;
}
public TfsCache(TfsClientCredentials credentials)
{
this.credentials = credentials;
}
private void cmdExport_Click(object sender, EventArgs e)
{
Uri collectionUri = new Uri(txtCollectionUri.Text);
string teamProject = txtTeamProject.Text;
SaveFileDialog dlg = new SaveFileDialog();
dlg.CheckPathExists = true;
dlg.Title = "Export Area/Iteration structure";
dlg.DefaultExt = ".nodes";
dlg.Filter = "TFS Node Structure (*.nodes)|*.nodes";
if (dlg.ShowDialog(this) == DialogResult.OK)
{
string filename = dlg.FileName;
var networkCredential = new NetworkCredential("username", "password");
var basicAuthCredential = new BasicAuthCredential(networkCredential);
var tfsCredential = new TfsClientCredentials(basicAuthCredential);
using(var tfs = new TfsTeamProjectCollection(collectionUri, tfsCredential))
//using (var tfs = TfsTeamProjectCollectionFactory.GetTeamProjectCollection(collectionUri))
using (WaitState waitState = new WaitState(this))
{
tfs.Authenticate();
tfs.EnsureAuthenticated();
// get the configuration server
var svr = tfs.ConfigurationServer;
// get the configuration service
var svc = tfs.GetService<TeamSettingsConfigurationService>();
// get the common structure service
var css = tfs.GetService<ICommonStructureService4>();
// get the spotlabs project
var prj = css.GetProjectFromName(txtTeamProject.Text);
// get the configurations
var cfg = svc.GetTeamConfigurationsForUser(new[] { prj.Uri }).Single<TeamConfiguration>();
// get the settings
var opt = cfg.TeamSettings;
// get the iteration schedule
var schedule = css.GetIterationDates(prj.Uri);
Console.WriteLine(opt.ToString());
var store = (WorkItemStore)tfs.GetService(typeof(WorkItemStore));
var proj = store.Projects[teamProject];
using (FileStream fs = new FileStream(filename, FileMode.Create, FileAccess.Write))
using (StreamWriter writer = new StreamWriter(fs))
{
writer.WriteLine("NODES");
writer.WriteLine(String.Format("{0}, Version {1}", Application.ProductName, Application.ProductVersion));
writer.WriteLine("Copyright (C) 2010 " + Application.CompanyName);
if (chkAreaStructure.Checked)
{
WriteNodes(proj.AreaRootNodes, writer, "A");
}
if (chkIterationStructure.Checked)
{
WriteNodes(proj.IterationRootNodes, writer, "I");
}
writer.Close();
}
}
MessageBox.Show("Export successful.");
}
}
private IEnumerable<TfsClientCredentials> GetServiceIdentityPatCredentials()
{
if (string.IsNullOrWhiteSpace(_config.TfsServerConfig.ServiceIdentityPatFile))
{
return new List<TfsClientCredentials>();
}
var netCred = new NetworkCredential("", GetPatFromConfig());
var basicCred = new BasicAuthCredential(netCred);
var patCred = new TfsClientCredentials(basicCred) {AllowInteractive = false};
return new List<TfsClientCredentials> {patCred};
}
/// <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;
}
private void cmdImport_Click(object sender, EventArgs e)
{
Uri collectionUri = new Uri(txtCollectionUri.Text);
string teamProject = txtTeamProject.Text;
OpenFileDialog dlg = new OpenFileDialog();
dlg.CheckFileExists = true;
dlg.Title = "Import Area/Iteration structure";
dlg.DefaultExt = ".nodes";
dlg.Filter = "TFS Node Structure (*.nodes)|*.nodes";
if (dlg.ShowDialog(this) == DialogResult.OK)
{
string filename = dlg.FileName;
var networkCredential = new NetworkCredential("username", "password");
var basicAuthCredential = new BasicAuthCredential(networkCredential);
var tfsCredential = new TfsClientCredentials(basicAuthCredential);
using (var tfs = new TfsTeamProjectCollection(collectionUri, tfsCredential))
//using (var tfs = TfsTeamProjectCollectionFactory.GetTeamProjectCollection(collectionUri, new UICredentialsProvider()))
using (WaitState waitState = new WaitState(this))
{
tfs.Authenticate();
tfs.EnsureAuthenticated();
WorkItemStore store = (WorkItemStore)tfs.GetService(typeof(WorkItemStore));
Project proj = store.Projects[teamProject];
NodeInfo rootAreaNode = null;
NodeInfo rootIterationNode = null;
var css = (ICommonStructureService4)tfs.GetService(typeof(ICommonStructureService4));
foreach (NodeInfo info in css.ListStructures(proj.Uri.ToString()))
{
if (info.StructureType == "ProjectModelHierarchy")
{
rootAreaNode = info;
}
else if (info.StructureType == "ProjectLifecycle")
{
rootIterationNode = info;
}
}
using (FileStream fs = new FileStream(filename, FileMode.Open, FileAccess.Read))
using (StreamReader reader = new StreamReader(fs))
{
string nextLine = reader.ReadLine();
if (nextLine != "NODES")
{
MessageBox.Show("Wrong file format!");
return;
}
reader.ReadLine();
reader.ReadLine();
while (!reader.EndOfStream)
{
nextLine = reader.ReadLine();
if (nextLine.StartsWith("A") && chkAreaStructure.Checked)
{
CreateNode(css, nextLine.Substring(2), rootAreaNode);
}
else if (nextLine.StartsWith("I") && chkIterationStructure.Checked)
{
CreateNode(css, nextLine.Substring(2), rootIterationNode);
}
else
{ // Ignore other lines
}
}
reader.Close();
}
MessageBox.Show("Import successful.");
}
}
}
private IEnumerable<TfsClientCredentials> GetBasicAuthCredentials()
{
var usernameAndPassword = GetAltAuthUsernameAndPasswordFromConfig();
if (usernameAndPassword == null)
{
return new List<TfsClientCredentials>();
}
NetworkCredential netCred = new NetworkCredential(usernameAndPassword.Item1, usernameAndPassword.Item2);
BasicAuthCredential basicCred = new BasicAuthCredential(netCred);
TfsClientCredentials tfsCred = new TfsClientCredentials(basicCred);
tfsCred.AllowInteractive = false;
return new List<TfsClientCredentials>
{
tfsCred
};
}
private IBuildServer GetBuildServer()
{
BasicAuthCredential basicCredentials = new BasicAuthCredential(credentialsProvider);
TfsClientCredentials tfsCredentials = new TfsClientCredentials(basicCredentials);
tfsCredentials.AllowInteractive = false;
var tfs = TfsTeamProjectCollectionFactory.GetTeamProjectCollection(new Uri(tfsServerAddress));
tfs.ClientCredentials = tfsCredentials;
tfs.Authenticate();
IBuildServer buildServer = tfs.GetService<IBuildServer>();
return buildServer;
}
