private void Connect()
{
if (Uri.IsWellFormedUriString(ConnectionUri, UriKind.Absolute))
{
_connection = TfsTeamProjectCollectionFactory.GetTeamProjectCollection(new Uri(ConnectionUri));
}
}
public string GetLastButOneRevision()
{
var collection = new TfsTeamProjectCollection(new Uri(ConfigHelper.Instance.FuncTestCollection));
var vcs = collection.GetService<VersionControlServer>();
TeamProject tp = vcs.GetTeamProject(ConfigHelper.Instance.FuncTestsProject);
var changesets = vcs.QueryHistory(
tp.ServerItem,
VersionSpec.Latest,
0,
RecursionType.Full,
null,
null,
null,
Int32.MaxValue,
true,
true).Cast<Changeset>().ToArray();
collection.Dispose();
if (changesets.Count() == 1)
return changesets.First().ChangesetId.ToString();
int lastButOneChangeset = changesets.Where(x => x.ChangesetId < changesets.Max(m => m.ChangesetId)).Max(x => x.ChangesetId);
return lastButOneChangeset.ToString(CultureInfo.InvariantCulture);
}
private ITestManagementTeamProject2 GetTestProject()
{
var collectionUri = SpecFlow2TFSConfig.TFS_URL + "/" + SpecFlow2TFSConfig.COLLECTION.Substring(SpecFlow2TFSConfig.COLLECTION.LastIndexOf('\\') + 1);
TfsTeamProjectCollection tpc = new TfsTeamProjectCollection(new Uri(collectionUri));
WorkItemStore workItemStore = new WorkItemStore(tpc);
Project project = null;
foreach (Project p in workItemStore.Projects)
{
if (p.Name == SpecFlow2TFSConfig.PROJECT)
{
project = p;
break;
}
}
if (project == null)
{
throw new NullReferenceException("no project found for the name " + SpecFlow2TFSConfig.PROJECT);
}
// get test management service
ITestManagementService2 test_service = (ITestManagementService2)tpc.GetService(typeof(ITestManagementService2));
ITestManagementTeamProject2 test_project = test_service.GetTeamProject(project);
return test_project;
}
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();
}
}
public override void Connect(string serverUri, string remotePath, string localPath, int fromChangeset, string tfsUsername, string tfsPassword, string tfsDomain)
{
this._serverUri = new Uri(serverUri);
this._remotePath = remotePath;
this._localPath = localPath;
this._startingChangeset = fromChangeset;
try
{
NetworkCredential tfsCredential = new NetworkCredential(tfsUsername, tfsPassword, tfsDomain);
//this._teamFoundationServer = new Microsoft.TeamFoundation.Client.TeamFoundationServer(this._serverUri, tfsCredential);
this._tfsProjectCollection = new TfsTeamProjectCollection(this._serverUri, tfsCredential);
this._versionControlServer = this._tfsProjectCollection.GetService<VersionControlServer>();
}
catch (Exception ex)
{
throw new Exception("Error connecting to TFS", ex);
}
//clear hooked eventhandlers
BeginChangeSet = null;
EndChangeSet = null;
FileAdded = null;
FileEdited = null;
FileDeleted = null;
FileUndeleted = null;
FileBranched = null;
FileRenamed = null;
FolderAdded = null;
FolderDeleted = null;
FolderUndeleted = null;
FolderBranched = null;
FolderRenamed = null;
ChangeSetsFound = null;
}
public BuildDefinitionsServiceModel(ITeamPilgrimServiceModelProvider teamPilgrimServiceModelProvider, ITeamPilgrimVsService teamPilgrimVsService, TfsTeamProjectCollection collection, Project project)
: base(teamPilgrimServiceModelProvider, teamPilgrimVsService)
{
BuildDefinitions = new ObservableCollection<BuildDefinitionModel>();
_collection = collection;
_project = project;
OpenBuildDefintionCommand = new RelayCommand<BuildDefinitionModel>(OpenBuildDefinition, CanOpenBuildDefinition);
ViewBuildsCommand = new RelayCommand<BuildDefinitionModel>(ViewBuilds, CanViewBuilds);
DeleteBuildDefinitionCommand = new RelayCommand<BuildDefinitionModel>(DeleteBuildDefinition, CanDeleteBuildDefinition);
CloneBuildDefinitionCommand = new RelayCommand<BuildDefinitionModel>(CloneBuildDefinition, CanCloneBuildDefinition);
QueueBuildCommand = new RelayCommand<BuildDefinitionModel>(QueueBuild, CanQueueBuild);
OpenProcessFileLocationCommand = new RelayCommand<BuildDefinitionModel>(OpenProcessFileLocation, CanOpenProcessFileLocation);
ManageBuildDefinitionSecurityCommand = new RelayCommand<BuildDefinitionModel>(ManageBuildDefinitionSecurity, CanManageBuildDefinitionSecurity);
NewBuildDefinitionCommand = new RelayCommand(NewBuildDefinition, CanNewBuildDefinition);
ManageBuildControllersCommand = new RelayCommand(ManageBuildControllers, CanManageBuildControllers);
ManageBuildQualitiesCommand = new RelayCommand(ManageBuildQualities, CanManageBuildQualities);
ManageBuildSecurityCommand = new RelayCommand(ManageBuildSecurity, CanManageBuildSecurity);
_populateBackgroundWorker = new BackgroundWorker();
_populateBackgroundWorker.DoWork += PopulateBackgroundWorkerOnDoWork;
_populateBackgroundWorker.RunWorkerAsync();
}
public WorkItemQueryServiceModel(ITeamPilgrimServiceModelProvider teamPilgrimServiceModelProvider, ITeamPilgrimVsService teamPilgrimVsService, TfsTeamProjectCollection projectCollection, Project project)
: base(teamPilgrimServiceModelProvider, teamPilgrimVsService)
{
_projectCollection = projectCollection;
_project = project;
QueryItems = new ObservableCollection<WorkItemQueryChildModel>();
NewWorkItemCommand = new RelayCommand<string>(NewWorkItem, CanNewWorkItem);
GoToWorkItemCommand = new RelayCommand(GoToWorkItem, CanGoToWorkItem);
NewQueryDefinitionCommand = new RelayCommand<WorkItemQueryFolderModel>(NewQueryDefinition, CanNewQueryDefinition);
NewQueryFolderCommand = new RelayCommand<WorkItemQueryFolderModel>(NewQueryFolder, CanNewQueryFolder);
OpenQueryDefinitionCommand = new RelayCommand<WorkItemQueryDefinitionModel>(OpenQueryDefinition, CanOpenQueryDefinition);
EditQueryDefinitionCommand = new RelayCommand<WorkItemQueryDefinitionModel>(EditQueryDefinition, CanEditQueryDefinition);
DeleteQueryItemCommand = new RelayCommand<WorkItemQueryChildModel>(DeleteQueryDefinition, CanDeleteQueryDefinition);
OpenSeurityDialogCommand = new RelayCommand<WorkItemQueryChildModel>(OpenSeurityDialog, CanOpenSeurityDialog);
_populateBackgroundWorker = new BackgroundWorker();
_populateBackgroundWorker.DoWork +=PopulateBackgroundWorkerOnDoWork;
_populateBackgroundWorker.RunWorkerAsync();
}
public virtual void SetUp()
{
var collectionUrl = Environment.GetEnvironmentVariable("WILINQ_TEST_TPCURL");
if (string.IsNullOrWhiteSpace(collectionUrl))
{
collectionUrl = "http://localhost:8080/tfs/DefaultCollection";
}
TPC = new TfsTeamProjectCollection(new Uri(collectionUrl));
TPC.Authenticate();
var projectName = Environment.GetEnvironmentVariable("WILINQ_TEST_PROJECTNAME");
// ReSharper disable once ConvertIfStatementToConditionalTernaryExpression
if (string.IsNullOrWhiteSpace(projectName))
{
Project = TPC.GetService<WorkItemStore>().Projects.Cast<Project>().First();
}
else
{
Project = TPC.GetService<WorkItemStore>().Projects.Cast<Project>().First(_ => _.Name == projectName);
}
}
static void Main(string[] args)
{
// Try to parse options from command line
var options = new Options();
if (Parser.Default.ParseArguments(args, options))
{
try
{
_collection = TfsTeamProjectCollectionFactory.GetTeamProjectCollection(new Uri(options.TeamCollection));
_buildServer = _collection.GetService<IBuildServer>();
_commonStructureService = _collection.GetService<ICommonStructureService>();
_printer = new TabbedPrinter();
PrintDefinitions(options);
}
catch (Exception ex)
{
Console.WriteLine();
Console.WriteLine("An error occured:");
Console.WriteLine(ex.Message);
Console.WriteLine();
}
}
else
{
Console.WriteLine("Couldn't read options");
Console.WriteLine();
}
}
private TfsTeamProjectCollection ConnectToTfsCollection()
{
var tfsCredentials = GetTfsCredentials();
foreach (var credentials in tfsCredentials)
{
try
{
Logger.InfoFormat("Connecting to TFS {0} using {1} credentials", _config.TfsServerConfig.CollectionUri, credentials);
var tfsServer = new TfsTeamProjectCollection(new Uri(_config.TfsServerConfig.CollectionUri), credentials);
tfsServer.EnsureAuthenticated();
Logger.InfoFormat("Successfully connected to TFS");
return tfsServer;
}
catch (Exception ex)
{
Logger.WarnFormat("TFS connection attempt failed.\n Exception: {0}", ex);
}
}
Logger.ErrorFormat("All TFS connection attempts failed");
throw new Exception("Cannot connect to TFS");
}
public object GetService(Type serviceType)
{
var collection = new TfsTeamProjectCollection(_projectCollectionUri);
object service;
try
{
if (_buildConfigurationManager.UseCredentialToAuthenticate)
{
collection.Credentials = new NetworkCredential(_buildConfigurationManager.TfsAccountUserName,
_buildConfigurationManager.TfsAccountPassword, _buildConfigurationManager.TfsAccountDomain);
}
collection.EnsureAuthenticated();
service = collection.GetService(serviceType);
}
catch (Exception ex)
{
Tracing.Client.TraceError(
String.Format("Error communication with TFS server: {0} detail error message {1} ",
_projectCollectionUri, ex));
throw;
}
Tracing.Client.TraceInformation("Connection to TFS established.");
return service;
}
/// <summary>
/// Selects the target Team Project containing the migrated test cases.
/// </summary>
/// <param name="serverUrl">URL of TFS Instance</param>
/// <param name="project">Name of Project within the TFS Instance</param>
/// <returns>The Team Project</returns>
private static ITestManagementTeamProject GetProject(string serverUrl, string project)
{
var uri = new System.Uri(serverUrl);
TfsTeamProjectCollection tfs = new TfsTeamProjectCollection(uri);
ITestManagementService tms = tfs.GetService<ITestManagementService>();
return tms.GetTeamProject(project);
}
/// <summary>
/// Main Execution. UI handled in separate method, as this is a procedural utility.
/// </summary>
/// <param name="args">Not used</param>
private static void Main(string[] args)
{
string serverUrl, destProjectName, plansJSONPath, logPath, csvPath;
UIMethod(out serverUrl, out destProjectName, out plansJSONPath, out logPath, out csvPath);
teamCollection = new TfsTeamProjectCollection(new Uri(serverUrl));
workItemStore = new WorkItemStore(teamCollection);
Trace.Listeners.Clear();
TextWriterTraceListener twtl = new TextWriterTraceListener(logPath);
twtl.Name = "TextLogger";
twtl.TraceOutputOptions = TraceOptions.ThreadId | TraceOptions.DateTime;
ConsoleTraceListener ctl = new ConsoleTraceListener(false);
ctl.TraceOutputOptions = TraceOptions.DateTime;
Trace.Listeners.Add(twtl);
Trace.Listeners.Add(ctl);
Trace.AutoFlush = true;
// Get Project
ITestManagementTeamProject newTeamProject = GetProject(serverUrl, destProjectName);
// Get Test Plans in Project
ITestPlanCollection newTestPlans = newTeamProject.TestPlans.Query("Select * From TestPlan");
// Inform user which Collection/Project we'll be working in
Trace.WriteLine("Executing alignment tasks in collection \"" + teamCollection.Name
+ "\",\n\tand Destination Team Project \"" + newTeamProject.TeamProjectName + "\"...");
// Get and print all test case information
GetAllTestPlanInfo(newTestPlans, plansJSONPath, logPath, csvPath);
Console.WriteLine("Alignment completed. Check log file in:\n " + logPath
+ "\nfor missing areas or other errors. Press enter to close.");
Console.ReadLine();
}
private static string GetDropDownloadPath(TfsTeamProjectCollection collection, IBuildDetail buildDetail)
{
string droplocation = buildDetail.DropLocation;
if (string.IsNullOrEmpty(droplocation))
{
throw new FailingBuildException(string.Format(CultureInfo.CurrentCulture, "No drop is available for {0}.", buildDetail.BuildNumber));
}
ILocationService locationService = collection.GetService<ILocationService>();
string containersBaseAddress = locationService.LocationForAccessMapping(ServiceInterfaces.FileContainersResource, FrameworkServiceIdentifiers.FileContainers, locationService.DefaultAccessMapping);
droplocation = BuildContainerPath.Combine(droplocation, string.Format(CultureInfo.InvariantCulture, "{0}.zip", buildDetail.BuildNumber));
try
{
long containerId;
string itemPath;
BuildContainerPath.GetContainerIdAndPath(droplocation, out containerId, out itemPath);
string downloadPath = string.Format(CultureInfo.InvariantCulture, "{0}/{1}/{2}", containersBaseAddress, containerId, itemPath.TrimStart('/'));
return downloadPath;
}
catch (InvalidPathException)
{
throw new FailingBuildException(string.Format(CultureInfo.CurrentCulture, "No drop is available for {0}.", buildDetail.BuildNumber));
}
}
public void Close(string itemId, string comment)
{
using (var collection = new TfsTeamProjectCollection(locator.Location))
{
var workItemId = int.Parse(itemId);
var workItemStore = new WorkItemStore(collection, WorkItemStoreFlags.BypassRules);
var workItem = workItemStore.GetWorkItem(workItemId);
var workItemDefinition = workItem.Store.Projects[workItem.Project.Name].WorkItemTypes[workItem.Type.Name];
if (workItemDefinition == null)
{
throw new ArgumentException("Could not obtain work item definition to close work item");
}
var definitionDocument = workItemDefinition.Export(false).InnerXml;
var xDocument = XDocument.Parse(definitionDocument);
var graphBuilder = new StateGraphBuilder();
var stateGraph = graphBuilder.BuildStateGraph(xDocument);
var currentStateNode = stateGraph.FindRelative(workItem.State);
var graphWalker = new GraphWalker<string>(currentStateNode);
var shortestWalk = graphWalker.WalkToNode("Closed");
foreach (var step in shortestWalk.Path)
{
workItem.State = step.Value;
workItem.Save();
}
workItem.Fields[CoreField.Description].Value = comment + "<br /><br/>" + workItem.Fields[CoreField.Description].Value;
workItem.Save();
}
}
/// <summary>
/// Compares changesets
/// </summary>
/// <param name="localPath"></param>
/// <param name="sourceChangesetId">Source changeset Id</param>
/// <param name="serverUrl">Server Uri</param>
/// <param name="srcPath">Source item path</param>
public static void CompareLocal(string localPath, string sourceChangesetId, string serverUri, string srcPath)
{
if (String.IsNullOrWhiteSpace(sourceChangesetId))
throw new ArgumentException("'sourceChangesetId' is null or empty.");
if (String.IsNullOrWhiteSpace(serverUri))
throw new TfsHistorySearchException("'serverUri' is null or empty.");
if (String.IsNullOrWhiteSpace(srcPath))
throw new TfsHistorySearchException("'srcPath' is null or empty.");
if (String.IsNullOrWhiteSpace(localPath))
throw new TfsHistorySearchException("'localPath' is null or empty.");
TfsTeamProjectCollection tc = new TfsTeamProjectCollection(new Uri(serverUri));
VersionControlServer vcs = tc.GetService(typeof(VersionControlServer)) as VersionControlServer;
//VersionSpec sourceVersion = VersionSpec.ParseSingleSpec(sourceChangesetId, vcs.TeamFoundationServer.AuthenticatedUserName);
VersionSpec sourceVersion = VersionSpec.ParseSingleSpec(sourceChangesetId, vcs.AuthorizedUser);
//VersionSpec targetVersion = VersionSpec.ParseSingleSpec(targetChangesetId, vcs.TeamFoundationServer.AuthenticatedUserName);
//Difference.DiffFiles(
Difference.VisualDiffItems(vcs, Difference.CreateTargetDiffItem(vcs, srcPath, sourceVersion, 0, sourceVersion), Difference.CreateTargetDiffItem(vcs, localPath, null, 0, null));
//Difference.VisualDiffFiles();
//Difference.VisualDiffItems(vcs,
// Difference.CreateTargetDiffItem(vcs, srcPath, sourceVersion, 0, sourceVersion),
// Difference.CreateTargetDiffItem(vcs, targetPath, targetVersion, 0, targetVersion));
}
public FolderDiffInternalsGetter(dynamic folderDiffObject, TfsTeamProjectCollection collection, string outputDirectory):base("", "", "", outputDirectory) {
_folderDiff = new FolderDiffWrapper(folderDiffObject, FolderDiffWrapper.LoadVersonControlControlsAssemblyFromApplication());
_collection = collection;
SourcePath = _folderDiff.Path1;
TargetPath = _folderDiff.Path2;
}
protected override void ProcessRecord()
{
using (var collection = new TfsTeamProjectCollection(CollectionUri))
{
var cssService = collection.GetService<ICommonStructureService4>();
var projectInfo = cssService.GetProjectFromName(TeamProject);
var teamService = collection.GetService<TfsTeamService>();
var tfsTeam = teamService.ReadTeam(projectInfo.Uri, Team, null);
if (tfsTeam == null)
{
WriteError(new ErrorRecord(new ArgumentException(string.Format("Team '{0}' not found.", Team)), "", ErrorCategory.InvalidArgument, null));
return;
}
var identityService = collection.GetService<IIdentityManagementService>();
var identity = identityService.ReadIdentity(IdentitySearchFactor.AccountName, Member, MembershipQuery.Direct, ReadIdentityOptions.None);
if (identity == null)
{
WriteError(new ErrorRecord(new ArgumentException(string.Format("Identity '{0}' not found.", Member)), "", ErrorCategory.InvalidArgument, null));
return;
}
identityService.AddMemberToApplicationGroup(tfsTeam.Identity.Descriptor, identity.Descriptor);
WriteVerbose(string.Format("Identity '{0}' added to team '{1}'", Member, Team));
}
}
private void EnsureTfs(bool allowCache = true)
{
if (_tfs != null)
return;
if (allowCache)
{
var tfsFromCache = HttpRuntime.Cache[CacheKey] as TfsTeamProjectCollection;
if (tfsFromCache != null)
{
_tfs = tfsFromCache;
return;
}
}
lock (_CacheLock)
{
if (allowCache && _tfs != null)
return;
_tfs = new TfsTeamProjectCollection(
new Uri(_principal.TfsUrl), _principal.GetCredentialsProvider());
//new Uri(_principal.TfsUrl), CredentialCache.DefaultCredentials, _principal.GetCredentialsProvider());
HttpRuntime.Cache.Add(
CacheKey,
_tfs,
null,
Cache.NoAbsoluteExpiration,
new TimeSpan(1, 0, 0),
CacheItemPriority.Normal,
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;
}
public void SetConfiguration(ConfigurationBase newConfiguration)
{
if (timer != null)
{
timer.Change(Timeout.Infinite, Timeout.Infinite);
}
configuration = newConfiguration as TeamFoundationConfiguration;
if (configuration == null)
{
throw new ApplicationException("Configuration can not be null.");
}
var credentialProvider = new PlainCredentialsProvider(configuration.Username, configuration.Password);
var teamProjectCollection = new TfsTeamProjectCollection(new Uri(configuration.CollectionUri), credentialProvider);
buildServer = teamProjectCollection.GetService<IBuildServer>();
if (timer == null)
{
timer = new Timer(Tick, null, 0, configuration.PollInterval);
}
else
{
timer.Change(0, configuration.PollInterval);
}
}
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 SourceControlWrapper(string teamProjectCollectionUrl, string teamProjectName)
{
this.tpcollection = new TfsTeamProjectCollection(new Uri(teamProjectCollectionUrl));
this.teamProjectName = teamProjectName;
this.vcserver = this.tpcollection.GetService<VersionControlServer>();
}
public ProjectServiceModel(ITeamPilgrimServiceModelProvider teamPilgrimServiceModelProvider, ITeamPilgrimVsService teamPilgrimVsService, TeamPilgrimServiceModel teamPilgrimServiceModel, TfsTeamProjectCollection tfsTeamProjectCollection, Project project)
: base(teamPilgrimServiceModelProvider, teamPilgrimVsService)
{
TeamPilgrimServiceModel = teamPilgrimServiceModel;
TfsTeamProjectCollection = tfsTeamProjectCollection;
Project = project;
ShowProjectAlertsCommand = new RelayCommand(ShowProjectAlerts, CanShowProjectAlerts);
OpenSourceControlCommand = new RelayCommand(OpenSourceControl, CanOpenSourceControl);
OpenPortalSettingsCommand = new RelayCommand(OpenPortalSettings, CanOpenPortalSettings);
OpenSourceControlSettingsCommand = new RelayCommand(OpenSourceControlSettings, CanOpenSourceControlSettings);
OpenAreasAndIterationsCommand = new RelayCommand(OpenAreasAndIterations, CanOpenAreasAndIterations);
ShowSecuritySettingsCommand = new RelayCommand(ShowSecuritySettings, CanShowSecuritySettings);
OpenGroupMembershipCommand = new RelayCommand(OpenGroupMembership, CanOpenGroupMembership);
BuildDefinitionsServiceModel = new BuildDefinitionsServiceModel(teamPilgrimServiceModelProvider, teamPilgrimVsService, tfsTeamProjectCollection, project);
WorkItemQueryServiceModel = new WorkItemQueryServiceModel(teamPilgrimServiceModelProvider, teamPilgrimVsService, tfsTeamProjectCollection, project);
ChildObjects = new ObservableCollection<BaseModel>
{
WorkItemQueryServiceModel,
BuildDefinitionsServiceModel,
new SourceControlModel()
};
IsActive = teamPilgrimVsService.ActiveProjectContext.ProjectName == Project.Name;
}
public TFSWorkItemManager(Config.InstanceConfig config)
{
ValidateConfig(config);
_config = config;
// Init TFS service objects
_tfsServer = ConnectToTfsCollection();
Logger.InfoFormat("Connected to TFS. Getting TFS WorkItemStore");
_tfsStore = _tfsServer.GetService<WorkItemStore>();
if (_tfsStore == null)
{
Logger.ErrorFormat("Cannot initialize TFS Store");
throw new Exception("Cannot initialize TFS Store");
}
Logger.InfoFormat("Geting TFS Project");
_tfsProject = _tfsStore.Projects[config.TfsServerConfig.Project];
Logger.InfoFormat("Initializing WorkItems Cache");
InitWorkItemsCache();
_nameResolver = InitNameResolver();
}
/// <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.");
}
static void Main(string[] args)
{
TfsTeamProjectCollection tfs = new TfsTeamProjectCollection(new Uri("https://code-inside.visualstudio.com/DefaultCollection"));
VersionControlServer vcs = (VersionControlServer)tfs.GetService(typeof(VersionControlServer));
//Following will get all changesets since 365 days. Note : "DateVersionSpec(DateTime.Now - TimeSpan.FromDays(20))"
System.Collections.IEnumerable history = vcs.QueryHistory("$/Grocerylist",
LatestVersionSpec.Instance,
0,
RecursionType.Full,
null,
new DateVersionSpec(DateTime.Now - TimeSpan.FromDays(365)),
LatestVersionSpec.Instance,
Int32.MaxValue,
true,
false);
foreach (Changeset changeset in history)
{
Console.WriteLine("Changeset Id: " + changeset.ChangesetId);
Console.WriteLine("Owner: " + changeset.Owner);
Console.WriteLine("Date: " + changeset.CreationDate.ToString());
Console.WriteLine("Comment: " + changeset.Comment);
Console.WriteLine("-------------------------------------");
}
Console.ReadLine();
}
public TfsFileHandler(TfsTeamProjectCollection tfsTeamProjectCollection, string filename)
{
_tfsTeamProjectCollection = tfsTeamProjectCollection;
_filename = filename;
FileExistsOnServer = GetFileExistsOnServer();
}
public static void Main(string[] args)
{
try
{
var options = new Options();
if (CommandLine.Parser.Default.ParseArgumentsStrict(args, options))
{
TfsTeamProjectCollection collection = new TfsTeamProjectCollection(new Uri(options.TeamProjectCollectionUrl));
//Call Build
IBuildServer buildServer = collection.GetService<IBuildServer>();
IBuildDefinition definition = buildServer.GetBuildDefinition(options.TeamProjectName,
options.BuildDefinition);
IBuildRequest request = definition.CreateBuildRequest();
request.ProcessParameters = UpdateVersion(request.ProcessParameters, options);
request.DropLocation = options.DropLocation;
buildServer.QueueBuild(request);
}
}
catch (Exception ex)
{
Console.WriteLine("Error in calling TFS Build: " + ex.Message);
}
}
private void PopulateProjectNameComboBox()
{
string url = tfsAddressTextBox.Text;
string username = tfsUsernameTextBox.Text;
string password = tfsPasswordTextBox.Text;
Uri tfsUri;
if (!Uri.TryCreate(url, UriKind.Absolute, out tfsUri))
return;
var credentials = new System.Net.NetworkCredential();
if (!string.IsNullOrEmpty(username))
{
credentials.UserName = username;
credentials.Password = password;
}
var tfs = new TfsTeamProjectCollection(tfsUri, credentials);
tfs.Authenticate();
var workItemStore = (WorkItemStore)tfs.GetService(typeof(WorkItemStore));
projectComboBox.Items.Clear();
foreach (Project project in workItemStore.Projects)
projectComboBox.Items.Add(project.Name);
int existingProjectIndex = -1;
if (!string.IsNullOrEmpty(options.ProjectName))
existingProjectIndex = projectComboBox.Items.IndexOf(options.ProjectName);
projectComboBox.SelectedIndex = existingProjectIndex > 0 ? existingProjectIndex : 0;
}
private bool ConnectToTfs(String accountUri, String accessToken)
{
//login for VSTS
VssCredentials creds = new VssBasicCredential(
String.Empty,
accessToken);
creds.Storage = new VssClientCredentialStorage();
// Connect to VSTS
_tfsCollection = new TfsTeamProjectCollection(new Uri(accountUri), creds);
_tfsCollection.Authenticate();
return(true);
}
public static List <Branch> GetBranches(TfsTeamProjectCollection tfs)
{
var rtnVal = new List <Branch>();
using (tfs)
{
var vcs = tfs.GetService <VersionControlServer>();
var bos = vcs.QueryRootBranchObjects(RecursionType.OneLevel);
rtnVal.AddRange(bos.Select(branchObject => RecursivelyProcessBranch(branchObject, vcs)));
}
return(rtnVal);
}
private static void GetProjectsForServerV2(Uri serverUrl)
{
//https://stackoverflow.com/questions/31031817/unable-to-load-dll-microsoft-witdatastore32-dll-teamfoundation-workitemtracki
TfsTeamProjectCollection tpc = new TfsTeamProjectCollection(serverUrl);
WorkItemStore workItemStore = tpc.GetService <WorkItemStore>();
Project teamProject = workItemStore.Projects["ARM Basic Templates"];
WorkItemType workItemType = teamProject.WorkItemTypes["Test Case"];
var queryResults = workItemStore.Query(
"Select [State], [Title] " +
"From WorkItems " +
"Where [Work Item Type] = 'Test Case' " +
"Order By [State] Asc, [Changed Date] Desc");
}
internal static TfsTeamProjectCollectionWrapper GetInstance()
{
TfsTeamProjectCollection real = default(TfsTeamProjectCollection);
RealInstanceFactory(ref real);
var instance = (TfsTeamProjectCollectionWrapper)TfsTeamProjectCollectionWrapper.GetWrapper(real);
InstanceFactory(ref instance);
if (instance == null)
{
Assert.Inconclusive("Could not Create Test Instance");
}
return(instance);
}
public TfsWrapper(TfsOptions options, WorkspaceInfo[] workspaces)
{
this.projectCollection = new TfsTeamProjectCollection(new Uri(options.ProjectCollectionUrl));
this.projectWorkspaces = workspaces.Where(w => w.Name.StartsWith(options.ProjectCollectionName, StringComparison.OrdinalIgnoreCase)).ToList();
if (this.projectWorkspaces.Any() == false)
{
throw new Exception("Unable to match to any project workspaces");
}
// set the dev workspace
this.DevWorkspace = this.SetSingleWorkspace("dev");
this.PersonalWorkspace = this.SetPersonalWorkspace();
}
/// <summary>
/// This class gets the file stream from TFS
/// during Adds, the files dont exist in TFS and this results in the returning of a null string
/// </summary>
public static System.IO.Stream get(string serverURL, string FullFileName)
{
Stream fileStream = null;
TfsTeamProjectCollection tfs = new TfsTeamProjectCollection(new Uri(serverURL));
VersionControlServer vcs = (VersionControlServer)tfs.GetService(typeof(VersionControlServer));
string fName = FullFileName;
Item it = vcs.GetItems(fName).Items.FirstOrDefault();
if (it != null)
{
fileStream = it.DownloadFile();
}
return(fileStream);
}
private static void Main(string[] args)
{
try
{
Console.WriteLine("\r\nEnter the URL for your TFS Server: (ie: http://tfs:8080/tfs)");
var server = Console.ReadLine();
Console.WriteLine("\r\nEnter the Name of your old computer and hit enter \r\n (leave blank to skip migrating tfs mappings and exit):");
var oldComputerName = Console.ReadLine();
if (!string.IsNullOrEmpty(oldComputerName) && !string.IsNullOrEmpty(server))
{
var computername = Environment.MachineName;
Console.WriteLine("Old ComputerName: {0}", oldComputerName);
Console.WriteLine("New ComputerName: {0}", computername);
Console.WriteLine("Connecting to server...");
TfsTeamProjectCollection tfsCollection = new TfsTeamProjectCollection(new Uri(server));
VersionControlServer versionControlServer = tfsCollection.GetService <VersionControlServer>();
Console.WriteLine("Getting list of workspaces...");
Workspace[] workspaces = versionControlServer.QueryWorkspaces(null, versionControlServer.AuthorizedUser,
oldComputerName);
if (workspaces.Any())
{
foreach (var workspace in workspaces)
{
Console.WriteLine("Updating workspace: {0}", workspace.Name);
workspace.Update(
workspace.Name, //Keep the name
workspace.OwnerName, //Keep the owner
workspace.Comment, //Keep the comment
computername, //New Computer name
workspace.Folders, //Keep the mappings
workspace.PermissionsProfile, //Keep the permissions
false); //May not need to fix mappings ... if not, this will be false.
}
}
else
{
Console.WriteLine("No workspaces Found for that computer name.");
}
}
Console.WriteLine("All Finished! Press any key to continue.");
Console.ReadKey();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
private static void Migrate(TfsTeamProjectCollection teamProjectCollection, GitWorkspace workspace)
{
teamProjectCollection.EnsureAuthenticated();
var versionControlServer = teamProjectCollection.GetService <VersionControlServer>();
var history = (from changeset in versionControlServer.QueryHistory(workspace.ServerHomePath, RecursionType.Full)
select versionControlServer.GetChangeset(changeset.ChangesetId))
.OrderBy(changeset => changeset.ChangesetId);
using (var tfsWorkspace = new TfsWorkspace(teamProjectCollection.Uri, workspace.ServerHomePath))
{
ProcessChangesets(teamProjectCollection, workspace, tfsWorkspace, history);
}
}
/// <summary>
/// Get TeamProject from TFS
/// </summary>
/// <param name="teamProjecName">The teamProjectName object.</param>
public void GetTeamProject(string teamProjecName)
{
ReadOnlyCollection <CatalogNode> collectionNodes
= configurationServer.CatalogNode.QueryChildren(new[] { CatalogResourceTypes.ProjectCollection }, false, CatalogQueryOptions.None);
var collectionNode = collectionNodes.Single();
Guid collectionId = new Guid(collectionNode.Resource.Properties["InstanceId"]);
teamProjectCollection = configurationServer.GetTeamProjectCollection(collectionId);
ITestManagementService testManagementService = teamProjectCollection.GetService <ITestManagementService>();
testProject = testManagementService.GetTeamProject(teamProjecName);
}
public TFSRepositoryService()
{
_pendingCheckIns = new Dictionary <DataAccess.IVersionControlled, string>();
AppSettingsReader appReader = new AppSettingsReader();
_workspacePath = appReader.GetValue("RepositoryPath", typeof(string)).ToString();
WorkspaceInfo sourceWorkspaceInfo = Workstation.Current.GetLocalWorkspaceInfo(_workspacePath);
TfsTeamProjectCollection projectCollecion = TfsTeamProjectCollectionFactory.GetTeamProjectCollection(sourceWorkspaceInfo.ServerUri);
_versionControlServer = (VersionControlServer)projectCollecion.GetService(typeof(VersionControlServer));
_workspace = _versionControlServer.GetWorkspace(sourceWorkspaceInfo);
}
/// <summary>
/// main function
/// </summary>
/// <param name="args"></param>
private static void Main(string[] args)
{
//string path1 = "ISH3\\ISH3_KBL\\KBL_RS2\\Test";
string logPath = Directory.GetCurrentDirectory();
string logfile = Path.Combine(logPath, "log-file.txt");
if (File.Exists(logfile))
{
File.Delete(logfile);
}
ILog log = LogManager.GetLogger("testApp.Logging");
try
{
Uri tfsUri = new Uri(ConfigurationManager.AppSettings["TfsUri"]);
//Uri tfsUri = new Uri("https://tfs-alm.intel.com:8088/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);
var collectionNode = collectionNodes.Single();
// Use the InstanceId property to get the team project collection
Guid collectionId = new Guid(collectionNode.Resource.Properties["InstanceId"]);
teamProjectCollection = configurationServer.GetTeamProjectCollection(collectionId);
//Console.WriteLine("Collection: " + teamProjectCollection.Name);
log.InfoFormat("Collecton: {0}", teamProjectCollection.Name);
//log.Info("---------------------------------");
log.Info("*********************************");
workItemStore = teamProjectCollection.GetService <WorkItemStore>();
//ICommonStructureService css = teamProjectCollection.GetService<ICommonStructureService>();
//"ISH3\ISH3_KBL\KBL_RS2\Test"
log.Info("path:" + args[0]);
string path = args[0];
string[] folder = path.Split('\\');
for (int i = 0; i < folder.Length; i++)
{
log.Info("folder[" + i + "]:" + folder[i]);
}
if (!CreateCycle(folder))
{
return;
}
log.Info("Create test cycle:" + args[0] + " successfully!");
}
catch (Exception e)
{
log.Info(e.Message.ToString());
return;
}
}
private Dictionary <string, IterationInfo> LoadIterations(TfsTeamProjectCollection tfs, Project project)
{
var css = tfs.GetService <ICommonStructureService4>();
var structures = css.ListStructures(project.Uri.ToString());
var iterations = structures.First(n => n.StructureType.Equals("ProjectLifecycle"));
var iterationsTree = css.GetNodesXml(new[] { iterations.Uri }, true);
var result = new Dictionary <string, IterationInfo>();
BuildIterationTree(result, project.IterationRootNodes, css);
return(result);
}
public TeamManager(string teamProjectCollectionUrl, string teamProjectName, string softwareProjectName, string softwareProjectDescription)
{
_teamProjectCollectionUrl = teamProjectCollectionUrl;
_teamProjectName = teamProjectName;
_softwareProjectName = softwareProjectName;
_softwareProjectDescription = softwareProjectDescription;
_tfsTeamProjectCollection = TfsTeamProjectCollectionFactory.GetTeamProjectCollection(new Uri(_teamProjectCollectionUrl));
_tfsTeamProjectCollection.EnsureAuthenticated();
_commonStructureService4 = _tfsTeamProjectCollection.GetService <ICommonStructureService4>();
_tfsTeamService = _tfsTeamProjectCollection.GetService <TfsTeamService>();
_teamSettingsConfigurationService = _tfsTeamProjectCollection.GetService <TeamSettingsConfigurationService>();
_projectInfo = _commonStructureService4.GetProjectFromName(_teamProjectName);
}
public static ITestManagementTeamProject GetProject(string serverUrl, string project)
{
try
{
TfsTeamProjectCollection tfs = new TfsTeamProjectCollection(TfsTeamProjectCollection.GetFullyQualifiedUriForName(serverUrl));
ITestManagementService tms = tfs.GetService <ITestManagementService>();
return(tms.GetTeamProject(project));
}
catch (Exception e)
{
throw e;
}
}
public static SortedDictionary <string, string> GetTestPlans(string collectionName, string projectName)
{
tfs = new TfsTeamProjectCollection(TfsTeamProjectCollection.GetFullyQualifiedUriForName(XML.GetCollectionURL(collectionName)));
tms = tfs.GetService <ITestManagementService>();
proj = tms.GetTeamProject(projectName);
iTPC = proj.TestPlans.Query("Select * From TestPlan");
SortedDictionary <string, string> iTP = new SortedDictionary <string, string>();
foreach (ITestPlan itp in iTPC)
{
iTP.Add(itp.Id.ToString(), itp.Name);
}
return(iTP);
}
private void Connect()
{
if (_Collection == null)
{
_Telemetry.TrackEvent("TeamProjectContext.Connect",
new Dictionary <string, string> {
{ "Name", Config.Project },
{ "Target Project", Config.Project },
{ "Target Collection", Config.Collection.ToString() },
{ "ReflectedWorkItemID Field Name", Config.ReflectedWorkItemIDFieldName }
});
Stopwatch connectionTimer = Stopwatch.StartNew();
DateTime start = DateTime.Now;
Trace.WriteLine("Creating TfsTeamProjectCollection Object ");
if (_credentials == null)
{
_Collection = new TfsTeamProjectCollection(Config.Collection);
}
else
{
_Collection = new TfsTeamProjectCollection(Config.Collection, _credentials);
}
try
{
Trace.WriteLine(string.Format("Connected to {0} ", _Collection.Uri.ToString()));
Trace.WriteLine(string.Format("validating security for {0} ", _Collection.AuthorizedIdentity.ToString()));
_Collection.EnsureAuthenticated();
connectionTimer.Stop();
_Telemetry.TrackDependency("TeamService", "EnsureAuthenticated", start, connectionTimer.Elapsed, true);
Trace.TraceInformation(string.Format(" Access granted "));
}
catch (TeamFoundationServiceUnavailableException ex)
{
_Telemetry.TrackDependency("TeamService", "EnsureAuthenticated", start, connectionTimer.Elapsed, false);
_Telemetry.TrackException(ex,
new Dictionary <string, string> {
{ "CollectionUrl", Config.Collection.ToString() },
{ "TeamProjectName", Config.Project }
},
new Dictionary <string, double> {
{ "ConnectionTimer", connectionTimer.ElapsedMilliseconds }
});
Trace.TraceWarning($" [EXCEPTION] {ex}");
throw;
}
}
ConnectStore();
}
public void GetParentWorkitemTest()
{
var tfs = new TfsTeamProjectCollection(new Uri("http://localhost:8080/tfs/defaultcollection"));
WorkItemStore workItemStore = tfs.GetService <WorkItemStore>();
var workItem = workItemStore.GetWorkItem(85);
// TODO: private accessors using "Test References | .accessor" are deprecated
// use reflection to call Invoke directly
//GetParentWorkItem_Accessor target = new GetParentWorkItem_Accessor();
//WorkItem expected = null; // TODO: Initialize to an appropriate value
//WorkItem actual;
//actual = target.GetParentWorkitem(workItem);
//Assert.AreEqual(expected, actual);
}
static void Main(string[] args)
{
TfsTeamProjectCollection tpc = new TfsTeamProjectCollection(
new Uri("http://tfsserver:8080/tfs/TestCollection"));
WorkItemStore workItemStore = (WorkItemStore)tpc.GetService(typeof(WorkItemStore));
string wiql = "Select * From WorkItems Where [Work Item Type] = 'Test Case' and [System.TeamProject] = 'adam asf_test' ORDER BY [System.Tags]";
var queryResults = workItemStore.Query(wiql);
Console.WriteLine(queryResults.Count);
Console.WriteLine("press the <any> key");
Console.ReadKey();
}
public IList <BuildState> GetLatestBuildStates()
{
using (TfsTeamProjectCollection tfs = new TfsTeamProjectCollection(new Uri(_configuration.TfsUrl), new NetworkCredential(_configuration.TfsUserName, _configuration.TfsPassword)))
{
IBuildServer buildServer = tfs.GetService <IBuildServer>();
ITestManagementService testServer = tfs.GetService <ITestManagementService>();
var defs = buildServer.QueryBuildDefinitions(_configuration.TfsTeamProjectName);
return(defs
.Select(def => GetLatestBuildDetails(buildServer, def))
.Where(build => build != null)
.Select(build => new BuildState(build.BuildDefinition.Name, build.Status, build.FinishTime, build.Uri.AbsoluteUri, build.RequestedFor, GetTestResults(testServer, build.Uri)))
.ToList());
}
}
static void Main(string[] args)
{
Uri url = new Uri("https://tfsuri");
TfsTeamProjectCollection ttpc = new TfsTeamProjectCollection(url);
VersionControlServer vcs = ttpc.GetService <VersionControlServer>();
IEnumerable <Changeset> cses = vcs.QueryHistory("Path here could be local path or server path", RecursionType.Full);
foreach (Changeset cs in cses)
{
Console.WriteLine(cs.ChangesetId);
Console.WriteLine(cs.Comment);
}
Console.ReadLine();
}
/// <summary>
/// Initializes a new instance of the <see cref="TfsWrapper"/> class
/// using the specified URL.
/// </summary>
public TfsWrapper(TfsServerInfo serverInfo)
{
#region Argument Check
if (serverInfo == null)
{
throw new ArgumentNullException("serverInfo");
}
#endregion
_teamProjectCollection = new TfsTeamProjectCollection(serverInfo.Uri);
_versionControlServerLazy = new Lazy <VersionControlServer>(GetService <VersionControlServer>);
}
private void cmbUser_SelectedIndexChanged(object sender, EventArgs e)
{
string serverName = @"https://tfsnbs.gmd.lab/tfs/nbs";
TfsTeamProjectCollection tfs = new TfsTeamProjectCollection(new Uri(serverName));
VersionControlServer vcs = tfs.GetService <VersionControlServer>();
KeyValuePair <string, string> selectPair = (KeyValuePair <string, string>)cmbUser.SelectedItem;
if (cmbUser.SelectedIndex > -1)
{
userName = selectPair.Value;
this.GetShelveSetDetails(vcs);
}
}
private void EnsureCollection()
{
if (_collection == null)
{
_Telemetry.TrackEvent("TeamProjectContext.EnsureCollection",
new Dictionary <string, string> {
{ "Name", TfsConfig.Project },
{ "Target Project", TfsConfig.Project },
{ "Target Collection", TfsConfig.Collection.ToString() },
{ "ReflectedWorkItemID Field Name", TfsConfig.ReflectedWorkItemIDFieldName }
}, null);
_collection = GetDependantTfsCollection(_credentials);
}
}
/// <summary>
/// http://stackoverflow.com/questions/10557814/how-to-get-a-specific-build-with-the-tfs-api
/// </summary>
/// <param name="TeamProject"></param>
/// <param name="BuildDefinition"></param>
/// <param name="BuildID"></param>
/// <returns></returns>
public string GetBuildStatus(TfsTeamProjectCollection tfs, string TeamProject, string BuildDefinition, int BuildID)
{
IBuildServer buildServer = (IBuildServer)tfs.GetService(typeof(IBuildServer));
string status = string.Empty;
IQueuedBuildSpec qbSpec = buildServer.CreateBuildQueueSpec(TeamProject, BuildDefinition);
IQueuedBuildQueryResult qbResults = buildServer.QueryQueuedBuilds(qbSpec);
if (qbResults.QueuedBuilds.Length > 0)
{
IQueuedBuild build = qbResults.QueuedBuilds.Where(x => x.Id == BuildID).FirstOrDefault();
status = build.Status.ToString();
}
return(status);
}
public void Close()
{
if (m_Connection != null)
{
m_Connection.Close();
m_Connection = null;
}
if (projectCollection != null)
{
projectCollection.Dispose();
projectCollection = null;
}
}
static void Main(string[] args)
{
string rootLogFolder = ConfigurationManager.AppSettings["RootLogFolder"].ToString();
try
{
Console.WriteLine("*** Scanning all Team Projects in all Team Project Collections ***");
string tfsRootUrl = ConfigurationManager.AppSettings["TfsRootUrl"].ToString();
Console.WriteLine("Tfs Root Url: " + tfsRootUrl);
Uri tfsConfigurationServerUri = new Uri(tfsRootUrl);
TfsConfigurationServer configurationServer = TfsConfigurationServerFactory.GetConfigurationServer(tfsConfigurationServerUri);
ITeamProjectCollectionService tpcService = configurationServer.GetService <ITeamProjectCollectionService>();
string configDbConnectionString = ConfigurationManager.AppSettings["ConfigDBConnectionString"].ToString();
Console.WriteLine("Config DB Connectionstring: " + configDbConnectionString);
using (IVssDeploymentServiceHost deploymentServiceHost = CreateDeploymentServiceHost(configDbConnectionString))
{
foreach (TeamProjectCollection tpc in tpcService.GetCollections().OrderBy(tpc => tpc.Name))
{
string nameOfLogFile = "UpgradeTeamProjectFeatures-" + tpc.Name + ".txt";
string fullPathOfLogFile = System.IO.Path.Combine(rootLogFolder, nameOfLogFile);
System.IO.StreamWriter logFile = new System.IO.StreamWriter(fullPathOfLogFile);
logFile.WriteLine(String.Format("*** scanning Team Projects in TPC {0} ***", tpc.Name));
logFile.WriteLine();
string tpcUrl = tfsRootUrl + "/" + tpc.Name;
TfsTeamProjectCollection tfsCollection = new TfsTeamProjectCollection(new Uri(tpcUrl));
WorkItemStore witStore = tfsCollection.GetService <WorkItemStore>();
foreach (Microsoft.TeamFoundation.WorkItemTracking.Client.Project project in witStore.Projects)
{
Console.WriteLine("Team Project " + project.Name);
logFile.WriteLine(">> Team Project " + project.Name);
RunFeatureEnablement(deploymentServiceHost, project, tfsCollection.InstanceId, logFile);
logFile.WriteLine();
}
logFile.Close();
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
/// <summary>
/// Executes the logic for this workflow activity.
/// </summary>
/// <param name="context">The workflow context.</param>
/// <returns>The <see cref="Microsoft.TeamFoundation.Build.Client.IBuildServer"/>
/// that is specified.</returns>
protected override IBuildServer Execute(CodeActivityContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
string serverUrl = context.GetValue(this.TeamFoundationServerUrl);
using (TfsTeamProjectCollection tfs = TfsTeamProjectCollectionFactory.GetTeamProjectCollection(new Uri(serverUrl)))
{
return((IBuildServer)tfs.GetService <IBuildServer>());
}
}
/// <summary>
/// Returns a work item by ID
/// </summary>
/// <param name="projectCollection">Tfs Project Collection that contains the work item.</param>
/// <param name="workItemId">Id for the work item</param>
/// <returns>The found work item.</returns>
/// <exception cref="ArgumentException">Occurs when the work item id is not valid.</exception>
public static WorkItem GetWorkItemById(TfsTeamProjectCollection projectCollection, int workItemId)
{
ArgumentValidation.ValidateObjectIsNotNull(projectCollection, "projectCollection");
if (workItemId <= 0)
{
// This is not a valid work item.
throw new ArgumentException("Work Item Id is not valid", "workItemId");
}
WorkItemStore store = projectCollection.GetService <WorkItemStore>();
var workItem = store.GetWorkItem(workItemId);
return(workItem);
}
private static string GetTeamProjectCollectionName(TfsTeamProjectCollection teamProjectCollection)
{
long startTicks = XlHlp.DisplayInWatchWindow("Begin");
string colName = teamProjectCollection.Name;
// TFS in cloud send names back with back slashes
colName = colName.Replace('\\', '/');
// strip all all but TeamProjectCollection name part
colName = colName.Substring(colName.LastIndexOf('/') + 1);
XlHlp.DisplayInWatchWindow("End", startTicks);
return(colName);
}
public CapacitySearcher(TfsTeamProjectCollection connection,
WorkItemStore itemStore = null,
IIdentityManagementService2 managementService = null,
TfsTeamService teamService = null,
WorkHttpClient workClient = null,
ICommonStructureService4 structureService = null)
{
_connection = connection;
_itemStore = itemStore;
_managementService = managementService;
_teamService = teamService;
_workClient = workClient;
_structureService = structureService;
}
