Dune

1.0.0

Public/Get-DuneDeploymentTemplate.ps1

function Get-DuneDeploymentTemplate {
    [CmdletBinding(DefaultParameterSetName = "Default")]
    param (
        [Parameter(ParameterSetName = "Name", Mandatory, Position = 0)]
        [string]$Name,

        [Parameter(ParameterSetName = "Name", Position = 1)]
        [string]$Version,

        [Parameter(ParameterSetName = "Id")]
        [guid]$Id,

        [Parameter(ParameterSetName = "Deployment", ValueFromPipeline)]
        [DuneDeployment]$Deployment,

        [Parameter()]
        [switch]$Raw,

        [Parameter()]
        [switch]$IncludeDefinition,

        [Parameter()]
        [switch]$IncludeDeleted,

        [Parameter()]
        [switch]$Latest
    )

    begin {
        Write-Debug "$($MyInvocation.MyCommand)|begin"
        $ReturnObjects = @()
        $ProcessedUrls = @()
        $BaseUri = 'deploymenttemplates'
        $Method = 'GET'
    }

    process {
        Write-Debug "$($MyInvocation.MyCommand)|process|$($PSCmdlet.ParameterSetName)"

        # Build Uri
        switch ($PSCmdlet.ParameterSetName) {
            'Id' { $Uri = '{0}/{1}' -f $BaseUri, $Id }
            'Name' {
                $Uri = $BaseUri | Add-UriQueryParam "NameILike=$Name" -ConvertWildcards
                if ($Version) { $Uri = $Uri | Add-UriQueryParam "VersionILike=$Version" -ConvertWildcards }
            }
            'Deployment' {
                if ($Deployment.Template) {
                    return $Deployment.Template
                }
                else {
                    if ($Deployment.TemplateId) {
                        $Uri = '{0}/{1}' -f $BaseUri, $Deployment.TemplateId
                    }
                    else {
                        throw "TemplateId not set on Deployment $($Deployment.Name) (Id: $($Deployment.Id))"
                    }
                }
            }
            Default { $Uri = $BaseUri }
        }
        if ($PSCmdlet.ParameterSetName -in ('Id', 'Deployment')) {
            $Uri = $Uri | Add-UriQueryParam "IncludeDefinition=1"
            $Uri = $Uri | Add-UriQueryParam "IncludeReferencedObjects=1"
        }
        if ($IncludeDeleted) {
            $Uri = $Uri | Add-UriQueryParam "IncludeDeleted=1"
        }

        # ApiCall Cache
        if ($ProcessedUrls -notcontains $Uri) {
            try {
                # ApiCall and Object conversion
                $ResultItems = Invoke-DuneApiRequest -Uri $Uri -Method $Method -ExtractItems
                $ProcessedUrls += $Uri
                $ReturnObjects += $ResultItems | ForEach-Object {
                    if ($Raw) {
                        $_
                    }
                    else {
                        if (-not $uri.Contains('/')) {
                            if ($IncludeDefinition) { Get-DuneDeploymentTemplate -Id $_.Id }
                            else { ConvertTo-DuneClassObject -Class DuneDeploymentTemplate -InputObject $_ }
                        }
                        else {
                            ConvertTo-DuneClassObject -Class DuneDeploymentTemplate -InputObject $_
                        }
                    }
                }
            }
            catch {
                throw $_
            }
        }
        else {
            Write-Debug "$($MyInvocation.MyCommand)|process|ApiCall Cache hit: DuneApiRequest for $Uri already invoked"
        }
    }

    end {
        Write-Debug "$($MyInvocation.MyCommand)|end"
        if ($uri -and -not $uri.Contains('/') -and -not $Raw) {
            if ($IncludeDefinition) {
                $ReturnObjects | ForEach-Object {
                    $_.Definition = ((Invoke-DuneApiRequest -Uri "$BaseUri/$($_.Id)/definition" -Method 'GET').Content | ConvertFrom-Json).Definition
                }
            }
            else {
                Write-Warning "Slimmed down objects are returned. Please specify IncludeDefinition param to show full objects (Definition, AllowedResourceProviders, ResourceGroupTemplates)"
            }
        }
        $ReturnObjects = $ReturnObjects | Sort-Object -Unique Id | Sort-Object -Property Name, Version
        if ($Latest) {
            $ReturnObjects = Foreach ($Name in ($ReturnObjects | Select Name -Unique).Name){
                $ReturnObjects | ? Name -in $Name | Sort-Object Version | Select -Last 1
            }
        }
        return $ReturnObjects
    }
}