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- Software Specific:
- Software Site
- Software License
- Package Specific:
- Possible Package Source
- Package outdated?
- Package broken?
- Contact Maintainers
- Contact Site Admins
- Software Vendor?
- Report Abuse
- Download
TfsCmdlets
This is a prerelease version of TfsCmdlets.
- 1
- 2
- 3
1.0.0-alpha1 | Updated: 31 Jul 2015
- Software Specific:
- Software Site
- Software License
- Package Specific:
- Possible Package Source
- Package outdated?
- Package broken?
- Contact Maintainers
- Contact Site Admins
- Software Vendor?
- Report Abuse
- Download
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
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:
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
Option 1: Cached Package (Unreliable, Requires Internet - Same As Community)-
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
-
Open Source
-
Download the package:
Download - Follow manual internalization instructions
-
-
Package Internalizer (C4B)
-
Run: (additional options)
choco download tfscmdlets --internalize --version=1.0.0-alpha1 --pre --source=https://community.chocolatey.org/api/v2/
-
For package and dependencies run:
choco push --source="'INTERNAL REPO URL'"
- Automate package internalization
-
Run: (additional options)
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.
This package is exempt from moderation. While it is likely safe for you, there is more risk involved.
PowerShell Cmdlets for Team Foundation Server and Visual Studio Online
$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')
}
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
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
}
<#
.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")
}
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
}
}
<#
.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
}
}
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"
}
}
}
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
}
}
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
}
}
}
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)
}
<#
.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
}
<#
#>
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"
}
}
# Main module
<#
.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"
}
}
}
}
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)
}
}
Log in or click on link to see number of positives.
- System.Net.Http.Extensions.dll (7b3257f0ea26) - ## / 64
- System.Net.Http.Primitives.dll (c860b2dca751) - ## / 67
- System.Net.Http.Formatting.dll (76ea4b2d47bb) - ## / 67
- Microsoft.IdentityModel.Clients.ActiveDirectory.dll (167ab5abd0c3) - ## / 56
- Microsoft.IdentityModel.Clients.ActiveDirectory.WindowsForms.dll (f0d79143acbe) - ## / 56
- Newtonsoft.Json.dll (492f637081a4) - ## / 57
- System.IdentityModel.Tokens.Jwt.dll (9b51335056d2) - ## / 56
- System.Web.Http.dll (1666e476e653) - ## / 61
- TfsCmdlets.1.0.0-alpha1.nupkg (357750e5ed53) - ## / 57
- Microsoft.TeamFoundation.Build.Client.dll (a258ed6d30ce) - ## / 57
- Microsoft.TeamFoundation.Build.Common.dll (daeeaf72dcdd) - ## / 57
- Microsoft.TeamFoundation.Build2.WebApi.dll (73b9b5fadb46) - ## / 56
- Microsoft.TeamFoundation.Chat.WebApi.dll (42d1468fb064) - ## / 56
- Microsoft.TeamFoundation.Client.dll (12ad091bbc68) - ## / 57
- Microsoft.TeamFoundation.Common.dll (58007bede40e) - ## / 54
- Microsoft.TeamFoundation.Core.WebApi.dll (b492db29d5ee) - ## / 57
- Microsoft.TeamFoundation.DeleteTeamProject.dll (69b625cb9754) - ## / 57
- Microsoft.TeamFoundation.Diff.dll (7647a390217d) - ## / 57
- Microsoft.TeamFoundation.Discussion.Client.dll (7a65c4b25367) - ## / 56
- Microsoft.TeamFoundation.Discussion.WebApi.dll (fe5f1592f0b3) - ## / 57
- Microsoft.TeamFoundation.Git.Client.dll (12cf4cbcc8ec) - ## / 57
- Microsoft.TeamFoundation.Lab.Client.dll (da6163dded23) - ## / 56
- Microsoft.TeamFoundation.Lab.Common.dll (6a9a00074f53) - ## / 56
- Microsoft.TeamFoundation.Lab.TestIntegration.Client.dll (7df0a45652af) - ## / 57
- Microsoft.TeamFoundation.Lab.WorkflowIntegration.Client.dll (baf8fa7a40ef) - ## / 56
- Microsoft.TeamFoundation.Policy.WebApi.dll (505ed82954ff) - ## / 57
- Microsoft.TeamFoundation.ProjectManagement.dll (2d3a75c1c3f7) - ## / 57
- Microsoft.TeamFoundation.SharePointReporting.Integration.dll (c126d464e4cd) - ## / 57
- Microsoft.TeamFoundation.SourceControl.WebApi.dll (559deab7d78c) - ## / 57
- Microsoft.TeamFoundation.Test.WebApi.dll (d6e722846e4d) - ## / 56
- Microsoft.TeamFoundation.TestImpact.Client.dll (d3dae331014e) - ## / 56
- Microsoft.TeamFoundation.TestManagement.Client.dll (66dad72dc0f5) - ## / 57
- Microsoft.TeamFoundation.TestManagement.Common.dll (2e29b2360042) - ## / 57
- Microsoft.TeamFoundation.TestManagement.WebApi.dll (8c8217b32b90) - ## / 56
- Microsoft.TeamFoundation.VersionControl.Client.dll (2a781f61f3b7) - ## / 57
- Microsoft.TeamFoundation.VersionControl.Common.dll (921f38c07648) - ## / 57
- Microsoft.TeamFoundation.VersionControl.Common.Integration.dll (846d1479e488) - ## / 56
- Microsoft.TeamFoundation.Work.WebApi.dll (4b5b7b171bb7) - ## / 56
- Microsoft.TeamFoundation.WorkItemTracking.Client.DataStoreLoader.dll (8f3764b6bd68) - ## / 57
- Microsoft.TeamFoundation.WorkItemTracking.Client.dll (7b4843aada65) - ## / 57
- Microsoft.TeamFoundation.WorkItemTracking.Client.QueryLanguage.dll (26ad9d87759e) - ## / 57
- Microsoft.TeamFoundation.WorkItemTracking.Common.dll (858cdb3a7ddf) - ## / 57
- Microsoft.TeamFoundation.WorkItemTracking.Proxy.dll (29adcc4ff7e0) - ## / 57
- Microsoft.TeamFoundation.WorkItemTracking.WebApi.dll (18f38684350f) - ## / 55
- Microsoft.VisualStudio.Services.Client.dll (41003462aa6f) - ## / 57
- Microsoft.VisualStudio.Services.Common.dll (00fe53af0475) - ## / 57
- Microsoft.VisualStudio.Services.WebApi.dll (3e412fddc540) - ## / 57
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.9.0 | 51 | Thursday, August 15, 2024 | Approved | |
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 |
(c) 2014 Igor Abade V. Leite. All rights reserved.
{ReleaseNotes}
This package has no dependencies.
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.