Unpacking Software Livestream

Join our monthly Unpacking Software livestream to hear about the latest news, chat and opinion on packaging, software deployment and lifecycle management!

Learn More

Chocolatey Product Spotlight

Join the Chocolatey Team on our regular monthly stream where we put a spotlight on the most recent Chocolatey product releases. You'll have a chance to have your questions answered in a live Ask Me Anything format.

Learn More

Chocolatey Coding Livestream

Join us for the Chocolatey Coding Livestream, where members of our team dive into the heart of open source development by coding live on various Chocolatey projects. Tune in to witness real-time coding, ask questions, and gain insights into the world of package management. Don't miss this opportunity to engage with our team and contribute to the future of Chocolatey!

Learn More

Calling All Chocolatiers! Whipping Up Windows Automation with Chocolatey Central Management

Webinar from
Wednesday, 17 January 2024

We are delighted to announce the release of Chocolatey Central Management v0.12.0, featuring seamless Deployment Plan creation, time-saving duplications, insightful Group Details, an upgraded Dashboard, bug fixes, user interface polishing, and refined documentation. As an added bonus we'll have members of our Solutions Engineering team on-hand to dive into some interesting ways you can leverage the new features available!

Watch On-Demand
Chocolatey Community Coffee Break

Join the Chocolatey Team as we discuss all things Community, what we do, how you can get involved and answer your Chocolatey questions.

Watch The Replays
Chocolatey and Intune Overview

Webinar Replay from
Wednesday, 30 March 2022

At Chocolatey Software we strive for simple, and teaching others. Let us teach you just how simple it could be to keep your 3rd party applications updated across your devices, all with Intune!

Watch On-Demand
Chocolatey For Business. In Azure. In One Click.

Livestream from
Thursday, 9 June 2022

Join James and Josh to show you how you can get the Chocolatey For Business recommended infrastructure and workflow, created, in Azure, in around 20 minutes.

Watch On-Demand
The Future of Chocolatey CLI

Livestream from
Thursday, 04 August 2022

Join Paul and Gary to hear more about the plans for the Chocolatey CLI in the not so distant future. We'll talk about some cool new features, long term asks from Customers and Community and how you can get involved!

Watch On-Demand
Hacktoberfest Tuesdays 2022

Livestreams from
October 2022

For Hacktoberfest, Chocolatey ran a livestream every Tuesday! Re-watch Cory, James, Gary, and Rain as they share knowledge on how to contribute to open-source projects such as Chocolatey CLI.

Watch On-Demand

Downloads:

5,021

Downloads of v 1.0.0-alpha1:

313

Last Update:

31 Jul 2015

Package Maintainer(s):

Software Author(s):

  • Igor Abade V. Leite (T-Shooter)

Tags:

tfscmdlets tfs powershell

TfsCmdlets

This is a prerelease version of TfsCmdlets.

  • 1
  • 2
  • 3

1.0.0-alpha1 | Updated: 31 Jul 2015

Downloads:

5,021

Downloads of v 1.0.0-alpha1:

313

Maintainer(s):

Software Author(s):

  • Igor Abade V. Leite (T-Shooter)

TfsCmdlets 1.0.0-alpha1

This is a prerelease version of TfsCmdlets.

Legal Disclaimer: Neither this package nor Chocolatey Software, Inc. are affiliated with or endorsed by Igor Abade V. Leite (T-Shooter). The inclusion of Igor Abade V. Leite (T-Shooter) trademark(s), if any, upon this webpage is solely to identify Igor Abade V. Leite (T-Shooter) goods or services and not for commercial purposes.

  • 1
  • 2
  • 3

Some Checks Have Failed or Are Not Yet Complete

Not All Tests Have Passed


Validation Testing Unknown


Verification Testing Unknown


Scan Testing Successful:

No detections found in any package files

Details
Learn More

Deployment Method: Individual Install, Upgrade, & Uninstall

To install TfsCmdlets, run the following command from the command line or from PowerShell:

>

To upgrade TfsCmdlets, run the following command from the command line or from PowerShell:

>

To uninstall TfsCmdlets, run the following command from the command line or from PowerShell:

>

Deployment Method:

NOTE

This applies to both open source and commercial editions of Chocolatey.

1. Enter Your Internal Repository Url

