Dune

1.0.0

Public/Get-DuneDeployment.ps1

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

        [Parameter()]
        [string]$DisplayName,

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

        [Parameter(ParameterSetName = "Collection", ValueFromPipeline)]
        [DuneCollection]$Collection,

        [Parameter(ParameterSetName = "DeploymentTemplate", ValueFromPipeline)]
        [DuneDeploymentTemplate]$DeploymentTemplate,

        [Parameter(ParameterSetName = "ResourceGroup", ValueFromPipeline)]
        [DuneResourceGroup]$ResourceGroup,

        [Parameter(ParameterSetName = "Resource", ValueFromPipeline)]
        [DuneResource]$Resource,

        [Parameter(ParameterSetName = "Job", ValueFromPipeline)]
        [DuneJob]$Job,

        [Parameter()]
        [Environments]$Environment,

        [Parameter()]
        [switch]$Raw,

        [Parameter()]
        [switch]$IncludeDeploymentTemplate,

        [Parameter()]
        [switch]$IncludeDeleted
    )

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

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

        # Build Uri
        switch ($PSCmdlet.ParameterSetName) {
            'Id' { $Uri = '{0}/{1}' -f $BaseUri, $Id }
            'Collection' { $Uri = '{0}?ParentId={1}' -f $BaseUri, $Collection.Id }
            'ResourceGroup' { $Uri = '{0}/{1}' -f $BaseUri, $ResourceGroup.ParentId }
            'Resource' {
                if ($Resource.Deployment) {
                    return $Resource.Deployment
                }
                else {
                    $Uri = '{0}/{1}' -f $BaseUri, $Resource.DeploymentId
                }
            }
            'DeploymentTemplate' { $Uri = '{0}?TemplateId={1}' -f $BaseUri, $DeploymentTemplate.Id }
            'Job' {
                if ($Job.ConfigItemType -eq "Deployment") {
                    $Uri = '{0}/{1}' -f $BaseUri, $Job.ConfigItemId
                }
                else {
                    Write-Warning "Wrong ConfigItemType $($Job.ConfigItemId) for Job $($Job.Name) (id: $($Job.Id))"
                    return
                }
            }
            Default { $Uri = $BaseUri }
        }
        if ($Name) {
            $Uri = $Uri | Add-UriQueryParam "NameILike=$Name" -ConvertWildcards
        }
        if ($DisplayName) {
            $Uri = $Uri | Add-UriQueryParam "DisplayNameILike=$DisplayName" -ConvertWildcards
        }
        if ($IncludeDeleted) {
            $Uri = $Uri | Add-UriQueryParam "IncludeDeleted=1"
        }
        if ($PSBoundParameters.ContainsKey('Environment')) {
            $Uri = $Uri | Add-UriQueryParam "Environment=$Environment"
        }

        # ApiCall Cache
        if ($ProcessedUrls -notcontains $Uri) {
            try {
                $ResultItems = Invoke-DuneApiRequest -Uri $Uri -Method $Method -ExtractItems
                $ProcessedUrls += $Uri
                $ReturnObjects += $ResultItems | ForEach-Object {
                    if ($Raw) {
                        $_
                    }
                    else {
                        If ($_.template) { $_.template = ConvertTo-DuneClassObject -Class DuneTemplate -InputObject $_.template }
                        ConvertTo-DuneClassObject -Class DuneDeployment -InputObject $_ #-AbstractClass "Template"
                    }
                }
            }
            catch {
                throw $_
            }
        }
        else {
            Write-Debug "$($MyInvocation.MyCommand)|process|ApiCall Cache hit: DuneApiRequest for $Uri already invoked"
        }
    }

    end {
        Write-Debug "$($MyInvocation.MyCommand)|end"
        # if($IncludeDeploymentTemplate){
        # $DeploymentTemplates = Get-DuneDeploymentTemplate
        # foreach ($Object in $ReturnObjects) {
        # $Object.Template = $DeploymentTemplates | Where-Object Id -EQ $Object.TemplateId
        # }
        # }
        if ($IncludeDeploymentTemplate -and ($ReturnObjects | Where-Object { -not $_.Template })) {
            $DeploymentTemplates = if (($ReturnObjects.Count -eq 1) -and (-not $ReturnObjects.Template)) { $ReturnObjects | Get-DuneDeploymentTemplate }else { Get-DuneDeploymentTemplate }
            foreach ($Object in ($ReturnObjects | Where-Object { -not $_.Template })) {
                $Object.Template = $DeploymentTemplates | Where-Object Id -EQ $Object.TemplateId
            }
        }
        return $ReturnObjects | Sort-Object -Unique Id | Sort-Object created
    }
}