(this should look similar to https://community.chocolatey.org/api/v2/)


2. Setup Your Environment

1. Ensure you are set for organizational deployment

Please see the organizational deployment guide

2. Get the package into your environment

  • Open Source or Commercial:
    • Proxy Repository - Create a proxy nuget repository on Nexus, Artifactory Pro, or a proxy Chocolatey repository on ProGet. Point your upstream to https://community.chocolatey.org/api/v2/. Packages cache on first access automatically. Make sure your choco clients are using your proxy repository as a source and NOT the default community repository. See source command for more information.
    • You can also just download the package and push it to a repository Download

3. Copy Your Script

choco upgrade tfscmdlets -y --source="'INTERNAL REPO URL'" --version="'1.0.0-alpha1'" --prerelease [other options]

See options you can pass to upgrade.

See best practices for scripting.

Add this to a PowerShell script or use a Batch script with tools and in places where you are calling directly to Chocolatey. If you are integrating, keep in mind enhanced exit codes.

If you do use a PowerShell script, use the following to ensure bad exit codes are shown as failures:


choco upgrade tfscmdlets -y --source="'INTERNAL REPO URL'" --version="'1.0.0-alpha1'" --prerelease
$exitCode = $LASTEXITCODE

Write-Verbose "Exit code was $exitCode"
$validExitCodes = @(0, 1605, 1614, 1641, 3010)
if ($validExitCodes -contains $exitCode) {
  Exit 0
}

Exit $exitCode

- name: Install tfscmdlets
  win_chocolatey:
    name: tfscmdlets
    version: '1.0.0-alpha1'
    source: INTERNAL REPO URL
    state: present
    allow_prerelease: yes

See docs at https://docs.ansible.com/ansible/latest/modules/win_chocolatey_module.html.


chocolatey_package 'tfscmdlets' do
  action    :install
  source   'INTERNAL REPO URL'
  version  '1.0.0-alpha1'
  options  '--prerelease'
end

See docs at https://docs.chef.io/resource_chocolatey_package.html.


cChocoPackageInstaller tfscmdlets
{
    Name        = "tfscmdlets"
    Version     = "1.0.0-alpha1"
    Source      = "INTERNAL REPO URL"
    chocoParams = "--prerelease"
}

Requires cChoco DSC Resource. See docs at https://github.com/chocolatey/cChoco.


package { 'tfscmdlets':
  ensure          => '1.0.0-alpha1',
  install_options => ['--prerelease'],
  provider        => 'chocolatey',
  source          => 'INTERNAL REPO URL',
}

Requires Puppet Chocolatey Provider module. See docs at https://forge.puppet.com/puppetlabs/chocolatey.


4. If applicable - Chocolatey configuration/installation

See infrastructure management matrix for Chocolatey configuration elements and examples.

WARNING

This package is exempt from moderation. While it is likely safe for you, there is more risk involved.

Description

PowerShell Cmdlets for Team Foundation Server and Visual Studio Online


Tools\chocolateyInstall.ps1
$InstallPath = Join-Path $($env:ChocolateyInstall) 'lib\TfsCmdlets'
$ToolsDir = Join-Path $InstallPath 'Tools'

if (-not ($env:PSModulePath -contains $ToolsDir))
{
    [Environment]::SetEnvironmentVariable("PSModulePath", "$env:PSModulePath;$ToolsDir", 'Machine')
}
Tools\chocolateyUninstall.ps1
$InstallPath = Join-Path $($env:ChocolateyInstall) 'lib\TfsCmdlets'
$ToolsDir = Join-Path $InstallPath 'Tools'

if ($env:PSModulePath -contains $ToolsDir)
{
    [Environment]::SetEnvironmentVariable("PSModulePath", ($env:PSModulePath -replace ";$ToolDir",''), 'Machine')
}
Tools\lib\Microsoft.IdentityModel.Clients.ActiveDirectory.dll
 
Tools\lib\Microsoft.IdentityModel.Clients.ActiveDirectory.WindowsForms.dll
 
Tools\lib\Microsoft.TeamFoundation.Build.Client.dll
 
Tools\lib\Microsoft.TeamFoundation.Build.Common.dll
 
Tools\lib\Microsoft.TeamFoundation.Build2.WebApi.dll
 
Tools\lib\Microsoft.TeamFoundation.Chat.WebApi.dll
 
Tools\lib\Microsoft.TeamFoundation.Client.dll
 
Tools\lib\Microsoft.TeamFoundation.Common.dll
 
Tools\lib\Microsoft.TeamFoundation.Core.WebApi.dll
 
Tools\lib\Microsoft.TeamFoundation.DeleteTeamProject.dll
 
Tools\lib\Microsoft.TeamFoundation.Diff.dll
 
Tools\lib\Microsoft.TeamFoundation.Discussion.Client.dll
 
Tools\lib\Microsoft.TeamFoundation.Discussion.WebApi.dll
 
Tools\lib\Microsoft.TeamFoundation.Git.Client.dll
 
Tools\lib\Microsoft.TeamFoundation.Lab.Client.dll
 
Tools\lib\Microsoft.TeamFoundation.Lab.Common.dll
 
Tools\lib\Microsoft.TeamFoundation.Lab.TestIntegration.Client.dll
 
Tools\lib\Microsoft.TeamFoundation.Lab.WorkflowIntegration.Client.dll
 
Tools\lib\Microsoft.TeamFoundation.Policy.WebApi.dll
 
Tools\lib\Microsoft.TeamFoundation.ProjectManagement.dll
 
Tools\lib\Microsoft.TeamFoundation.SharePointReporting.Integration.dll
 
Tools\lib\Microsoft.TeamFoundation.SourceControl.WebApi.dll
 
Tools\lib\Microsoft.TeamFoundation.Test.WebApi.dll
 
Tools\lib\Microsoft.TeamFoundation.TestImpact.Client.dll
 
Tools\lib\Microsoft.TeamFoundation.TestManagement.Client.dll
 
Tools\lib\Microsoft.TeamFoundation.TestManagement.Common.dll
 
Tools\lib\Microsoft.TeamFoundation.TestManagement.WebApi.dll
 
Tools\lib\Microsoft.TeamFoundation.VersionControl.Client.dll
 
Tools\lib\Microsoft.TeamFoundation.VersionControl.Common.dll
 
Tools\lib\Microsoft.TeamFoundation.VersionControl.Common.Integration.dll
 
Tools\lib\Microsoft.TeamFoundation.Work.WebApi.dll
 
Tools\lib\Microsoft.TeamFoundation.WorkItemTracking.Client.DataStoreLoader.dll
 
Tools\lib\Microsoft.TeamFoundation.WorkItemTracking.Client.dll
 
Tools\lib\Microsoft.TeamFoundation.WorkItemTracking.Client.QueryLanguage.dll
 
Tools\lib\Microsoft.TeamFoundation.WorkItemTracking.Common.dll
 
Tools\lib\Microsoft.TeamFoundation.WorkItemTracking.Proxy.dll
 
Tools\lib\Microsoft.TeamFoundation.WorkItemTracking.WebApi.dll
 
Tools\lib\Microsoft.VisualStudio.Services.Client.dll
 
Tools\lib\Microsoft.VisualStudio.Services.Common.dll
 
Tools\lib\Microsoft.VisualStudio.Services.WebApi.dll
 
Tools\lib\Newtonsoft.Json.dll
 
Tools\lib\System.IdentityModel.Tokens.Jwt.dll
 
Tools\lib\System.Net.Http.Extensions.dll
 
Tools\lib\System.Net.Http.Formatting.dll
 
Tools\lib\System.Net.Http.Primitives.dll
 
Tools\lib\System.Web.Http.dll
 
Tools\Startup.ps1
Function _SetConsoleColors
{
	Process
	{
		$Host.UI.RawUI.BackgroundColor = "DarkMagenta"
		$Host.UI.RawUI.ForegroundColor = "White"
		Clear-Host
	}
}

Function _ImportTfsCmdlets
{
	Process
	{
		Write-Host "Importing TfsCmdlets module from $(_GetScriptDirectory)... " -NoNewline 
		Import-Module "$(_GetScriptDirectory)\TfsCmdlets.psd1"
		Write-Host "DONE."
	}
}

Function _ImportTfsPowerTools
{
	Process
	{
		Write-Host "Importing TFS Power Tools snap-in... " -NoNewline 

		try
		{
			$snapInName = "Microsoft.TeamFoundation.PowerShell"
			if ((Get-PSSnapin | ? { $_.Name -eq $snapInName }) -eq $null)
			{
				Add-PSSnapin $snapInName 2>&1 | Out-Null
			}
			Write-Host "DONE."
		}
		catch 
		{
			Write-Host "ERROR ($error.Exception.Message)."
		}
	}
}

Function _ImportTfsStandardTools
{
	Process
	{
		Write-Host "Importing TFS standard tools... " -NoNewline 
		$vsToolsPath = $env:VS120COMNTOOLS
		$devEnvDir = [System.IO.Path]::GetFullPath($(Join-Path $vsToolsPath "..\IDE"))
		$env:Path += ";$devEnvDir"
		Write-Host "DONE."
	}
}

Function _ShowBanner
{
	Process
	{
		$module = Get-Module TfsCmdlets
		Write-Host ""
		Write-Host "$($module.Name) version $($module.Version)"
		Write-Host ""
	}
}

Function _GetScriptDirectory
{
	Process
	{
		$Invocation = (Get-Variable MyInvocation -Scope 1).Value;
		if($Invocation.PSScriptRoot)
		{
			$Invocation.PSScriptRoot;
		}
		Elseif($Invocation.MyCommand.Path)
		{
			Split-Path $Invocation.MyCommand.Path
		}
		else
		{
			$Invocation.InvocationName.Substring(0,$Invocation.InvocationName.LastIndexOf("\"));
		}
	}
}

Function Prompt
{
	Process
	{
		if (Test-Path variable:global:TfsConnection)
		{
			$tfsConnectionText = "@$($Global:TfsConnection.Uri.Host)/$($Global:TfsConnection.Uri.Segments[$Global:TfsConnection.Uri.Segments.Length-1])"
		}
		"[TFS${tfsConnectionText}] $($executionContext.SessionState.Path.CurrentLocation)$('>' * ($nestedPromptLevel + 1)) "
	}
}

#Script main body

_SetConsoleColors
#_ImportTfsCmdlets
#_ImportTfsPowerTools
#_ImportTfsStandardTools
#_ShowBanner
Tools\TfsCmdlets\Admin\Admin.psd1
 
Tools\TfsCmdlets\Admin\Admin.psm1
Function Get-TfsInstallationPath
{
	[CmdletBinding()]
	[OutputType([string])]
	Param
	(
		[Parameter()]
		[string]
		[Alias('Session')]
		$Computer,

		[Parameter()]
		[ValidateSet('BaseInstallation', 'ApplicationTier', 'SharePointExtensions', 'TeamBuild', 'Tools', 'VersionControlProxy')]
		[string]
		$Component = 'BaseInstallation',

		[Parameter()]
		[string]
		$Version = '12.0',

		[Parameter()]
		[System.Management.Automation.Credential()]
		[System.Management.Automation.PSCredential]
		$Credential
	)

	Process
	{

		$scriptBlock = New-ScriptBlock -EntryPoint '_GetInstallationPath' -Dependency 'Test-RegistryValue', 'Get-RegistryValue'

		return Invoke-ScriptBlock -ScriptBlock $scriptBlock -Computer $Computer -Credential $Credential -ArgumentList $Version, $Component
	}
}


Function _GetInstallationPath($Version, $Component)
{
	return Get-InstallationPath @PSBoundParameters
}
Function Test-RegistryValue
{
	Param
	(
		[Parameter(Mandatory=$true)]
		[ValidateNotNullOrEmpty()]
		$Path,

		[Parameter(Mandatory=$true)]
		[ValidateNotNullOrEmpty()]
		$Value
	)

	Process
	{
		try
		{
			Get-RegistryValue -Path $Path -Value $Value | Out-Null
			return $true
		}
		catch {}

		return $false

	}
}

Function Get-RegistryValue
{
	Param
	(
		[Parameter(Mandatory=$true)]
		[ValidateNotNullOrEmpty()]
		$Path,

		[Parameter(Mandatory=$true)]
		[ValidateNotNullOrEmpty()]
		$Value
	)

	Process
	{
		return Get-ItemProperty -Path $Path | Select-Object -ExpandProperty $Value
	}
}

Function Get-InstallationPath
{
	Param
	(
		[string]
		$Version, 
		
		[string]
		$Component
	)

	$rootKeyPath = "HKLM:\Software\Microsoft\TeamFoundationServer\$Version"

	if ($Component -eq 'BaseInstallation')
	{
		$componentPath = $rootKeyPath
	}
	else
	{
		$componentPath = "$rootKeyPath\InstalledComponents\$Component"
	}

	if (-not (Test-RegistryValue -Path $rootKeyPath -Value 'InstallPath'))
	{
		throw "Team Foundation Server is not installed in computer $env:COMPUTERNAME"
	}

	if (-not (Test-RegistryValue -Path $componentPath -Value 'InstallPath'))
	{
		throw "Team Foundation Server component '$Component' is not installed in computer $env:COMPUTERNAME"
	}

	return Get-RegistryValue -Path $componentPath -Value 'InstallPath'
}
Function New-ScriptBlock($EntryPoint, [string[]]$Dependency)
{
	$entryPoint = (Get-Item "function:$EntryPoint").Definition.Trim()
	$paramSection = $entryPoint.Substring(0, $entryPoint.IndexOf("`n"))
	$bodySection = $entryPoint.Substring($paramSection.Length) + "`n`n"
	
	$body = $paramSection

	foreach($depFn in $Dependency)
	{
		$f = Get-Item "function:$depFn"

		$body += "Function $f `n{`n"
		$body += $f.Definition 
		$body += "`n}`n`n"
	}

	$body += $bodySection

	return [scriptblock]::Create($body)
}

Function Invoke-ScriptBlock($ScriptBlock, $Computer, $Credentials, $ArgumentList)
{
	if (-not $Computer)
	{
		return Invoke-Command -ScriptBlock $scriptBlock -ArgumentList $ArgumentList
	}
	elseif ($Computer -is [System.Management.Automation.Runspaces.PSSession])
	{
		return Invoke-Command -ScriptBlock $scriptBlock -Session $Computer -ArgumentList $ArgumentList
	}

	return Invoke-Command -ScriptBlock $scriptBlock -ComputerName $Computer -Credential $Credential -ArgumentList $ArgumentList
}
Tools\TfsCmdlets\AreaIteration\AreaIteration.psd1
 
Tools\TfsCmdlets\AreaIteration\AreaIteration.psm1
<#
.SYNOPSIS
	Get an specific Area of one Team Project.

.PARAMETER Collection
	Specifies either�a�URL�or�the�name�of�the�Team�Project�Collection�to�connect�to,�or�a�previously�initialized�TfsTeamProjectCollection�object.
	For�more�details,�see�the�-Collection�argument�in�the�Get-TfsTeamProjectCollection�cmdlet.

.PARAMETER Project
	Specifies either the�name of the Team Project or a previously initialized Microsoft.TeamFoundation.WorkItemTracking.Client.Project object to connect to.�
	For�more�details,�see�the�-Project�argument�in�the�Get-TfsTeamProject�cmdlet. 

.EXAMPLE
	xxxx.
#>
Function Get-TfsArea
{
    [CmdletBinding()]
    [OutputType([Microsoft.TeamFoundation.Server.NodeInfo])]
    Param
    (
		[Parameter(Position=0)]
		[Alias("Path")]
		[ValidateScript({($_ -is [string]) -or ($_ -is [uri]) -or ($_ -is [Microsoft.TeamFoundation.Server.NodeInfo])})] 
		[SupportsWildcards()]
		[object]
		$Area = '\**',

		[Parameter(ValueFromPipeline=$true)]
		[object]
		$Project,

		[Parameter()]
		[object]
		$Collection
    )

    Process
    {
		return _GetCssNodes -Node $Area -Scope Area -Project $Project -Collection $Collection
    }
}
<#
.SYNOPSIS
	Get an specific Iteration of one Team Project.

.PARAMETER Collection
	Specifies either�a�URL�or�the�name�of�the�Team�Project�Collection�to�connect�to,�or�a�previously�initialized�TfsTeamProjectCollection�object.
	For�more�details,�see�the�-Collection�argument�in�the�Get-TfsTeamProjectCollection�cmdlet.

.PARAMETER Project
	Specifies either the�name of the Team Project or a previously initialized Microsoft.TeamFoundation.WorkItemTracking.Client.Project object to connect to.�
	For�more�details,�see�the�-Project�argument�in�the�Get-TfsTeamProject�cmdlet. 

.EXAMPLE
	xxxx.
#>
Function Get-TfsIteration
{
    [CmdletBinding()]
    [OutputType([Microsoft.TeamFoundation.Server.NodeInfo])]
    Param
    (
		[Parameter(Position=0)]
		[Alias("Path")]
		[ValidateScript({($_ -is [string]) -or ($_ -is [uri]) -or ($_ -is [Microsoft.TeamFoundation.Server.NodeInfo])})] 
		[object]
		$Iteration = '\**',

		[Parameter(ValueFromPipeline=$true)]
		[object]
		$Project,

		[Parameter()]
		[object]
		$Collection
    )

    Process
    {
		return _GetCssNodes -Node $Iteration -Scope Iteration -Project $Project -Collection $Collection
    }
}
<#
#>
Function Move-TfsArea
{
	[CmdletBinding()]
    Param
    (
		[Parameter(Mandatory=$true, Position=0, ValueFromPipeline=$true)]
		[Alias("Path")]
		[ValidateScript({($_ -is [string]) -or ($_ -is [uri]) -or ($_ -is [Microsoft.TeamFoundation.Server.NodeInfo])})] 
		[object]
		$Area,

		[Parameter(Position=1l)]
		[ValidateScript({($_ -is [string]) -or ($_ -is [uri]) -or ($_ -is [Microsoft.TeamFoundation.Server.NodeInfo])})] 
		[object]
		$Destination,

		[Parameter()]
		[object]
		$Project,

		[Parameter()]
		[object]
		$Collection
	)

    Process
    {
		$node = Get-TfsArea -Area $Area -Project $Project -Collection $Collection

		if (-not $node)
		{
			throw "Invalid or non-existent area $Area"
		}

		$destinationNode = Get-TfsArea -Area $Destination -Project $Project -Collection $Collection

		if (-not $node)
		{
			throw "Invalid or non-existent destination area $Destination"
		}

		$cssService = _GetCssService -Project $Project -Collection $Collection

		$cssService.MoveBranch($node.Uri, $destinationNode.Uri)

		return $cssService.GetNode($node.Uri)
    }
}
<#
#>
Function Move-TfsIteration
{
	[CmdletBinding()]
    Param
    (
		[Parameter(Mandatory=$true, Position=0, ValueFromPipeline=$true)]
		[Alias("Path")]
		[ValidateScript({($_ -is [string]) -or ($_ -is [uri]) -or ($_ -is [Microsoft.TeamFoundation.Server.NodeInfo])})] 
		[object]
		$Iteration,

		[Parameter(Position=1)]
		[ValidateScript({($_ -is [string]) -or ($_ -is [uri]) -or ($_ -is [Microsoft.TeamFoundation.Server.NodeInfo])})] 
		[object]
		$Destination,

		[Parameter()]
		[object]
		$Project,

		[Parameter()]
		[object]
		$Collection
	)

    Process
    {
		$node = Get-TfsIteration -Iteration $Iteration -Project $Project -Collection $Collection

		if (-not $node)
		{
			throw "Invalid or non-existent iteration $Iteration"
		}

		$destinationNode = Get-TfsIteration -Iteration $Destination -Project $Project -Collection $Collection

		if (-not $node)
		{
			throw "Invalid or non-existent destination iteration $Destination"
		}

		$cssService = _GetCssService -Project $Project -Collection $Collection

		$cssService.MoveBranch($node.Uri, $destinationNode.Uri)

		return $cssService.GetNode($node.Uri)
    }
}
<#
.SYNOPSIS
	Create a new Area on Team Project.

.PARAMETER Collection
	Specifies either�a�URL�or�the�name�of�the�Team�Project�Collection�to�connect�to,�or�a�previously�initialized�TfsTeamProjectCollection�object.
	For�more�details,�see�the�-Collection�argument�in�the�Get-TfsTeamProjectCollection�cmdlet.

.PARAMETER Project
	Specifies either the�name of the Team Project or a previously initialized Microsoft.TeamFoundation.WorkItemTracking.Client.Project object to connect to.�
	For�more�details,�see�the�-Project�argument�in�the�Get-TfsTeamProject�cmdlet. 

.EXAMPLE
	xxxx.
#>
Function New-TfsArea
{
	[CmdletBinding()]
    Param
    (
		[Parameter(Mandatory=$true, Position=0)]
		[Alias("Path")]
		[string]
		$Area,

		[Parameter()]
		[object]
		$Project,

		[Parameter()]
		[object]
		$Collection
	)

    Process
    {
		return _NewCssNode -Path $Area -Scope Area -Project $Project -Collection $Collection
    }
}
<#
.SYNOPSIS
	Create a new Iteration on Team Project.

.PARAMETER Collection
	Specifies either�a�URL�or�the�name�of�the�Team�Project�Collection�to�connect�to,�or�a�previously�initialized�TfsTeamProjectCollection�object.
	For�more�details,�see�the�-Collection�argument�in�the�Get-TfsTeamProjectCollection�cmdlet.

.PARAMETER Project
	Specifies either the�name of the Team Project or a previously initialized Microsoft.TeamFoundation.WorkItemTracking.Client.Project object to connect to.�
	For�more�details,�see�the�-Project�argument�in�the�Get-TfsTeamProject�cmdlet. 

.EXAMPLE
	xxxx.
#>
Function New-TfsIteration
{
	[CmdletBinding()]
    Param
    (
		[Parameter(Mandatory=$true, Position=0)]
		[ValidateScript({($_ -is [string]) -or ($_ -is [Microsoft.TeamFoundation.Server.NodeInfo])})] 
		[Alias("Path")]
		[object]
		$Iteration,

        [Parameter()]
		[DateTime]
        $StartDate,
    
        [Parameter()]
		[DateTime]
        $FinishDate,

		[Parameter()]
		[object]
		$Project,

		[Parameter()]
		[object]
		$Collection
	)

    Process
    {
		return _NewCssNode -Path $Iteration -Scope Iteration -Project $Project -Collection $Collection -StartDate $StartDate -FinishDate $FinishDate
    }
}
<#
#>
Function Remove-TfsArea
{
	[CmdletBinding(ConfirmImpact='High', SupportsShouldProcess=$true)]
	Param
	(
		[Parameter(Mandatory=$true, Position=0, ValueFromPipeline=$true)]
		[Alias("Path")]
		[ValidateScript({($_ -is [string]) -or ($_ -is [Microsoft.TeamFoundation.Server.NodeInfo])})] 
		[object]
		$Area,

		[Parameter(Position=1)]
		[Alias("NewPath")]
		[ValidateScript({ ($_ -is [string]) -or ($_ -is [Microsoft.TeamFoundation.Server.NodeInfo]) })] 
		[object]
		$MoveTo = '\',

		[Parameter()]
		[object]
		$Project,

		[Parameter()]
		[object]
		$Collection
	)

	Process
	{
		$Areas = Get-TfsArea -Area $Area -Project $Project -Collection $Collection | Sort -Property Path -Descending

		foreach($i in $Areas)
		{
			if ($PSCmdlet.ShouldProcess($i.RelativePath, "Delete Area"))
			{
				$projectName = $i.Path.Split("\")[1]
				_DeleteCssNode -Node $i -MoveToNode $MoveTo -Scope Area -Project $projectName -Collection $Collection
			}
		}
	}
}
<#
#>
Function Remove-TfsIteration
{
	[CmdletBinding(ConfirmImpact='High', SupportsShouldProcess=$true)]
	Param
	(
		[Parameter(Mandatory=$true, Position=0, ValueFromPipeline=$true)]
		[Alias("Path")]
		[ValidateScript({($_ -is [string]) -or ($_ -is [Microsoft.TeamFoundation.Server.NodeInfo])})] 
		[object]
		$Iteration,

		[Parameter(Position=1)]
		[Alias("NewPath")]
		[ValidateScript({ ($_ -is [string]) -or ($_ -is [Microsoft.TeamFoundation.Server.NodeInfo]) })] 
		[object]
		$MoveTo = '\',

		[Parameter()]
		[object]
		$Project,

		[Parameter()]
		[object]
		$Collection
	)

	Process
	{
		$iterations = Get-TfsIteration -Iteration $Iteration -Project $Project -Collection $Collection | Sort -Property Path -Descending

		foreach($i in $iterations)
		{
			if ($PSCmdlet.ShouldProcess($i.RelativePath, "Delete Iteration"))
			{
				$projectName = $i.Path.Split("\")[1]
				_DeleteCssNode -Node $i -MoveToNode $MoveTo -Scope Iteration -Project $Project -Collection $Collection
			}
		}
	}
}
<#
#>
Function Rename-TfsArea
{
	[CmdletBinding()]
    Param
    (
		[Parameter(Mandatory=$true, Position=0, ValueFromPipeline=$true)]
		[ValidateScript({($_ -is [string]) -or ($_ -is [Microsoft.TeamFoundation.Server.NodeInfo])})] 
		[Alias("Path")]
		[object]
		$Area,

		[Parameter(Position=1)]
		[string]
		$NewName,

		[Parameter()]
		[object]
		$Project,

		[Parameter()]
		[object]
		$Collection
	)

    Process
    {
		Set-TfsArea -Area $Area -NewName $NewName -Project $Project -Collection $Collection
    }
}
<#
#>
Function Rename-TfsIteration
{
	[CmdletBinding()]
    Param
    (
		[Parameter(Mandatory=$true, Position=0, ValueFromPipeline=$true)]
		[ValidateScript({($_ -is [string]) -or ($_ -is [Microsoft.TeamFoundation.Server.NodeInfo])})] 
		[Alias("Path")]
		[object]
		$Iteration,

		[Parameter(Position=1)]
		[string]
		$NewName,

		[Parameter()]
		[object]
		$Project,

		[Parameter()]
		[object]
		$Collection
	)

    Process
    {
		Set-TfsIteration -Iteration $Iteration -NewName $NewName -Project $Project -Collection $Collection
    }
}
<#
#>
Function Set-TfsArea
{
	[CmdletBinding()]
    Param
    (
		[Parameter(Mandatory=$true, Position=0, ValueFromPipeline=$true)]
		[ValidateScript({($_ -is [string]) -or ($_ -is [Microsoft.TeamFoundation.Server.NodeInfo])})] 
		[Alias("Path")]
		[object]
		$Area,

		[Parameter()]
		[string]
		$NewName,

		[Parameter()]
		[int]
		$MoveBy,

		[Parameter()]
		[object]
		$Project,

		[Parameter()]
		[object]
		$Collection
	)

    Process
    {
		$node = Get-TfsArea -Area $Area -Project $Project -Collection $Collection

		if (-not $node)
		{
			throw "Invalid or non-existent area $Area"
		}

		$cssService = _GetCssService -Project $Project -Collection $Collection

		if ($NewName)
		{
			$cssService.RenameNode($node.Uri, $NewName)
		}

		if ($MoveBy)
		{
			$cssService.ReorderNode($node.Uri, $MoveBy)
		}

		return $cssService.GetNode($node.Uri)
    }
}
<#
.SYNOPSIS
	Set Iteration Dates of an specific Iteration of one Team Project.

.PARAMETER Collection
	Specifies either�a�URL�or�the�name�of�the�Team�Project�Collection�to�connect�to,�or�a�previously�initialized�TfsTeamProjectCollection�object.
	For�more�details,�see�the�-Collection�argument�in�the�Get-TfsTeamProjectCollection�cmdlet.

.PARAMETER Project
	Specifies either the�name of the Team Project or a previously initialized Microsoft.TeamFoundation.WorkItemTracking.Client.Project object to connect to.�
	For�more�details,�see�the�-Project�argument�in�the�Get-TfsTeamProject�cmdlet. 

.EXAMPLE
	xxxx.
#>
Function Set-TfsIteration
{
	[CmdletBinding()]
    Param
    (
		[Parameter(Position=0, Mandatory=$true, ValueFromPipeline=$true)]
		[Alias("Path")]
		[ValidateScript({($_ -is [string]) -or ($_ -is [Microsoft.TeamFoundation.Server.NodeInfo])})] 
		[object]
		$Iteration = '\**',

		[Parameter()]
		[string]
		$NewName,

		[Parameter()]
		[int]
		$MoveBy,

        [Parameter()]
		[Nullable[DateTime]]
        $StartDate,
    
        [Parameter()]
		[Nullable[DateTime]]
        $FinishDate,

		[Parameter()]
		[object]
		$Project,

		[Parameter()]
		[object]
		$Collection
    )

    Process
    {
		$node = Get-TfsIteration -Iteration $Iteration -Project $Project -Collection $Collection

		if (-not $node)
		{
			throw "Invalid or non-existent iteration $Iteration"
		}

		$cssService = _GetCssService -Project $Project -Collection $Collection
		$cssService4 = _GetCssService -Project $Project -Collection $Collection -Version 4

		if ($NewName)
		{
			$cssService.RenameNode($node.Uri, $NewName)
		}

		if ($MoveBy)
		{
			$cssService.ReorderNode($node.Uri, $MoveBy)
		}

		if ($StartDate -or $FinishDate)
		{
			if (-not $PSBoundParameters.ContainsKey("StartDate"))
			{
				$StartDate = $node.StartDate
			}

			if (-not $PSBoundParameters.ContainsKey("FinishDate"))
			{
				$FinishDate = $node.FinishDate
			}

			[void]$cssService4.SetIterationDates($node.Uri, $StartDate, $FinishDate)
		}

        return $cssService.GetNode($node.Uri)
    }
}
Function _GetCssNodes($Node, $Scope, $Project, $Collection)
{
    Process
	{
		if ($Node -is [Microsoft.TeamFoundation.Server.NodeInfo])
		{
			return $Node
		}

		$tp = Get-TfsTeamProject -Project $Project -Collection $Collection
		$tpc = $tp.Store.TeamProjectCollection
		$projectName = $tp.Name
        $cssService = $tpc.GetService([type]"Microsoft.TeamFoundation.Server.ICommonStructureService")
        
		if ($node -is [uri])
		{
			return $cssService.GetNode($node)
		}

		$rootPath = _NormalizePath "$projectName\$Scope"
		$fullPath = _NormalizePath "$rootPath\$Node"

		$rootNodeUri = $cssService.GetNodeFromPath("$rootPath").Uri
		$rootElement = $cssService.GetNodesXml(@($rootNodeUri), $true)
		
		$nodePaths = $rootElement.SelectNodes('//@Path') | Select -ExpandProperty '#text'
		$matchingPaths = $nodePaths | ? { $_ -like $fullPath }

        return $matchingPaths | % { $cssService.GetNodeFromPath($_) }
    }
}

Function _DeleteCssNode($Node, $Scope, $MoveToNode, $Project, $Collection)
{
    Process
	{
		$newNode = _GetCssNodes -Node $MoveToNode -Scope $Scope -Project $Project -Collection $Collection
		$cssService = _GetCssService -Project $Project -Collection $Collection

		$cssService.DeleteBranches($Node.Uri, $newNode.Uri)        
    }
}

Function _NewCssNode ($Project, $Path, $Scope, $Collection, $StartDate, $FinishDate)
{
	Process
	{
		$tp = Get-TfsTeamProject -Project $Project -Collection $Collection
		$tpc = $tp.Store.TeamProjectCollection
		$projectName = $tp.Name
        $cssService = $tpc.GetService([type]"Microsoft.TeamFoundation.Server.ICommonStructureService")

        try
        {
			$fullPath = _NormalizePath "$projectName\$Scope\$Path"
			$parentPath = Split-Path $fullPath -Parent
			$nodeName = Split-Path $fullPath -Leaf
            $parentNode = $cssService.GetNodeFromPath($parentPath)
        }
        catch
        {
            $parentNode = _NewCssNode -Project $Project -Path $parentPath -Scope $Scope -Collection $Collection
        }

		if ($StartDate -or $FinishDate)
		{
			$cssService = $tpc.GetService([type]"Microsoft.TeamFoundation.Server.ICommonStructureService4")
			$nodeUri = $cssService.CreateNode($nodeName, $parentNode.Uri, $StartDate, $FinishDate)
		}
		else
		{
			$nodeUri = $cssService.CreateNode($nodeName, $parentNode.Uri)
		}

        return $cssService.GetNode($nodeUri)
    }
}

Function _NormalizePath($Path)
{
	if([string]::IsNullOrWhiteSpace($Path))
	{
		return [string]::Empty
	}

	$newPath = [System.Text.RegularExpressions.Regex]::Replace($Path, '\\{2,}', '\')

	if (-not $newPath.StartsWith("\"))
	{
		$newPath = "\$newPath"
	}

	if ($newPath.EndsWith("\"))
	{
		$newPath = $newPath.Substring(0, $newPath.Length-1)
	}

	return $newPath
}

Function _GetCssService($Project, $Collection, $Version)
{
	$tp = Get-TfsTeamProject -Project $Project -Collection $Collection
	$tpc = $tp.Store.TeamProjectCollection
	$projectName = $tp.Name

    return $tpc.GetService([type]"Microsoft.TeamFoundation.Server.ICommonStructureService$Version")
}
Tools\TfsCmdlets\ConfigServer\ConfigServer.psd1
 
Tools\TfsCmdlets\ConfigServer\ConfigServer.psm1
Function Get-TfsConfigurationServer
{
	[CmdletBinding()]
	[OutputType([Microsoft.TeamFoundation.Client.TfsConfigurationServer])]
	Param
	(
		[Parameter(Position=0)]
		[object] 
		$Server,
	
		[Parameter(Position=1)]
		[System.Management.Automation.Credential()]
		[System.Management.Automation.PSCredential]
		$Credential
	)

	Process
	{
		if ($Server -is [Microsoft.TeamFoundation.Client.TfsConfigurationServer])
		{
			return $Server
		}

		if ($Server -is [Uri])
		{
			return _GetConfigServerFromUrl $Server $Credential
		}

		if ($Server -is [string])
		{
			if ([Uri]::IsWellFormedUriString($Server, [UriKind]::Absolute))
			{
				return _GetConfigServerFromUrl ([Uri] $Server) $Credential
			}

			if (-not [string]::IsNullOrWhiteSpace($Server))
			{
				return _GetConfigServerFromName $Server $Credential
			}

			$Server = $null
		}

		if ($Server -eq $null)
		{
			if ($Global:TfsServerConnection)
			{
				return $Global:TfsServerConnection
			}
		}

		throw "No TFS connection information available. Either supply a valid -Server argument or use Connect-TfsConfigurationServer prior to invoking this cmdlet."
	}
}

# =================
# Helper Functions
# =================

Function _GetConfigServerFromUrl
{
	Param ($Url, $Cred)
	
	if ($Cred)
	{
		$configServer = New-Object Microsoft.TeamFoundation.Client.TfsConfigurationServer -ArgumentList ([Uri] $Url), ([System.Net.NetworkCredential] $cred)
	}
	else
	{
		$configServer = [Microsoft.TeamFoundation.Client.TfsConfigurationServerFactory]::GetConfigurationServer([Uri] $Url)
	}


	$configServer.EnsureAuthenticated()
	return $configServer
}

Function _GetConfigServerFromName
{
	Param ($Name, $Cred)

	$Servers = Get-TfsRegisteredConfigurationServer $Name
	
	foreach($Server in $Servers)
	{
		if ($Cred)
		{
			$configServer = New-Object Microsoft.TeamFoundation.Client.TfsConfigurationServer -ArgumentList ($Server.Uri), ([System.Net.NetworkCredential] $cred)
		}
		else
		{
			$configServer = [Microsoft.TeamFoundation.Client.TfsConfigurationServerFactory]::GetConfigurationServer($Server)
		}

		$configServer.EnsureAuthenticated()
		$configServer
	}
}
Function Get-TfsConfigurationServerConnectionString
{
	[CmdletBinding()]
	[OutputType([string])]
	Param
	(
		[Parameter()]
		[string]
		[Alias('Session')]
		$Computer,

		[Parameter()]
		[string]
		$Version = '12.0',

		[Parameter()]
		[System.Management.Automation.Credential()]
		[System.Management.Automation.PSCredential]
		$Credential
	)

	Process
	{

		$scriptBlock = New-ScriptBlock -EntryPoint '_GetConnectionString' -Dependency 'Get-InstallationPath', 'Test-RegistryValue', 'Get-RegistryValue'

		return Invoke-ScriptBlock -ScriptBlock $scriptBlock -Computer $Computer -Credential $Credential -ArgumentList $Version
	}
}

Function _GetConnectionString($Version)
{
	$path = Get-InstallationPath -Version $Version -Component ApplicationTier
	$webConfigPath = Join-Path $path 'Web Services\Web.config'
	$webConfig = [xml] (Get-Content $webConfigPath)

	return (Select-Xml -Xml $webConfig -XPath '/configuration/appSettings/add[@key="applicationDatabase"]/@value').Node.Value
}
Function Get-TfsRegisteredConfigurationServer
{
	[CmdletBinding()]
	[OutputType([Microsoft.TeamFoundation.Client.RegisteredConfigurationServer[]])]
	Param
	(
		[Parameter(Position=0, ValueFromPipeline=$true)]
		[string]
		$Name = "*"
	)

	Process
	{
		if(($Name -eq "localhost") -or ($Name -eq "."))
		{
			$Name = $env:COMPUTERNAME
		}

		return [Microsoft.TeamFoundation.Client.RegisteredTfsConnections]::GetConfigurationServers() | ? Name -Like $Name
	}
}
Tools\TfsCmdlets\Connection\Connection.psd1
 
Tools\TfsCmdlets\Connection\Connection.psm1
<#
.SYNOPSIS

Connects to a Team Foundation Server configuration server.

.DESCRIPTION

The Connect-TfsConfigurationServer function connects to a TFS configuration server. Functions that operate on a server level (as opposed to those operation on a team project collection level) will use by default a connection opened by this function.

.NOTES

A TFS Configuration Server represents the server that is running Team Foundation Server. On a database level, it is represented by the Tfs_Configuration database. 

Operations that should be performed on a server level (such as setting server-level permissions) require a connection to a TFS configuration server. 

Internally, this connection is represented by an instance of the Microsoft.TeamFoundation.Client.TfsConfigurationServer class and is kept in a PowerShell global variable caled TfsServerConnection .

.LINK
https://msdn.microsoft.com/en-us/library/vstudio/microsoft.teamfoundation.client.tfsconfigurationserver(v=vs.120).aspx

#>
Function Connect-TfsConfigurationServer
{
	[CmdletBinding()]
	[OutputType([Microsoft.TeamFoundation.Client.TfsConfigurationServer])]
	Param
	(
		[Parameter(Mandatory=$true, Position=0, ValueFromPipeline=$true)]
		[object] 
		$Server,
	
		[Parameter(Position=1)]
		[System.Management.Automation.Credential()]
		[System.Management.Automation.PSCredential]
		$Credential,

		[Parameter()]
		[switch]
		$Passthru
	)

	Process
	{
		$configServer = (Get-TfsConfigurationServer -Server $Server -Credential $Credential | Select -First 1)

		if (-not $configServer)
		{
			throw "Error connecting to TFS"
		}

		$Global:TfsServerConnection = $configServer
		$Global:TfsServerConnectionCredential = $Credential

		if ($Passthru)
		{
			return $configServer
		}
	}
}
Function Connect-TfsTeamProject
{
	[CmdletBinding()]
	[OutputType([Microsoft.TeamFoundation.WorkItemTracking.Client.Project])]
	Param
	(
		[Parameter(Mandatory=$true, Position=0, ValueFromPipeline=$true)]
		[object] 
		$Project,
	
		[Parameter()]
		[object] 
		$Collection,
	
		[Parameter()]
		[System.Management.Automation.Credential()]
		[System.Management.Automation.PSCredential]
		$Credential,

		[Parameter()]
		[switch]
		$Passthru
	)

	Process
	{
		$tp = (Get-TfsTeamProject -Project $Project -Collection $Collection -Credential $Credential | Select -First 1)

		if (-not $tp)
		{
			throw "Error connecting to team project $Project"
		}

		$Global:TfsProjectConnection = $tp

		Connect-TfsTeamProjectCollection -Collection $tp.Store.TeamProjectCollection

		if ($Passthru)
		{
			return $tp
		}
	}
}
<#
.SYNOPSIS

	Connects to a TFS Team Project Collection. 

.DESCRIPTION

	The Connect-TfsTeamProjectCollection cmdlet "connects" (initializes a Microsoft.TeamFoundation.Client.TfsTeamProjectCollection object) to a TFS Team Project Collection. That connection is subsequently kept in a global variable to be later reused until it's closed by a call to Disconnect-TfsTeamProjectCollection.

	Most cmdlets in the TfsCmdlets module require a TfsTeamProjectCollection object to be provided via their -Collection argument in order to access a TFS instance. Those cmdlets will use the connection opened by Connect-TfsTeamProjectCollection as their "default connection". In other words, TFS cmdlets (e.g. New-TfsWorkItem) that have a -Collection argument will use the connection provided by Connect-TfsTeamProjectCollection by default.

.PARAMETER Collection

	Specifies either a URL/name of the Team Project Collection to connect to, or a previously initialized TfsTeamProjectCollection object. 

	For more details, see the -Collection argument in the Get-TfsTeamProjectCollection cmdlet.

.PARAMETER Server

	Specifies either a URL or the name of the Team Foundation Server configuration server (the "root" of a TFS installation) to connect to, or a previously initialized Microsoft.TeamFoundation.Client.TfsConfigurationServer object.

	For more details, see the -Server argument in the Get-TfsConfigurationServer cmdlet.

.PARAMETER Credential

	Specifies a user account that has permission to perform this action. The default is the current user.

	Type a user name, such as "User01" or "Domain01\User01", or enter a PSCredential object, such as one generated by the Get-Credential cmdlet. If you type a user name, you will be prompted for a password.

	To connect to Visual Studio Online you must enable Alternate Credentials for your user profile and supply that credential in this argument.

	For more information on Alternate Credentials for your Visual Studio Online account, please refer to https://msdn.microsoft.com/library/dd286572#setup_basic_auth.

.PARAMETER Passthru

	Returns the results of the command. By default, this cmdlet does not generate any output.

.EXAMPLE

	Connect-TfsTeamProjectCollection -Collection http://tfs:8080/tfs/DefaultCollection

	Connects to a collection called "DefaultCollection" in a TF server called "tfs" using the default credentials of the logged-on user

.LINK
	
	Get-TfsTeamProjectCollection

.LINK

	https://msdn.microsoft.com/en-us/library/microsoft.teamfoundation.client.tfsteamprojectcollection.aspx

#>
Function Connect-TfsTeamProjectCollection
{
	[CmdletBinding()]
	[OutputType([Microsoft.TeamFoundation.Client.TfsTeamProjectCollection])]
	Param
	(
		[Parameter(Mandatory=$true, Position=0, ValueFromPipeline=$true)]
		[object] 
		$Collection,
	
		[Parameter()]
		[object] 
		$Server,
	
		[Parameter()]
		[System.Management.Automation.Credential()]
		[System.Management.Automation.PSCredential]
		$Credential,

		[Parameter()]
		[switch]
		$Passthru
	)

	Process
	{
		$tpc = (Get-TfsTeamProjectCollection -Collection $Collection -Server $Server -Credential $Credential | Select -First 1)

		if (-not $tpc)
		{
			throw "Error connecting to team project collection $Collection"
		}

		$tpc.EnsureAuthenticated()

		$Global:TfsTpcConnection = $tpc
		$Global:TfsTpcConnectionCredential = $Credential

		Connect-TfsConfigurationServer -Server $tpc.ConfigurationServer

		if ($Passthru)
		{
			return $tpc
		}
	}
}
Function Disconnect-TfsConfigurationServer
{
	Process
	{
		Remove-Variable -Name TfsServerConnection -Scope Global
		Remove-Variable -Name TfsServerConnectionUrl -Scope Global
		Remove-Variable -Name TfsServerConnectionCredential -Scope Global
		Remove-Variable -Name TfsServerConnectionUseDefaultCredentials -Scope Global
	}
}
Function Disconnect-TfsTeamProject
{
	Process
	{
		Remove-Variable -Name TfsProjectConnection -Scope Global
	}
}
<#
.SYNOPSIS

	Disconnects from the currently connected TFS Team Project Collection

.DESCRIPTION

	The Disconnect-TfsTeamProjectCollection removes the global variable set by Connect-TfsTeamProjectCollection. Therefore, cmdlets relying on a "default collection" as provided by Connect-TfsTeamProjectCollection will no longer work after a call to this cmdlets, unless their -Collection argument is provided or a new call to Connect-TfsTeamProjectCollection is made.

.EXAMPLE

	Disconnect-TfsTeamProjectCollection

	Disconnects from the currently connected TFS Team Project Collection

#>
Function Disconnect-TfsTeamProjectCollection
{
	Process
	{
		Remove-Variable -Name TfsTpcConnection -Scope Global
		Remove-Variable -Name TfsTpcConnectionUrl -Scope Global
		Remove-Variable -Name TfsTpcConnectionCredential -Scope Global
		Remove-Variable -Name TfsTpcConnectionUseDefaultCredentials -Scope Global
	}
}
Tools\TfsCmdlets\Git\Git.psd1
 
Tools\TfsCmdlets\Git\Git.psm1
Function New-TfsGitRepository
{
    param
    (
        [Parameter(Mandatory=$true)]
        [string] 
        $ProjectName,
    
        [Parameter(Mandatory=$true, ValueFromPipeline=$true)]
        [string] 
        $Name
    )

	Begin
	{
        #TO-DO: Fix this call (convert to Get-...)
        $connection = _GetRestConnection 
	}

    Process
    {
        $project = Get-TfsTeamProjectInformation -Name $ProjectName
        $id = $project.id
        $apiUrl = _GetUrl $CollectionUrl "_apis/git/repositories?api-version=1.0"
        $body = "{`"name`": `"${Name}`", `"project`": { `"id`": `"${id}`" } }"
    
        if ($connection.UseDefaultCredentials)
        {
            Invoke-RestMethod -Uri $apiUrl -UseDefaultCredentials -Method "POST" -Body $body -ContentType "application/json"
        }
        else
        {
            Invoke-RestMethod -Uri $apiUrl -Credential $Credential -Method "POST" -Body $body -ContentType "application/json"
        }
    }
}

Tools\TfsCmdlets\GlobalList\GlobalList.psd1
 
Tools\TfsCmdlets\GlobalList\GlobalList.psm1
Function Export-TfsGlobalList
{
	[CmdletBinding()]
	[OutputType([xml])]
    Param
    (
        [Parameter()]
        [string] 
        $Name = "*",
    
        [Parameter()]
        [object]
        $Collection
    )

    Process
    {
        $tpc = Get-TfsTeamProjectCollection $Collection
        $store = $tpc.GetService([type]'Microsoft.TeamFoundation.WorkItemTracking.Client.WorkItemStore')

        $xml = [xml] $store.ExportGlobalLists()

        $procInstr = $xml.CreateProcessingInstruction("xml", 'version="1.0"')

        [void] $xml.InsertBefore($procInstr, $xml.DocumentElement)

        $nodesToRemove = $xml.SelectNodes("//GLOBALLIST") #| ? ([System.Xml.XmlElement]$_).GetAttribute("name") -NotLike $Name

        foreach($node in $nodesToRemove)
        {
			if (([System.Xml.XmlElement]$node).GetAttribute("name") -notlike $Name)
			{
				[void]$xml.DocumentElement.RemoveChild($node)
			}
        }

        return $xml
    }
}
Function Get-TfsGlobalList
{
	[CmdletBinding()]
    Param
    (
        [Parameter()]
        [string] 
        $Name = "*",
    
        [Parameter()]
        [object]
        $Collection
    )

    Process
    {
        $xml = Export-TfsGlobalList @PSBoundParameters

        foreach($listNode in $xml.SelectNodes("//GLOBALLIST"))
		{
			$list = [PSCustomObject] [ordered] @{
				Name = $listNode.GetAttribute("name")
				Items = @()
			}

			foreach($itemNode in $listNode.SelectNodes("LISTITEM"))
			{
				$list.Items += $itemNode.GetAttribute("value")
			}

			$list
		}
    }
}
Function Import-TfsGlobalList
{
	[CmdletBinding()]
    Param
    (
        [Parameter(Mandatory=$true)]
        [xml] 
        $Xml,
    
        [Parameter()]
        [object]
        $Collection
    )

    Process
    {
        $tpc = Get-TfsTeamProjectCollection $Collection
        $store = $tpc.GetService([type]'Microsoft.TeamFoundation.WorkItemTracking.Client.WorkItemStore')

        [void] $store.ImportGlobalLists($Xml.OuterXml)
    }
}
Function New-TfsGlobalList
{
    Param
    (
        [Parameter(Mandatory=$true)]
        [string] 
        $Name,
    
        [Parameter(Mandatory=$true)] 
        [string[]] 
        $Items,

        [Parameter()]
        [switch]
        $Force,

        [Parameter()]
        [object]
        $Collection
    )

    Process
    {
        [xml] $xml = Export-TfsGlobalList -Collection $Collection

        # Checks whether the global list already exists
        $list = $xml.SelectSingleNode("//GLOBALLIST[@name='$Name']")

        if ($list -ne $null)
        {
            if ($Force.IsPresent)
            {
                [void] $list.ParentNode.RemoveChild($list)
                $overwritten = $true
            }
            else
            {
                Throw "Global List $Name already exists. To overwrite an existing list, use the -Force switch."
            }
        }

        # Creates the new list XML element
        $list = $xml.CreateElement("GLOBALLIST")
        $list.SetAttribute("name", $Name)

        # Adds the item elements to the list
        foreach($item in $Items)
        {
            $itemElement = $xml.CreateElement("LISTITEM")
            [void] $itemElement.SetAttribute("value", $item)
            [void]$list.AppendChild($itemElement)
        }

        # Appends the new list to the XML obj
        [void] $xml.DocumentElement.AppendChild($list)

        # Saves the list back to TFS
        Import-TfsGlobalList -Xml $xml -Collection $Collection

        return Get-TfsGlobalList -Name $Name -Collection $Collection
    }
}
Function Remove-TfsGlobalList
{
	[CmdletBinding(ConfirmImpact="High", SupportsShouldProcess=$true)]
    Param
    (
        [Parameter(ValueFromPipelineByPropertyName="Name")]
        [string] 
        $Name = "*",
    
        [Parameter()]
        [object]
        $Collection
    )

	Process
	{
		$tpc = Get-TfsTeamProjectCollection $Collection
		$store = $tpc.GetService([type]'Microsoft.TeamFoundation.WorkItemTracking.Client.WorkItemStore')

		$lists = Get-TfsGlobalList -Name $Name -Collection $Collection
		$listsToRemove = @()

		foreach($list in $lists)
		{
			if ($PSCmdlet.ShouldProcess($list.Name, "Remove global list"))
			{
				$listsToRemove += $list
			}
		}

		if ($listsToRemove.Length -eq 0)
		{
			return
		}

		$xml = [xml] "<Package />"

		foreach($list in $listsToRemove)
		{
			$elem = $xml.CreateElement("DestroyGlobalList");
			$elem.SetAttribute("ListName", "*" + $list.Name);
			$elem.SetAttribute("ForceDelete", "true");
			[void]$xml.DocumentElement.AppendChild($elem);
		}

		$returnElem = $null

		$store.SendUpdatePackage($xml.DocumentElement, [ref] $returnElem, $false)
	}
}
Function Set-TfsGlobalList
{
    Param
    (
        [Parameter(Mandatory=$true)]
        [string] 
        $Name,
    
		[Parameter(ParameterSetName="Edit list items")]
        [string[]] 
        $Add,

		[Parameter(ParameterSetName="Edit list items")]
        [string[]] 
        $Remove,

		[Parameter(ParameterSetName="Rename list", Mandatory=$true)]
        [string] 
        $NewName,

		[Parameter(ParameterSetName="Edit list items")]
        [switch] 
        $Force,

        [object]
        $Collection
    )

    Process
    {
        [xml] $xml = Export-TfsGlobalList -Name $Name -Collection $Collection

        # Retrieves the list
        $list = $xml.SelectSingleNode("//GLOBALLIST")
        $newList = $false

        if ($list -eq $null)
        {
            if (-not $Force.IsPresent)
            { 
                throw "Global list name $Name is invalid or non-existent. Either check the name or use -Force to create a new list."
            }
            
            # Creates the new list XML element
            $list = $xml.CreateElement("GLOBALLIST")
            [void] $list.SetAttribute("name", $Name)
            [void] $xml.DocumentElement.AppendChild($list)
            $newList = $true
        }

		if ($PSCmdlet.ParameterSetName -eq "Rename list")
		{
			$list.SetAttribute("name", $NewName)
			Import-TfsGlobalList -Xml $xml -Collection $Collection

			Remove-TfsGlobalList -Name $Name -Collection $Collection -Confirm:$false

			return Get-TfsGlobalList -Name $NewName -Collection $Collection
		}


        foreach($item in $Add)
        {
            if (-not $newList)
            {
                # Checks if the element exists (prevents duplicates)
                $existingItem = $list.SelectSingleNode("LISTITEM[@value='$item']")
                if ($existingItem -ne $null) { continue }
            }

            $itemElement = $xml.CreateElement("LISTITEM")
            [void] $itemElement.SetAttribute("value", $item)
            [void]$list.AppendChild($itemElement)
        }
        
        if (-not $newList)
        {
			foreach($item in $Remove)
			{
				$existingItem = $list.SelectSingleNode("LISTITEM[@value='$item']")
				
				if ($existingItem)
				{
					[void]$list.RemoveChild($existingItem)
				}
			}
		}
		        
        # Saves the list back to TFS
        Import-TfsGlobalList -Xml $xml -Collection $Collection

        return Get-TfsGlobalList -Name $Name -Collection $Collection
    }
}
Tools\TfsCmdlets\ProcessTemplate\ProcessTemplate.psd1
 
Tools\TfsCmdlets\ProcessTemplate\ProcessTemplate.psm1
Function Export-TfsProcessTemplate
{
    Param
    (
        [Parameter(Position=0)]
        [object]
        $Process = "*",

        [Parameter(Mandatory=$true)]
        [string]
        $DestinationPath,

        [Parameter()]
        [ValidateNotNullOrEmpty()]
        [string]
        $NewName,

        [Parameter()]
        [ValidateNotNullOrEmpty()]
        [string]
        $NewDescription,

        [Parameter(ValueFromPipeline=$true)]
        [Microsoft.TeamFoundation.Client.TfsTeamProjectCollection]
        $Collection
    )

    Process
    {
        $tpc = Get-TfsTeamProjectCollection $Collection
        $processTemplateSvc = $tpc.GetService([type]"Microsoft.TeamFoundation.Server.IProcessTemplates")

        if ($Process -is [Microsoft.TeamFoundation.Server.TemplateHeader])
        {
            $templates = @($Process)
        }
        else
        {
            $templates = Get-TfsProcessTemplate $Process -Collection $Collection
        }

        if ($NewName -or $NewDescription)
        {
            $templates = $templates | select -First 1
        }

        foreach($template in $templates)
        {
            if ($NewName)
            {
                $templateName = $NewName
            }
            else
            {
                $templateName = $template.Name
            }

            $tempFile = $processTemplateSvc.GetTemplateData($template.TemplateId)
            $zipFile = "$tempFile.zip"
            Rename-Item -Path $tempFile -NewName (Split-Path $zipFile -Leaf)

            $outDir = Join-Path $DestinationPath $templateName
            New-Item $outDir -ItemType Directory -Force | Out-Null

            Expand-Archive -Path $zipFile -DestinationPath $outDir

            if ($NewName -or $NewDescription)
            {
                $ptFile = (Join-Path $outDir "ProcessTemplate.xml")
                $ptXml = [xml] (Get-Content $ptFile)

                if ($NewName)
                {
                    $ptXml.ProcessTemplate.metadata.name = $NewName
                }

                if ($NewDescription)
                {
                    $ptXml.ProcessTemplate.metadata.description = $NewDescription
                }

                $ptXml.Save($ptFile)
            }

            Remove-Item $zipFile
        }
    }
}
Function Get-TfsProcessTemplate
{
    Param
    (
        [Parameter(Position=0)]
        [string]
        $Name = "*",

        [Parameter(ValueFromPipeline=$true)]
        [object]
        $Collection
    )

    Process
    {
        $tpc = Get-TfsTeamProjectCollection $Collection
        $processTemplateSvc = $tpc.GetService([type]"Microsoft.TeamFoundation.Server.IProcessTemplates")
        $templateHeaders = $processTemplateSvc.TemplateHeaders() | ? Name -Like $Name

        foreach($templateHeader in $templateHeaders)
        {
            $templateHeader | Add-Member Collection $tpc.DisplayName -PassThru
        }
    }
}
Tools\TfsCmdlets\Team\Team.psd1
 
Tools\TfsCmdlets\Team\Team.psm1
Function Get-TfsTeam
{
    param
    (
        [Parameter(Mandatory=$true)]
        [string] 
        $ProjectName,
    
        [Parameter(Mandatory=$true, ValueFromPipeline=$true)]
        [string] 
        $Name
    )

    Process
    {
        $team = _GetTeam $ProjectName $Name

        return [PSCustomObject] [ordered] @{
            Name = $team.Name;
            Description = $team.Description;
            Picture = "(Not Implemented)";
            WorkingDays = "(Not Implemented)";
            TeamFieldValues = "(Not Implemented)";
            ShowBugsInBacklog = "(Not Implemented)";
            Default = "(Not Implemented)";
            Id = $team.Identity.TeamFoundationId
        }
    }
}
Function New-TfsTeam
{
    param
    (
        [Parameter(Mandatory=$true, ValueFromPipeline=$true)]
        [string] 
        $Name,
    
        [Parameter(Mandatory=$true)]
        [string] 
        $Project,
    
        [Parameter()]
        [string] 
        $Description,
    
        [Parameter()]
        [string] 
        $Picture,
    
        [Parameter()]
        [System.DayOfWeek[]] 
        $WorkingDays,
    
        [Parameter()]
        [switch] 
        $ShowBugsInBacklog,
    
		[Parameter()] 
		[Microsoft.TeamFoundation.Client.TfsTeamProjectCollection] 
		$Collection,

        [Parameter()]
        [switch] 
        $Default
    )

    Process
    {
        $tpc = Get-TfsTeamProjectCollection -Collection $Collection

        $teamProject = Get-TfsTeamProject $Project
        $team = _CreateTeam $teamProject $Name $Description

		return $team
    }
}
Function Remove-TfsTeam
{
}
Function Set-TfsTeam
{
    param
    (
        [Parameter(Mandatory=$true)]
        [string] 
        $ProjectName,
    
        [Parameter(Mandatory=$true, ValueFromPipeline=$true)]
        [string] 
        $Name,
    
        [Parameter()]
        [string] 
        $NewName,
    
        [Parameter()]
        [string] 
        $Description,
    
        [Parameter()]
        [string] 
        $Picture,
    
        [Parameter()]
        [System.DayOfWeek[]] 
        $WorkingDays,
    
        [Parameter()]
        [switch] 
        $ShowBugsInBacklog
    )

    Process
    {
        $team = _GetTeam -ProjectName $ProjectName -Name $Name

        if ($NewName)
        {
        }
    }
}
Function _GetTeam
{
    param
    (
        [Parameter()]
        [string] 
        $ProjectName,
    
        [Parameter()]
        [string] 
        $Name
    )

    Begin
    {
        $tpc = Get-TfsTeamProjectCollection -Current
        $teamService = $tpc.GetService([type]"Microsoft.TeamFoundation.Client.TfsTeamService")
    }

    Process
    {
        $teamProject = Get-TfsTeamProject $projectName
        $team = ($teamService.QueryTeams($teamProject.Uri) | where Name -eq $name)

        return $team
    }
}

Function _CreateTeam
{
    param
    (
    )

    Process
    {
        $teamService = $tpc.GetService([type]"Microsoft.TeamFoundation.Client.TfsTeamService")
        return $teamService.CreateTeam($teamProject.Uri, $Name, $Description, $null)
    }
}

Function _SetTeamSettings
{
    param
    (
        $team, 
        
        [string[]]
        $teamFieldValues        
    )
}

function Get-TfsTeamSettingsConfigurationService {
    Param(
        [Microsoft.TeamFoundation.Client.TfsTeamProjectCollection] $TfsCollection
        )
    return $TfsCollection.GetService([ Microsoft.TeamFoundation.ProcessConfiguration.Client.TeamSettingsConfigurationService]);
} 
 
function Add-TfsTeamField {
Param(
       [parameter(Mandatory=$true)][Microsoft.TeamFoundation.Client.TfsTeamProjectCollection] $TfsCollection,
       [parameter(Mandatory=$true)][Microsoft.TeamFoundation.Server.ProjectInfo] $TfsTeamProject,
       [parameter(Mandatory=$true)][Microsoft.TeamFoundation.Client.TeamFoundationTeam] $TfsTeam,
       [parameter(Mandatory=$true)][String] $TeamFieldValue
       )
 
    $TfsTeamConfigService = Get-TfsTeamSettingsConfigurationService $TfsCollection
    $TfsTeamConfig = $TfsTeamConfigService.GetTeamConfigurations([Guid[]]($TfsTeam.Identity.TeamFoundationId))
 
    $newTeamFieldValue = New-Object Microsoft.TeamFoundation.ProcessConfiguration.Client.TeamFieldValue
    $newTeamFieldValue.Value = $TeamFieldValue
 
    $TfsTeamConfig.TeamSettings.TeamFieldValues = [Microsoft.TeamFoundation.ProcessConfiguration.Client.TeamFieldValue[]]($newTeamFieldValue)
    $TfsTeamConfig.TeamSettings.BacklogIterationPath = "$($TfsTeamProject.Name)" 
    #$TfsTeamConfig.TeamSettings.IterationPaths = [string[]]("$($TfsTeamProject.Name)")
 
    $TfsTeamConfigService.SetTeamSettings($TfsTeam.Identity.TeamFoundationId,$TfsTeamConfig.TeamSettings)
} 
Tools\TfsCmdlets\TeamProject\TeamProject.psd1
 
Tools\TfsCmdlets\TeamProject\TeamProject.psm1
<#
.SYNOPSIS

	Gets a TFS Team Project. 

.DESCRIPTION

	The Get-TfsTeamProject cmdlets gets one or more Team Project objects (an instance of Microsoft.TeamFoundation.WorkItemTracking.Client.Project) from the supplied Team Project Collection.

.PARAMETER Project

	Specifies the name of a Team Project. Wildcards are supported.

.PARAMETER Collection

	Specifies either a URL or the name of the Team Project Collection to connect to, or a previously initialized TfsTeamProjectCollection object. 

	For more details, see the -Collection argument in the Get-TfsTeamProjectCollection cmdlet.

.PARAMETER Server

	Specifies either a URL or the name of the Team Foundation Server configuration server (the "root" of a TFS installation) to connect to, or a previously initialized Microsoft.TeamFoundation.Client.TfsConfigurationServer object.

	For more details, see the -Server argument in the Get-TfsTeamProjectCollection cmdlet.

.PARAMETER Credential

	Specifies a user account that has permission to perform this action. The default is the current user.

	Type a user name, such as "User01" or "Domain01\User01", or enter a PSCredential object, such as one generated by the Get-Credential cmdlet. If you type a user name, you will be prompted for a password.

	To connect to Visual Studio Online you must enable Alternate Credentials for your user profile and supply that credential in this argument.

	For more information on Alternate Credentials for your Visual Studio Online account, please refer to https://msdn.microsoft.com/library/dd286572#setup_basic_auth.

.INPUTS

	Microsoft.TeamFoundation.Client.TfsTeamProjectCollection

.NOTES

	As with most cmdlets in the TfsCmdlets module, this cmdlet requires a TfsTeamProjectCollection object to be provided via the -Collection argument. If absent, it will default to the connection opened by Connect-TfsTeamProjectCollection.

#>
Function Get-TfsTeamProject
{
    [CmdletBinding()]
	[OutputType([Microsoft.TeamFoundation.WorkItemTracking.Client.Project])]
    Param
    (
        [Parameter(Position=0)]
        [object] 
        $Project = '*',

        [Parameter(ValueFromPipeline=$true, Position=1)]
        [object]
        $Collection,

		[Parameter()]
		[System.Management.Automation.Credential()]
		[System.Management.Automation.PSCredential]
		$Credential
    )

    Process
    {
		if ($Project -is [Microsoft.TeamFoundation.WorkItemTracking.Client.Project])
		{
			return $Project
		}

		if ($Project -is [string])
		{
			$tpc = Get-TfsTeamProjectCollection $Collection -Credential $Credential
        
			$wiStore = $tpc.GetService([type]'Microsoft.TeamFoundation.WorkItemTracking.Client.WorkItemStore')

			return _GetAllProjects $tpc | ? Name -Like $Project | % { $wiStore.Projects[$_.Name] }
		}

		if ($Project -eq $null)
		{
			if ($TfsProjectConnection)
			{
				return $TfsProjectConnection
			}
		}

		throw "No TFS team project information available. Either supply a valid -Project argument or use Connect-TfsTeamProject prior to invoking this cmdlet."
    }
}

Function _GetAllProjects
{
    param ($tpc)

    $css = $tpc.GetService([type]'Microsoft.TeamFoundation.Server.ICommonStructureService')

    return $css.ListAllProjects() | ? Status -eq WellFormed
}
Tools\TfsCmdlets\TeamProjectCollection\TeamProjectCollection.psd1
 
Tools\TfsCmdlets\TeamProjectCollection\TeamProjectCollection.psm1
<#
#>
Function Dismount-TfsTeamProjectCollection
{
	[CmdletBinding(ConfirmImpact="High", SupportsShouldProcess=$true)]
	Param
	(
		[Parameter(Mandatory=$true, Position=0)]
		[object] 
		$Collection,

		[Parameter(ValueFromPipeline=$true)]
		[object] 
		$Server,
	
		[Parameter()]
		[string]
		$Reason,
	
		[Parameter()]
		[timespan]
		$Timeout = [timespan]::MaxValue,

		[Parameter()]
		[System.Management.Automation.Credential()]
		[System.Management.Automation.PSCredential]
		$Credential
	)

	Process
	{
		$tpc = Get-TfsTeamProjectCollection -Collection $Collection -Server $Server -Credential $Credential

		if ($PSCmdlet.ShouldProcess($tpc.Name, "Detach Project Collection"))
		{
			$configServer = $tpc.ConfigurationServer
			$tpcService = $configServer.GetService([type] 'Microsoft.TeamFoundation.Framework.Client.ITeamProjectCollectionService')
			$collectionInfo = $tpcService.GetCollection($tpc.InstanceId)
			$connectionString = $null

			$tpcJob = $tpcService.QueueDetachCollection($collectionInfo, $null, $Reason, [ref] $connectionString)
			$collectionInfo = $tpcService.WaitForCollectionServicingToComplete($tpcJob, $Timeout)

			return $connectionString
		}
	}
}
<#
.SYNOPSIS

.DESCRIPTION

.PARAMETER computername

.PARAMETER filePath

.EXAMPLE

.EXAMPLE

#>
Function Get-TfsRegisteredTeamProjectCollection
{
	[CmdletBinding()]
	[OutputType([Microsoft.TeamFoundation.Client.RegisteredProjectCollection[]])]
	Param
	(
		[Parameter(Position=0, ValueFromPipeline=$true)]
		[string]
		$Name = "*"
	)

	Process
	{
		return [Microsoft.TeamFoundation.Client.RegisteredTfsConnections]::GetProjectCollections() | ? DisplayName -Like $Name
	}
}
<#
.SYNOPSIS
	Gets a TFS Team Project Collection.

.DESCRIPTION
	The Get-TfsTeamProject cmdlets gets one or more Team Project Collection objects (an instance of Microsoft.TeamFoundation.Client.TfsTeamProjectCollection) from a TFS instance. 
	Team Project Collection objects can either be obtained by providing a fully-qualified URL to the collection or by collection name (in which case a TFS Configuration Server object is required).

.PARAMETER Collection
	
Specifies either a URL/name of the Team Project Collection to connect to, or a previously initialized TfsTeamProjectCollection object. 
When using a URL, it must be fully qualified. The format of this string is as follows:
http[s]://<ComputerName>:<Port>/[<TFS-vDir>/]<CollectionName>
Valid values for the Transport segment of the URI are HTTP and HTTPS. If you specify a connection URI with a Transport segment, but do not specify a port, the session is created with standards ports: 80 for HTTP and 443 for HTTPS.
To connect to a Team Project Collection by using its name, a TfsConfigurationServer object must be supplied either via -Server argument or via a previous call to the Connect-TfsConfigurationServer cmdlet.
Finally, if a TfsTeamProjectCollection object is provided via this argument, it will be used as the new default connection. This may be especially useful if you e.g. received a pre-initialized connection to a TFS collection via a call to an external library or API.


.PARAMETER Server
	Specifies either a URL/name of the Team Foundation Server configuration server (the "root" of a TFS installation) to connect to, or a previously initialized Microsoft.TeamFoundation.Client.TfsConfigurationServer object.

.PARAMETER Credential
	Specifies a user account that has permission to perform this action. The default is the current user.
	Type a user name, such as "User01" or "Domain01\User01", or enter a PSCredential object, such as one generated by the Get-Credential cmdlet. If you type a user name, you will be prompted for a password.
	To connect to Visual Studio Online you must enable Alternate Credentials for your user profile and supply that credential in this argument.
	For more information on Alternate Credentials for your Visual Studio Online account, please refer to https://msdn.microsoft.com/library/dd286572#setup_basic_auth.

.EXAMPLE
	Get-TfsTeamProjectCollection http://

.INPUTS
	Microsoft.TeamFoundation.Client.TfsConfigurationServer

.NOTES
	Cmdlets in the TfsCmdlets module that operate on a collection level require a TfsConfigurationServer object to be provided via the -Server argument. If absent, it will default to the connection opened by Connect-TfsConfigurationServer.
#>
Function Get-TfsTeamProjectCollection
{
	[CmdletBinding()]
	[OutputType([Microsoft.TeamFoundation.Client.TfsTeamProjectCollection])]
	Param
	(
		[Parameter(Position=0)]
		[object] 
		$Collection = "*",
	
		[Parameter(ValueFromPipeline=$true)]
		[object] 
		$Server,
	
		[Parameter()]
		[System.Management.Automation.Credential()]
		[System.Management.Automation.PSCredential]
		$Credential
	)

	Process
	{
		if ($Collection -is [Microsoft.TeamFoundation.Client.TfsTeamProjectCollection])
		{
			return $Collection
		}

		if ($Collection -is [Uri])
		{
			return _GetCollectionFromUrl $Collection $Credential
		}

		if ($Collection -is [string])
		{
			if ([Uri]::IsWellFormedUriString($Collection, [UriKind]::Absolute))
			{
				return _GetCollectionFromUrl ([Uri] $Collection) $Server $Credential
			}

			if (-not [string]::IsNullOrWhiteSpace($Collection))
			{
				return _GetCollectionFromName $Collection $Server $Credential
			}

			$Collection = $null
		}

		if ($Collection -eq $null)
		{
			if ($Global:TfsTpcConnection)
			{
				return $Global:TfsTpcConnection
			}
		}

		throw "No TFS connection information available. Either supply a valid -Collection argument or use Connect-TfsTeamProjectCollection prior to invoking this cmdlet."
	}
}

# =================
# Helper Functions
# =================

Function _GetCollectionFromUrl
{
	Param ($Url, $Cred)
	
	if ($Cred)
	{
		$tpc = New-Object Microsoft.TeamFoundation.Client.TfsTeamProjectCollection -ArgumentList $Url, (_GetCredential $cred)
	}
	else
	{
		$tpc = [Microsoft.TeamFoundation.Client.TfsTeamProjectCollectionFactory]::GetTeamProjectCollection([Uri] $Url)
	}

	return $tpc
}


Function _GetCollectionFromName
{
	Param
	(
		$Name, $Server, $Cred
	)
	Process
	{
		$configServer = Get-TfsConfigurationServer $Server -Credential $Cred
		$filter = [Guid[]] @([Microsoft.TeamFoundation.Framework.Common.CatalogResourceTypes]::ProjectCollection)
		
		$collections = $configServer.CatalogNode.QueryChildren($filter, $false, [Microsoft.TeamFoundation.Framework.Common.CatalogQueryOptions]::IncludeParents) 
		$collections = $collections | Select -ExpandProperty Resource | ? DisplayName -like $Name

		if ($collections.Count -eq 0)
		{
			throw "Invalid or non-existent Team Project Collection(s): $Name"
		}

		foreach($tpc in $collections)
		{
			$collectionId = $tpc.Properties["InstanceId"]
			$tpc = $configServer.GetTeamProjectCollection($collectionId)
			$tpc.EnsureAuthenticated()

			$tpc
		}

	}
}

Function _GetCredential
{
	Param ($Cred)

	if ($Cred)
	{
		return [System.Net.NetworkCredential] $Cred
	}
	
	return [System.Net.CredentialCache]::DefaultNetworkCredentials
}<#
#>
Function Mount-TfsTeamProjectCollection
{
	Param
	(
		[Parameter(Mandatory=$true, Position=0)]
		[string]
		$Name,

		[Parameter()]
		[string]
		$Description,

		[Parameter(ParameterSetName="Use database server", Mandatory=$true)]
		[string]
		$DatabaseServer,

		[Parameter(ParameterSetName="Use database server", Mandatory=$true)]
		[string]
		$DatabaseName,

		[Parameter(ParameterSetName="Use connection string", Mandatory=$true)]
		[string]
		$ConnectionString,

		[Parameter()]
		[ValidateSet("Started", "Stopped")]
		[string]
		$InitialState = "Started",

		[Parameter()]
		[switch]
		$Clone,

		[Parameter()]
		[int]
		$PollingInterval = 5,

		[Parameter()]
		[timespan]
		$Timeout = [timespan]::MaxValue,

		[Parameter(ValueFromPipeline=$true)]
		[object] 
		$Server,
	
		[Parameter()]
		[System.Management.Automation.Credential()]
		[System.Management.Automation.PSCredential]
		$Credential
	)
	Process
	{
		$configServer = Get-TfsConfigurationServer $Server -Credential $Credential
		$tpcService = $configServer.GetService([type] 'Microsoft.TeamFoundation.Framework.Client.ITeamProjectCollectionService')

		$servicingTokens = New-Object 'System.Collections.Generic.Dictionary[string,string]'

		if ($DatabaseName)
		{
			$servicingTokens["CollectionDatabaseName"] = $DatabaseName
		}

		if ($PSCmdlet.ParameterSetName -eq "Use database server")
		{
			$ConnectionString = "Data source=$DatabaseServer; Integrated Security=true; Initial Catalog=$DatabaseName"
		}

		try
		{
			Write-Progress -Id 1 -Activity "Attach team project collection" -Status "Attaching team project collection $Name" -PercentComplete 0

			$start = Get-Date

			# string databaseConnectionString, IDictionary<string, string> servicingTokens, bool cloneCollection, string name, string description, string virtualDirectory)

			$tpcJob = $tpcService.QueueAttachCollection(
				$ConnectionString,
				$servicingTokens, 
				$Clone.ToBool(),
				$Name,
				$Description,
				"~/$Name/")

			[void] $tpcService.WaitForCollectionServicingToComplete($tpcJob, $Timeout)

			return Get-TfsTeamProjectCollection -Server $Server -Credential $Credential -Collection $Name
		}
		finally
		{
			Write-Progress -Id 1 -Activity "Attach team project collection" -Completed
		}

		throw (New-Object 'System.TimeoutException' -ArgumentList "Operation timed out during creation of team project collection $Name")
	}
}
<#
#>
Function New-TfsTeamProjectCollection
{
	Param
	(
		[Parameter(Mandatory=$true, Position=0)]
		[string]
		$Name,

		[Parameter()]
		[string]
		$Description,

		[Parameter(ParameterSetName="Use database server", Mandatory=$true)]
		[string]
		$DatabaseServer,

		[Parameter(ParameterSetName="Use database server")]
		[string]
		$DatabaseName,

		[Parameter(ParameterSetName="Use connection string", Mandatory=$true)]
		[string]
		$ConnectionString,

		[Parameter()]
		[switch]
		$Default,

		[Parameter()]
		[switch]
		$UseExistingDatabase,

		[Parameter()]
		[ValidateSet("Started", "Stopped")]
		[string]
		$InitialState = "Started",

		[Parameter()]
		[int]
		$PollingInterval = 5,

		[Parameter()]
		[timespan]
		$Timeout = [timespan]::MaxValue,

		[Parameter(ValueFromPipeline=$true)]
		[object] 
		$Server,
	
		[Parameter()]
		[System.Management.Automation.Credential()]
		[System.Management.Automation.PSCredential]
		$Credential
	)

	Process
	{
		$configServer = Get-TfsConfigurationServer $Server -Credential $Credential
		$tpcService = $configServer.GetService([type] 'Microsoft.TeamFoundation.Framework.Client.ITeamProjectCollectionService')

		$servicingTokens = New-Object 'System.Collections.Generic.Dictionary[string,string]'

		$servicingTokens["SharePointAction"] = "None"
		$servicingTokens["ReportingAction"] = "None"

		if ($DatabaseName)
		{
			$servicingTokens["CollectionDatabaseName"] = $DatabaseName
		}

		if ($UseExistingDatabase)
		{
			$servicingTokens["UseExistingDatabase"] = $UseExistingDatabase.ToBool()
		}

		if ($PSCmdlet.ParameterSetName -eq "Use database server")
		{
			$ConnectionString = "Data source=$DatabaseServer; Integrated Security=true"
		}

		try
		{
			Write-Progress -Id 1 -Activity "Create team project collection" -Status "Creating team project collection $Name" -PercentComplete 0

			$start = Get-Date

			$tpcJob = $tpcService.QueueCreateCollection(
				$Name,
				$Description, 
				$Default.ToBool(),
				"~/$Name/",
				[Microsoft.TeamFoundation.Framework.Common.TeamFoundationServiceHostStatus] $InitialState,
				$servicingTokens,
				$ConnectionString,
				$null,  # Default connection string
				$null)  # Default category connection strings

			while((Get-Date).Subtract($start) -le $Timeout)
			{
				Start-Sleep -Seconds $PollingInterval

				$collectionInfo = $tpcService.GetCollection($tpcJob.HostId, [Microsoft.TeamFoundation.Framework.Client.ServiceHostFilterFlags]::IncludeAllServicingDetails)
				$jobDetail = $collectionInfo.ServicingDetails | ? JobId -eq $tpcJob.JobId

				if (($jobDetail -eq $null) -or 
					(($jobDetail.JobStatus -ne [Microsoft.TeamFoundation.Framework.Client.ServicingJobStatus]::Queued) -and 
					 ($jobDetail.JobStatus -ne [Microsoft.TeamFoundation.Framework.Client.ServicingJobStatus]::Running)))
				{
					if ($jobDetail.Result -eq [Microsoft.TeamFoundation.Framework.Client.ServicingJobResult]::Failed -or 
						$jobDetail.JobStatus -eq [Microsoft.TeamFoundation.Framework.Client.ServicingJobStatus]::Failed)
					{
						throw "Error creating team project collection $Name : "
					}
				
					return Get-TfsTeamProjectCollection -Server $Server -Credential $Credential -Collection $Name
				}
			}
		}
		finally
		{
				Write-Progress -Id 1 -Activity "Create team project collection" -Completed
		}

		throw (New-Object 'System.TimeoutException' -ArgumentList "Operation timed out during creation of team project collection $Name")
	}
}
<#
#>
Function Remove-TfsTeamProjectCollection
{
	[CmdletBinding(ConfirmImpact="High", SupportsShouldProcess=$true)]
	Param
	(
		[Parameter(Mandatory=$true, Position=0, ValueFromPipeline=$true)]
		[object] 
		$Collection,

		[Parameter()]
		[object] 
		$Server,
	
		[Parameter()]
		[timespan]
		$Timeout = [timespan]::MaxValue,

		[Parameter()]
		[System.Management.Automation.Credential()]
		[System.Management.Automation.PSCredential]
		$Credential
	)

	Process
	{
		$tpc = Get-TfsTeamProjectCollection -Collection $Collection -Server $Server -Credential $Credential

		if ($PSCmdlet.ShouldProcess($tpc.Name, "Delete Team Project Collection"))
		{
			Write-Progress -Id 1 -Activity "Delete team project collection" -Status "Deleting $($tpc.Name)" -PercentComplete 0
		
			try
			{
				$configServer = $tpc.ConfigurationServer
				$tpcService = $configServer.GetService([type] 'Microsoft.TeamFoundation.Framework.Client.ITeamProjectCollectionService')
				$collectionInfo = $tpcService.GetCollection($tpc.InstanceId)

				$collectionInfo.Delete()
			}
			finally
			{
				Write-Progress -Id 1 -Activity "Delete team project collection" -Completed
			}
		}
	}
}
<#
#>
Function Start-TfsTeamProjectCollection
{
	Param
	(
		[Parameter(Mandatory=$true, Position=0)]
		[object] 
		$Collection,

		[Parameter(ValueFromPipeline=$true)]
		[object] 
		$Server,
	
		[Parameter()]
		[System.Management.Automation.Credential()]
		[System.Management.Automation.PSCredential]
		$Credential
	)

	Process
	{
		throw "Not implemented"
	}
}
Tools\TfsCmdlets\TfsCmdlets.Format.ps1xml
 
Tools\TfsCmdlets\TfsCmdlets.psd1
 
Tools\TfsCmdlets\TfsCmdlets.psm1
# Main module
Tools\TfsCmdlets\TfsCmdlets.Types.ps1xml
 
Tools\TfsCmdlets\WorkItem\WorkItem.psd1
 
Tools\TfsCmdlets\WorkItem\WorkItem.psm1
<#
.SYNOPSIS
	Exports a work item type on XML format.

.PARAMETER Name
	Uses this parameter to filter for an specific Work Item Type.
	If suppress, cmdlet will return all Work Item Types on XML format.

.PARAMETER IncludeGlobalLists
	 Exports the definitions of referenced global lists. If not specified, global list definitions are omitted.

.PARAMETER Collection
	Specifies either�a�URL�or�the�name�of�the�Team�Project�Collection�to�connect�to,�or�a�previously�initialized�TfsTeamProjectCollection�object.
	For�more�details,�see�the�-Collection�argument�in�the�Get-TfsTeamProjectCollection�cmdlet.

.PARAMETER Project
	Specifies either the�name of the Team Project or a previously initialized Microsoft.TeamFoundation.WorkItemTracking.Client.Project object to connect to.�
	For�more�details,�see�the�-Project�argument�in�the�Get-TfsTeamProject�cmdlet. 

.EXAMPLE
	$xml = Export-TfsWorkItemType -Name Task -Project "MyTeamProject" -IncludeGlobalLists
	This example export a Work Item Type Task of Team Project "MyTeamProject" including the respective GlobalLists.
#>
Function Export-TfsWorkItemType
{
	[CmdletBinding()]
	[OutputType([xml[]])]
	Param
	(
		[Parameter()]
		[string] 
		$Name = "*",

		[Parameter()]
		[switch]
		$IncludeGlobalLists,

		[Parameter(ValueFromPipeline=$true)]
		[object]
		$Project,

		[Parameter()]
        [object]
        $Collection
	)

	Process
	{
		$types = Get-TfsWorkItemType -Name $Name -Project $Project -Collection $Collection

		foreach($type in $types)
		{
			$type.Export($IncludeGlobalLists)
		}
	}
}
<#
.SYNOPSIS
    Gets one or more work items
#>
Function Get-TfsWorkItem
{
	[CmdletBinding()]
	Param
	(
		[Parameter(Position=0, Mandatory=$true, ParameterSetName="Query by revision")]
		[Parameter(Position=0, Mandatory=$true, ParameterSetName="Query by date")]
		[Alias("id")]
		[ValidateNotNull()]
		[object]
		$WorkItem,

		[Parameter(ParameterSetName="Query by revision")]
		[Alias("rev")]
		[int]
		$Revision,

		[Parameter(Mandatory=$true, ParameterSetName="Query by date")]
		[datetime]
		$AsOf,

		[Parameter(Mandatory=$true, ParameterSetName="Query by WIQL")]
		[string]
		$Query,

		[Parameter(Mandatory=$true, ParameterSetName="Query by saved query")]
		[string]
		$QueryName,

		[Parameter(Mandatory=$true, ParameterSetName="Query by text")]
		[string]
		$FreeText,

		[Parameter(Mandatory=$true, ParameterSetName="Query by fields")]
		[ValidateNotNull()]
		[ValidateScript({ $_.Count -gt 0 })]
		[string[]]
		$Where,

		[Parameter(ValueFromPipeline=$true)]
		[object]
		$Project,

		[Parameter()]
		[hashtable]
		$Macros,

		[Parameter()]
        [object]
        $Collection
	)

	Process
	{
		$tp = Get-TfsTeamProject $Project
		$tpc = $tp.Store.TeamProjectCollection
		$store = $tp.Store

		if ($WorkItem -is [Microsoft.TeamFoundation.WorkItemTracking.Client.WorkItem])
		{
			if ((-Not $Revision) -and (-Not $AsOf))
			{
				return $WorkItem
			}
		}

		switch($PSCmdlet.ParameterSetName)
		{
			"Query by revision" {
				return _GetWorkItemByRevision $WorkItem $Revision $store
			}

			"Query by date" {
				return _GetWorkItemByDate $WorkItem $AsOf $store
			}

			"Query by fields" {
				$tokens = [string[]]@()

				for($i = 0; $i -lt $Where.Count; $i++)
				{
                    $tokens += "($($Where[$i]))"
				}

				$wiql = "SELECT * FROM WorkItems WHERE $([string]::Join(" AND ", $tokens))"

				return _GetWorkItemByWiql $wiql $Macros $store 
			}

			"Query by Text" {
				$EscapedText = $FreeText.Replace("'", "''")
				$Wiql = "SELECT * FROM WorkItems WHERE [System.Title] CONTAINS '$EscapedText' OR [System.Description] CONTAINS '$EscapedText'"
				return _GetWorkItemByWiql $Wiql $Macros $store 
			}

			"Query by WIQL" {
				return _GetWorkItemByWiql $Query $Macros $tp $store 
			}

			"Query by saved query" {
				return _GetWorkItemBySavedQuery $QueryName $Macros $tp $store 
			}
		}
	}
}



Function _GetWorkItemByRevision($WorkItem, $Revision, $store)
{
	if ($WorkItem -is [Microsoft.TeamFoundation.WorkItemTracking.Client.WorkItem])
	{
		$ids = @($WorkItem.Id)
	}
	elseif ($WorkItem -is [int])
	{
		$ids = @($WorkItem)
	}
	elseif ($WorkItem -is [int[]])
	{
		$ids = $WorkItem
	}
	else
	{
		throw "Invalid work item ""$WorkItem"". Supply either a WorkItem object or one or more integer ID numbers"
	}

	if ($Revision -is [int] -and $Revision -gt 0)
	{
	    foreach($id in $ids)
	    {
		    $store.GetWorkItem($id, $Revision)
	    }
	}
	elseif ($Revision -is [int[]])
	{
		if ($ids.Count -ne $Revision.Count)
		{
			throw "When supplying a list of IDs and Revisions, both must have the same number of elements"
		}
		for($i = 0; $i -le $ids.Count-1; $i++)
		{
			$store.GetWorkItem($ids[$i], $Revision[$i])
		}
	}
	else
	{
	    foreach($id in $ids)
	    {
		    $store.GetWorkItem($id)
	    }
	}
}

Function _GetWorkItemByDate($WorkItem, $AsOf, $store)
{
	if ($WorkItem -is [Microsoft.TeamFoundation.WorkItemTracking.Client.WorkItem])
	{
		$ids = @($WorkItem.Id)
	}
	elseif ($WorkItem -is [int])
	{
		$ids = @($WorkItem)
	}
	elseif ($WorkItem -is [int[]])
	{
		$ids = $WorkItem
	}
	else
	{
		throw "Invalid work item ""$WorkItem"". Supply either a WorkItem object or one or more integer ID numbers"
	}

	if ($AsOf -is [datetime[]])
	{
		if ($ids.Count -ne $AsOf.Count)
		{
			throw "When supplying a list of IDs and Changed Dates (AsOf), both must have the same number of elements"
		}
		for($i = 0; $i -le $ids.Count-1; $i++)
		{
			$store.GetWorkItem($ids[$i], $AsOf[$i])
		}
	}
	else
	{
	    foreach($id in $ids)
	    {
		    $store.GetWorkItem($id, $AsOf)
	    }
	}
}

Function _GetWorkItemByWiql($Query, $Macros, $Project, $store)
{
	if (-not $Macros)
	{
		$Macros = @{}
	}

	if (($Query -match "@project") -and $Project)
	{

		if (-not $Macros.ContainsKey("Project"))
		{
			$Macros["Project"] = $Project.Name
		}
	}

    if ($Query -match "@me")
    {
        $user = $null
        $store.TeamProjectCollection.GetAuthenticatedIdentity([ref] $user)
        $Macros["Me"] = $user.DisplayName
    }

	$wis = $store.Query($Query, $Macros)

	foreach($wi in $wis)
	{
		$wi
	}
}

Function _GetWorkItemBySavedQuery($QueryName, $Macros, $Project, $store)
{
	if ($Macros)
	{
		$wis = $store.Query($Query, $Macros)
	}
	else
	{
		$wis = $store.Query($Query)
	}

	foreach($wi in $wis)
	{
		$wi
	}
}
<#
.SYNOPSIS
	Shows information about Work Item Types.

.PARAMETER Name
	Uses this parameter to filter for an specific Work Item Type.
	If suppress, cmdlet will show all Work Item Types.

.PARAMETER Collection
	Specifies either�a�URL�or�the�name�of�the�Team�Project�Collection�to�connect�to,�or�a�previously�initialized�TfsTeamProjectCollection�object.
	For�more�details,�see�the�-Collection�argument�in�the�Get-TfsTeamProjectCollection�cmdlet.

.PARAMETER Project
	Specifies either the�name of the Team Project or a previously initialized Microsoft.TeamFoundation.WorkItemTracking.Client.Project object to connect to.�
	For�more�details,�see�the�-Project�argument�in�the�Get-TfsTeamProject�cmdlet. 

.EXAMPLE
	Get-TfsWorkItemType -Name "Task" -Project "My Team Project"
	Get informations about Work Item Type "Task" of a team project name "My Team Project"

.EXAMPLE
	Get-TfsWorkItemType -Project "My Team Project"
	Get all Work Item Types of a team project name "My Team Project"
#>
Function Get-TfsWorkItemType
{
	[CmdletBinding()]
	[OutputType([Microsoft.TeamFoundation.WorkItemTracking.Client.WorkItemType[]])]
	Param
	(
		[Parameter(Position=0)]
		[string] 
		$Name = "*",

		[Parameter(ValueFromPipeline=$true)]
		[object]
		$Project,

		[Parameter()]
        [object]
        $Collection
	)

	Process
	{
		$tp = Get-TfsTeamProject $Project $Collection
		return $tp.WorkItemTypes | ? Name -Like $Name
	}
}
<#
.SYNOPSIS
	This cmdlet imports a work item type XML definition file into a team project on a Team Foundation Server.
	If a work item type with the same name already exists, the new work item type definition will overwrite the existing definition.
	If the work item type does not already exist, a new work item type will be created..

.PARAMETER Xml
	Specifies the work item type XML definition file to import.

.PARAMETER Collection
	Specifies either�a�URL�or�the�name�of�the�Team�Project�Collection�to�connect�to,�or�a�previously�initialized�TfsTeamProjectCollection�object.
	For�more�details,�see�the�-Collection�argument�in�the�Get-TfsTeamProjectCollection�cmdlet.

.PARAMETER Project
	Specifies either the�name of the Team Project or a previously initialized Microsoft.TeamFoundation.WorkItemTracking.Client.Project object to connect to.�
	For�more�details,�see�the�-Project�argument�in�the�Get-TfsTeamProject�cmdlet. 

.EXAMPLE
	Import-TfsWorkItemType -Xml "C:\temp\Task.xml" -Project "MyTeamProject"
	This example imports a Work Item Type Task on Team Project "MyTeamProject".
#>
Function Import-TfsWorkItemType
{
	[CmdletBinding()]
	[OutputType([Microsoft.TeamFoundation.WorkItemTracking.Client.WorkItemType[]])]
	Param
	(
		[Parameter(Position=0)]
		[xml] 
		$Xml,

		[Parameter(ValueFromPipeline=$true)]
		[object]
		$Project,

		[Parameter()]
        [object]
        $Collection
	)

	Process
	{
		$tp = Get-TfsTeamProject $Project $Collection
		return $tp.WorkItemTypes | ? Name -Like $Name
	}
}
<#
.SYNOPSIS
	Specifies that a new work item of the type entered be created. The object WorkItem of the new work item is displayed.

.PARAMETER Type
	Represents the name of the work item type to create.

.PARAMETER Title
	Specifies a Title field of new work item type that will be created.

.PARAMETER Fields
	Specifies the fields that are changed and the new values to give to them.
	FieldN The name of a field to update.
	ValueN The value to set on the fieldN.
	[field1=value1[;field2=value2;...]

.PARAMETER Collection
	Specifies either�a�URL�or�the�name�of�the�Team�Project�Collection�to�connect�to,�or�a�previously�initialized�TfsTeamProjectCollection�object.
	For�more�details,�see�the�-Collection�argument�in�the�Get-TfsTeamProjectCollection�cmdlet.

.PARAMETER Project
	Specifies either the�name of the Team Project or a previously initialized Microsoft.TeamFoundation.WorkItemTracking.Client.Project object to connect to.�
	For�more�details,�see�the�-Project�argument�in�the�Get-TfsTeamProject�cmdlet. 

.EXAMPLE
	New-TfsWorkItem -Type Task -Title "Task 1" -Project "MyTeamProject"
	This example creates a new Work Item on Team Project "MyTeamProject".
#>
Function New-TfsWorkItem
{
	[CmdletBinding()]
	[OutputType([Microsoft.TeamFoundation.WorkItemTracking.Client.WorkItem])]
	Param
	(
		[Parameter(ValueFromPipeline=$true, Mandatory=$true, Position=0)]
		[object] 
		$Type,

		[Parameter(Position=1)]
		[string]
		$Title,

		[Parameter()]
		[hashtable]
		$Fields,

		[Parameter()]
		[object]
		$Project,

		[Parameter()]
        [object]
        $Collection
	)

	Process
	{
		$wit = Get-TfsWorkItemType -Type $Type -Project $Project -Collection $Collection

		$wi = $wit.NewWorkItem()
		$wi.Title = $Title

		foreach($field in $Fields)
		{
			$wi.Fields[$field.Key] = $field.Value
		}

		$wi.Save()

		return $wi
	}
}
Function Remove-TfsWorkItem
{
	[CmdletBinding(ConfirmImpact="High", SupportsShouldProcess=$true)]
	Param
	(
		[Parameter(Position=0, Mandatory=$true, ValueFromPipeline=$true)]
		[Alias("id")]
		[ValidateNotNull()]
		[object]
		$WorkItem,

		[Parameter()]
        [object]
        $Collection
	)

	Process
	{
		$ids = @()

		foreach($wi in $WorkItem)
		{
			if ($WorkItem -is [Microsoft.TeamFoundation.WorkItemTracking.Client.WorkItem])
			{
				$id = $WorkItem.Id
			}
			elseif ($WorkItem -is [int])
			{
				$id = $WorkItem
			}
			else
			{
				throw "Invalid work item ""$WorkItem"". Supply either a WorkItem object or one or more integer ID numbers"
			}

			if ($PSCmdlet.ShouldProcess("ID: $id", "Destroy workitem"))
			{
				$ids += $id
			}
		}

		if ($ids.Count -gt 0)
		{
			$tpc = Get-TfsTeamProjectCollection $Collection
			$store = $tpc.GetService([type] "Microsoft.TeamFoundation.WorkItemTracking.Client.WorkItemStore")

			$errors = $store.DestroyWorkItems([int[]] $ids)
		
			if ($errors -and ($errors.Count -gt 0))
			{
				$errors | Write-Error "Error $($_.Id): $($_.Exception.Message)"

				throw "Error destroying one or more work items"
			}
		}
	}
}
Tools\TfsCmdlets\XamlBuild\XamlBuild.psd1
 
Tools\TfsCmdlets\XamlBuild\XamlBuild.psm1
Function Get-TfsXamlBuildAgent
{
	[CmdletBinding()]
	[OutputType([Microsoft.TeamFoundation.Build.Client.IBuildAgent])]
	Param
	(
		[Parameter(Position=0)]
		[ValidateScript({$_ -is [string] -or $_ -is [Microsoft.TeamFoundation.Build.Client.IBuildAgent]})]
		[ValidateNotNullOrEmpty()]
		[Alias("Name")]
		[object] 
		$BuildAgent = "*",

		[Parameter(Position=0, ValueFromPipeline=$true)]
		[ValidateScript({$_ -is [string] -or $_ -is [Microsoft.TeamFoundation.Build.Client.IBuildController]})]
		[ValidateNotNullOrEmpty()]
		[Alias("Controller")]
		[object] 
		$BuildController = "*",

		[Parameter()]
        [object]
        $Collection
	)

	Process
	{
		if ($BuildAgent -is [Microsoft.TeamFoundation.Build.Client.IBuildAgent])
		{
			return $BuildAgent
		}

		$controllers = Get-TfsXamlBuildController -BuildController $BuildController -Collection $Collection

		foreach($controller in $controllers)
		{
			$controller.Agents | Where Name -Like $BuildAgent
		}		
 	}
}
Function Get-TfsXamlBuildController
{
	[CmdletBinding()]
	[OutputType([Microsoft.TeamFoundation.Build.Client.IBuildController])]
	Param
	(
		[Parameter(Position=0)]
		[ValidateScript({$_ -is [string] -or $_ -is [Microsoft.TeamFoundation.Build.Client.IBuildController]})]
		[ValidateNotNullOrEmpty()]
		[Alias("Name")]
		[object] 
		$BuildController = "*",

		[Parameter(ValueFromPipeline=$true)]
        [object]
        $Collection
	)

	Process
	{
		if ($BuildController -is [Microsoft.TeamFoundation.Build.Client.IBuildController])
		{
			return $BuildController

		}

		$tpc = Get-TfsTeamProjectCollection $Collection

		$buildServer = $tpc.GetService([type]'Microsoft.TeamFoundation.Build.Client.IBuildServer')
		$buildControllers = $buildServer.QueryBuildControllers()
		
		return $buildControllers | Where Name -Like $BuildController
 	}
}
<#
.SYNOPSIS
	Gets all queued builds

.PARAMETER BuildDefinition
	Uses this parameter to filter for an specific Build Defintion.
	If suppress, cmdlet will show all queue builds.

.PARAMETER Collection
	Specifies either�a�URL�or�the�name�of�the�Team�Project�Collection�to�connect�to,�or�a�previously�initialized�TfsTeamProjectCollection�object.
	For�more�details,�see�the�-Collection�argument�in�the�Get-TfsTeamProjectCollection�cmdlet.

.PARAMETER Project
	Specifies either the�name of the Team Project or a previously initialized Microsoft.TeamFoundation.WorkItemTracking.Client.Project object to connect to.�
	For�more�details,�see�the�-Project�argument�in�the�Get-TfsTeamProject�cmdlet. 

.EXAMPLE
	Get-TfsBuildQueue -BuildDefinition "My Build Definition" -Project "My Team Project"
	Get all queued builds given a definition name and a team project name

.EXAMPLE
	Get-TfsBuildQueue
	Get all queued builds, regardless of definition name or team project name

#>
Function Get-TfsXamlBuildDefinition
{
	[CmdletBinding()]
	[OutputType([Microsoft.TeamFoundation.Build.Client.IBuildDefinition])]
	Param
	(
		[Parameter(Position=0)]
		[ValidateScript({$_ -is [string] -or $_ -is [Microsoft.TeamFoundation.Build.Client.IBuildDefinition]})]
		[ValidateNotNullOrEmpty()]
		[Alias("Name")]
		[object] 
		$BuildDefinition = "*",

		[Parameter(ValueFromPipeline=$true)]
		[object]
		$Project,

		[Parameter()]
        [object]
        $Collection
	)

	Process
	{
		if ($BuildDefinition -is [Microsoft.TeamFoundation.Build.Client.IBuildDefinition])
		{
			return $BuildDefinition
		}

		$tp = Get-TfsTeamProject $Project $Collection
		$tpName = $tp.Name
		$tpc = $tp.Store.TeamProjectCollection

		$buildServer = $tpc.GetService([type]'Microsoft.TeamFoundation.Build.Client.IBuildServer')
		$buildDefs = $buildServer.QueryBuildDefinitions($tpName)
		
		return $buildDefs | Where Name -Like $BuildDefinition
 	}
}
<#
.SYNOPSIS
	Gets all queued builds

.PARAMETER BuildDefinition
	Uses this parameter to filter for an specific Build Defintion.
	If suppress, cmdlet will show all queue builds.

.PARAMETER Collection
	Specifies either�a�URL�or�the�name�of�the�Team�Project�Collection�to�connect�to,�or�a�previously�initialized�TfsTeamProjectCollection�object.
	For�more�details,�see�the�-Collection�argument�in�the�Get-TfsTeamProjectCollection�cmdlet.

.PARAMETER Project
	Specifies either the�name of the Team Project or a previously initialized Microsoft.TeamFoundation.WorkItemTracking.Client.Project object to connect to.�
	For�more�details,�see�the�-Project�argument�in�the�Get-TfsTeamProject�cmdlet. 

.EXAMPLE
	Get-TfsBuildQueue -BuildDefinition "My Build Definition" -Project "My Team Project"
	Get all queued builds given a definition name and a team project name

.EXAMPLE
	Get-TfsBuildQueue
	Get all queued builds, regardless of definition name or team project name

#>
Function Get-TfsXamlBuildQueue
{
	[CmdletBinding()]
	[OutputType([Microsoft.TeamFoundation.Build.Client.IQueuedBuild])]
	Param
	(
		[Parameter(Position=0, ValueFromPipeline=$true)]
		[ValidateScript({$_ -is [string] -or $_ -is [Microsoft.TeamFoundation.Build.Client.IBuildDefinition]})]
		[ValidateNotNullOrEmpty()]
		[object] 
		$BuildDefinition = "*",

		[Parameter()]
		[object]
		$Project,

		[Parameter()]
        [object]
        $Collection
	)

	Process
	{
		if ($BuildDefinition -is [Microsoft.TeamFoundation.Build.Client.IBuildDefinition])
		{
			$buildDefName = $BuildDefinition.Name
		}
		else
		{
			$buildDefName = $BuildDefinition
		}

		if ($Project)
		{
			$tp = Get-TfsTeamProject $Project $Collection
			$tpName = $tp.Name
			$tpc = $tp.Store.TeamProjectCollection
		}
		else
		{
			$tpName = "*"
			$tpc = Get-TfsTeamProjectCollection $Collection
		}

		$buildServer = $tpc.GetService([type]'Microsoft.TeamFoundation.Build.Client.IBuildServer')
		$query = $buildServer.CreateBuildQueueSpec($tpName, $buildDefName)
		
		$buildServer.QueryQueuedBuilds($query).QueuedBuilds
 	}
}
<#
.SYNOPSIS
   Sets up an additional build service in the current computer

.DESCRIPTION

   In Team Foundation Server, the Build Service is a Windows Service that is associated with a particular TFS Team Project Collection (since 2010). 
   
   Each Build Service support zero to one (0..1) Build Controllers and zero to n (0..n) Build Agents. 
   
   Each Build Agent is associated to a specific Build Controller but an Agent and its corresponding Controller don�t need to be on the same machine. 
   
   This topology lets you configure a continuous integration build that queues its builds on the Build Controller you�ve specified which then farms out the heavy lifting to any of the n agents it manages. This gives you an easy way to load balance your builds across a set of machines.
   
   There is a potential down-side, however, in that each build service can only service one particular project collection and you cannot install more than one build service in any given computer.

   This script allows you work around that limitation, setting up more than one build service in the same machine.

.NOTES
	
	This is not supported and should not be used in production environments.
#>
Function New-TfsBuildService
{
    Param
    (
        [Parameter(Mandatory=$true)]
        [ValidateNotNullOrEmpty()]
        [string]
        $CollectionName,

        [Parameter()]
        [string]
        $BuildServiceName = "TFSBuildServiceHost.2013",

        [Parameter()]
        [string]
        $ComputerName = $env:COMPUTERNAME,

        [Parameter()]
        [ValidateRange(1,65535)]
        [int]
        $Port = 9191,

        [Parameter(Mandatory=$true)]
        [System.Management.Automation.Credential()]
        [System.Management.Automation.PSCredential]
        $ServiceCredential = (Get-Credential),

        [Parameter()]
        [switch]
        $Force
    )

    Begin
    {
        if ($ComputerName -eq "localhost")
        {
            $ComputerName = $env:COMPUTERNAME
        }
        $tpc = Get-TfsTeamProjectCollection -Current
        $buildServer = $tpc.GetService([type]"Microsoft.TeamFoundation.Build.Client.IBuildServer")
    }

    Process
    {
        $ToolsVersion = 12
        $EnvVarName = "TFSBUILDSERVICEHOST.2013"
        $BuildEndpointTemplate = "Build/v5.0/Services"

        if (-not $TfsInstallationPath) 
        {
            $TfsInstallationPath = (Get-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\TeamFoundationServer\12.0").InstallPath
        }

        if (-not $BuildServiceName)
        {
            $BuildServiceName = "TfsBuildService-$collectionName"
        }

        $ServiceBinPath = "$TfsInstallationPath\Tools\TfsBuildServiceHost.exe /NamedInstance:$BuildServiceName"
        $ServiceDisplayName = "Visual Studio Team Foundation Build Service Host ($collectionName)"


        _CreateService $BuildServiceName $ServiceDisplayName $ServiceBinPath $Force.IsPresent
        _RegisterBuildServiceHost $TfsInstallationPath $Force.IsPresent
        _CreateBuildController
        _CreateBuildAgent
    }
}

#======================
# Helper methods
#======================

Function _CreateService
{
    Param
    (
        $BuildServiceName,
        $ServiceDisplayName,
        $ServiceBinPath,
        $Force
    )

    if (Get-Service $BuildServiceName -ErrorAction SilentlyContinue)
    {
        if (-not $Force)
        {
            throw "Build Service $BuildServiceName is already registered. To re-register a build service, use the -Force switch"
        }

        sc.exe delete $BuildServiceName | Out-Null
    }

    $svc = New-Service -Name $BuildServiceName -DisplayName $ServiceDisplayName -BinaryPathName $ServiceBinPath
    
    sc.exe failure $BuildServiceName reset= 86400 actions= restart/60000 | Out-Null
}

Function _RegisterBuildServiceHost
{
    Param
    (
        $TfsInstallationPath,
        $Force
    )

    _LoadPrivateAssemblies $TfsInstallationPath

    $flags = [System.Reflection.BindingFlags]::NonPublic -bor [System.Reflection.BindingFlags]::SetProperty -bor [System.Reflection.BindingFlags]::Static
    [Microsoft.TeamFoundation.Build.Config.BuildServiceHostProcess].InvokeMember("NamedInstance", $flags, $null, $null, [object[]] $BuildServiceName)

    if ($buildServer.QueryBuildServiceHosts($BuildServiceName).Length -ne 0)
    {
        if (-not $Force)
        {
            throw "Build Service $BuildServiceName is already registered. To re-register a build service, use the -Force switch"
        }
        
        [Microsoft.TeamFoundation.Build.Config.BuildServiceHostUtilities]::Unregister($true, $true)
    }

    $port = _GetNextAvailablePort
    $endpoint = "http://$env:COMPUTERNAME:$port/$BuildEndpointTemplate"
    $serviceHost = $buildServer.CreateBuildServiceHost($BuildServiceName, $endpoint)
    $serviceHost.Save()

    $userName = $ServiceCredential.UserName
    $password = $ServiceCredential.GetNetworkCredential().Password

    [Microsoft.TeamFoundation.Build.Config.BuildServiceHostUtilities]::Register($serviceHost, $userName, $password)
}

Function _GetNextAvailablePort
{
    $RegistryPath = "HKLM:\SOFTWARE\Microsoft\VisualStudio\$ToolsVersion.0\TeamFoundation\Build"
    $PortsTaken = Get-ChildItem -Path $RegistryPath | Get-ItemProperty -Name Endpoint | ForEach { [uri] $_.Endpoint } | Select -ExpandProperty Port

    $StartPort = 9191
    $MaxPorts = $StartPort + $PortsTaken.Length

    for ($i = $StartPort; $i -le $MaxPorts; $i++)
    { 
        if ($PortsTaken -notcontains $i)
        {
            $Port = $i
            break
        }
    }

    return $Port
}

Function _LoadPrivateAssemblies
{
    Param
    (
        $TfsInstallationPath
    )

    $AssemblyPath = "$TfsInstallationPath\Tools\Microsoft.TeamFoundation.Build.Config.dll"
    Add-Type -Path $AssemblyPath
}

Function _GetRegValue
{
    Param
    (
        $KeyPath, $ValueName, $ComputerName
    )

    Process
    {
        if ((-not $ComputerName) -or ($ComputerName -eq $env:COMPUTERNAME))
        {
            return Get-ChildItem -Path $KeyPath | Get-ItemProperty -Name $ValueName
        }

        $KeyMapping = @{
            HKCU = "CurrentUser";
            HKLM = "LocalMachine"
        }

        $RootKey = ($KeyPath -split ":\")[0]
        $Path = ($KeyPath -split ":\")[1]
        
        $Reg = [Microsoft.Win32.RegistryKey]::OpenRemoteBaseKey($KeyMapping[$RootKey], $ComputerName)
        $RegKey= $Reg.OpenSubKey($Path)
        $Value = $RegKey.GetValue($ValueName)

        $RegKey.Close()
        $Reg.Close()

        return $Value
    }
}
<#
.SYNOPSIS
	Queues a new XAML Build.

.PARAMETER BuildDefinition
	Build Definition Name that you want to queue.

.PARAMETER Collection
	Specifies either�a�URL�or�the�name�of�the�Team�Project�Collection�to�connect�to,�or�a�previously�initialized�TfsTeamProjectCollection�object.
	For�more�details,�see�the�-Collection�argument�in�the�Get-TfsTeamProjectCollection�cmdlet.

.PARAMETER Project
	Specifies either the�name of the Team Project or a previously initialized Microsoft.TeamFoundation.WorkItemTracking.Client.Project object to connect to.�
	For�more�details,�see�the�-Project�argument�in�the�Get-TfsTeamProject�cmdlet. 

.EXAMPLE
	Start-TfsBuild -BuildDefinition "My Build Definition" -Project "MyTeamProject"
	This example queue a Build Definition "My Build Definition" of Team Project "MyTeamProject".

#>
Function Start-TfsXamlBuild
{
	Param
	(
		[Parameter(Mandatory=$true, Position=0)]
		[object] 
		$BuildDefinition,

		[Parameter(ValueFromPipeline=$true, Mandatory=$true)]
		[object]
		[ValidateNotNull()]
		[ValidateScript({($_ -is [string]) -or ($_ -is [Microsoft.TeamFoundation.WorkItemTracking.Client.Project])})] 
		$Project,

		[Parameter()]
        [object]
        $Collection,

		[Parameter()]
		[string]
		[ValidateSet("LatestOnQueue", "LatestOnBuild", "Custom")]
		$GetOption = "LatestOnBuild",

		[Parameter()]
		[string]
		$GetVersion,

		[Parameter()]
		[string]
		$DropLocation,

		[Parameter()]
        [hashtable]
        $Parameters
	)

	Process
	{

		$tp = Get-TfsTeamProject $Project $Collection
		$tpc = $tp.Store.TeamProjectCollection

		$buildServer = $tpc.GetService([type]"Microsoft.TeamFoundation.Build.Client.IBuildServer")

		if ($BuildDefinition -is [Microsoft.TeamFoundation.Build.Client.IBuildDefinition])
		{
			$buildDef = $BuildDefinition
		}
		else
		{
			$buildDef = $buildServer.GetBuildDefinition($tp.Name, $BuildDefinition);
		}

		$req = $buildDef.CreateBuildRequest()
        $req.GetOption = [Microsoft.TeamFoundation.Build.Client.GetOption] $GetOption;

		if ($GetOption -eq "Custom")
		{
	        $req.CustomGetVersion = $GetVersion
		}

		if ($DropLocation)
		{
			$req.DropLocation = $DropLocation
		}

        $buildServer.QueueBuild($req)
	}
}
Tools\TfsCmdletsShell.ico
 

Log in or click on link to see number of positives.

In cases where actual malware is found, the packages are subject to removal. Software sometimes has false positives. Moderators do not necessarily validate the safety of the underlying software, only that a package retrieves software from the official distribution point and/or validate embedded software against official distribution point (where distribution rights allow redistribution).

Chocolatey Pro provides runtime protection from possible malware.

Add to Builder Version Downloads Last Updated Status
TfsCmdlets 2.8.2 36 Wednesday, July 24, 2024 Approved
TfsCmdlets 2.8.1 26 Tuesday, July 16, 2024 Approved
TfsCmdlets 2.8.0 33 Tuesday, July 9, 2024 Approved
TfsCmdlets 2.7.1 26 Wednesday, July 3, 2024 Approved
TfsCmdlets 2.6.1 46 Wednesday, May 15, 2024 Approved
TfsCmdlets 2.6.0 248 Saturday, October 1, 2022 Approved
TfsCmdlets 2.5.1 62 Monday, August 22, 2022 Approved
TfsCmdlets 2.5.0 60 Wednesday, August 3, 2022 Approved
TfsCmdlets 2.4.1 71 Thursday, July 21, 2022 Approved
TfsCmdlets 2.4.0 93 Monday, May 23, 2022 Approved
TfsCmdlets 2.3.2 63 Wednesday, May 18, 2022 Approved
TfsCmdlets 2.3.1 74 Saturday, April 9, 2022 Approved
TfsCmdlets 2.3.0 71 Sunday, April 3, 2022 Approved
TfsCmdlets 2.2.1 76 Friday, February 11, 2022 Approved
TfsCmdlets 2.2.0 66 Saturday, February 5, 2022 Approved
TfsCmdlets 2.1.4 94 Tuesday, November 30, 2021 Approved
TfsCmdlets 2.1.3 71 Thursday, November 25, 2021 Approved
TfsCmdlets 2.1.2 87 Friday, September 10, 2021 Approved
TfsCmdlets 2.1.1 80 Wednesday, September 8, 2021 Approved
TfsCmdlets 2.0.0 87 Tuesday, August 3, 2021 Approved
TfsCmdlets 2.0.0-rc0005 88 Sunday, April 18, 2021 Exempted
TfsCmdlets 2.0.0-rc0004 88 Monday, April 5, 2021 Exempted
TfsCmdlets 2.0.0-rc0003 78 Friday, February 19, 2021 Exempted
TfsCmdlets 2.0.0-rc0002 87 Tuesday, December 1, 2020 Exempted
TfsCmdlets 2.0.0-beta0015 89 Tuesday, July 21, 2020 Exempted
TfsCmdlets 2.0.0-beta0014 69 Sunday, July 19, 2020 Exempted
TfsCmdlets 2.0.0-beta0013 68 Saturday, July 18, 2020 Exempted
TfsCmdlets 2.0.0-beta0010 162 Thursday, September 12, 2019 Exempted
TfsCmdlets 2.0.0-beta0009 97 Tuesday, September 10, 2019 Exempted
TfsCmdlets 2.0.0-beta0008 109 Friday, September 6, 2019 Exempted
TfsCmdlets 2.0.0-beta0004 119 Thursday, August 29, 2019 Exempted
TfsCmdlets 1.0.0.894-beta1 392 Thursday, April 6, 2017 Exempted
TfsCmdlets 1.0.0-alpha9 333 Saturday, December 24, 2016 Exempted
TfsCmdlets 1.0.0-alpha7 299 Thursday, October 22, 2015 Exempted
TfsCmdlets 1.0.0-alpha6 281 Thursday, October 22, 2015 Exempted
TfsCmdlets 1.0.0-alpha5 259 Thursday, September 10, 2015 Exempted
TfsCmdlets 1.0.0-alpha4 248 Friday, September 4, 2015 Exempted
TfsCmdlets 1.0.0-alpha3 314 Thursday, September 3, 2015 Exempted
TfsCmdlets 1.0.0-alpha1 313 Friday, July 31, 2015 Exempted

{ReleaseNotes}


This package has no dependencies.

Discussion for the TfsCmdlets Package

Ground Rules:

  • This discussion is only about TfsCmdlets and the TfsCmdlets package. If you have feedback for Chocolatey, please contact the Google Group.
  • This discussion will carry over multiple versions. If you have a comment about a particular version, please note that in your comments.
  • The maintainers of this Chocolatey Package will be notified about new comments that are posted to this Disqus thread, however, it is NOT a guarantee that you will get a response. If you do not hear back from the maintainers after posting a message below, please follow up by using the link on the left side of this page or follow this link to contact maintainers. If you still hear nothing back, please follow the package triage process.
  • Tell us what you love about the package or TfsCmdlets, or tell us what needs improvement.
  • Share your experiences with the package, or extra configuration or gotchas that you've found.
  • If you use a url, the comment will be flagged for moderation until you've been whitelisted. Disqus moderated comments are approved on a weekly schedule if not sooner. It could take between 1-5 days for your comment to show up.
comments powered by Disqus