NN.SnipeIT

0.0.3

NN.SnipeIT.psm1

#Region './Private/Get-SnipeAccessToken.ps1' 0
function Get-SnipeAccessToken {
    param (
        [string]$accessTokenPath = "$env:USERPROFILE\.creds\Snipe-IT\snipeitAccessToken.xml"
    )

    if (!(Test-Path $accessTokenPath)) {
        New-SnipeAccessToken
    }

    Import-Clixml $accessTokenPath | ConvertFrom-SecureString -AsPlainText
}
#EndRegion './Private/Get-SnipeAccessToken.ps1' 12
#Region './Private/Get-SnipeEndpoint.ps1' 0
function Get-SnipeEndpoint {
    param (
        [string]$endpointPath = "$env:USERPROFILE\.creds\Snipe-IT\snipeitEndpoint.xml"
    )

    if (!(Test-Path $endpointPath)) {
        New-SnipeEndpoint
    }

    Import-Clixml $endpointPath
}
#EndRegion './Private/Get-SnipeEndpoint.ps1' 12
#Region './Private/Invoke-SnipeMethod.ps1' 0
function Invoke-SnipeMethod {
    param (
        [Parameter(Mandatory)][string]$Uri,
        [Parameter(Mandatory)][ValidateSet("GET","POST","PUT","PATCH","DELETE")][string]$Method
    )
    
    $splat = @{
        "Uri" = $uri
        "Method" = "GET"
        "Headers" = @{
            "Authorization" = "Bearer $(Get-SnipeAccessToken)"
            "Accept" = "application/json"
            "Content-Type" = "application/json"
        }
    }
    $result = Invoke-RestMethod @splat

    if ($result.PSObject.Properties.name -contains "rows") {
        $result.rows
    } else {
        $result
    }
}
#EndRegion './Private/Invoke-SnipeMethod.ps1' 24
#Region './Private/Register-Autofill.ps1' 0
$Splat = @{
    "CommandName" = "Get-SnipeLocations"
    "ParameterName" = "name"
    "ScriptBlock" = {
        param($commandName, $parameterName, $wordToComplete, $commandAst, $fakeBoundParameters)

        $AllLocationNames = (Get-SnipeLocations).name | Sort-Object
        $AllLocationNames.Where({
            $_ -like "$wordToComplete*"
        }).ForEach({
            "`"$_`""
        })
    }
}
Register-ArgumentCompleter @Splat
#EndRegion './Private/Register-Autofill.ps1' 16
#Region './Public/Get-SnipeAccessories.ps1' 0
function Get-SnipeAccessories {
    [CmdletBinding(DefaultParameterSetName="List accessories")]
    param (
        [Parameter(Position=0,ParameterSetName="List accessories")][string]$search,
        [Parameter(ParameterSetName="List accessories")][int]$limit,
        [Parameter(ParameterSetName="List accessories")][int]$offset,
        [Parameter(ParameterSetName="List accessories")][string]$order_number,
        [Parameter(ParameterSetName="List accessories")][ValidateSet(
            "id",
            "name",
            "asset_tag",
            "serial",
            "model",
            "model_number",
            "last_checkout",
            "category",
            "manufacturer",
            "notes",
            "expected_checkin",
            "order_number",
            "companyName",
            "location",
            "image",
            "status_label",
            "assigned_to",
            "created_at",
            "purchase_date",
            "purchase_cost"
            )][string]$sort,
        [Parameter(ParameterSetName="List accessories")][ValidateSet("asc","desc")][string]$order,
        [Parameter(ParameterSetName="List accessories")][ValidateSet("true","false")][string]$expand,
        [Parameter(Mandatory,ParameterSetName="Get accessory by id")][int]$id,
        [Parameter(ParameterSetName="Get accessory by id")][switch]$listCheckedOut

    )

    $uri = "$(Get-SnipeEndpoint)/accessories"

    switch ($PsCmdlet.ParameterSetName) {
        "List accessories" {
            $PSBoundParameters.Keys.ForEach({
                $key = $_
                $value = $PSBoundParameters.$key

                if (([array]$PSBoundParameters.Keys)[0] -eq $key) {
                    $delimiter = "?"
                } else {
                    $delimiter = "&"
                }

                $uri = "$uri$delimiter$key=$value"
            })
        }
        "Get accessory by id" {
            $uri = "$uri/$id"
            if ($listCheckedOut) {
                $uri = "$uri/checkedout"
            }
        }
    }

    Invoke-SnipeMethod -Method "GET" -Uri $uri
}
#EndRegion './Public/Get-SnipeAccessories.ps1' 64
#Region './Public/Get-SnipeAssets.ps1' 0
function Get-SnipeAssets {
    [CmdletBinding(DefaultParameterSetName="List assets")]
    param (
        [Parameter(ParameterSetName="List assets")][int]$limit,
        [Parameter(ParameterSetName="List assets")][int]$offset,
        [Parameter(Position=0,ParameterSetName="List assets")][string]$search,
        [Parameter(ParameterSetName="List assets")][string]$order_number,
        [Parameter(ParameterSetName="List assets")][ValidateSet(
            "id",
            "name",
            "asset_tag",
            "serial",
            "model",
            "model_number",
            "last_checkout",
            "category",
            "manufacturer",
            "notes",
            "expected_checkin",
            "order_number",
            "companyName",
            "location",
            "image",
            "status_label",
            "assigned_to",
            "created_at",
            "purchase_date",
            "purchase_cost"
            )][string]$sort,
        [Parameter(ParameterSetName="List assets")][ValidateSet("asc","desc")][string]$order,
        [Parameter(ParameterSetName="List assets")][int]$model_id,
        [Parameter(ParameterSetName="List assets")][int]$category_id,
        [Parameter(ParameterSetName="List assets")][int]$manufacturer_id,
        [Parameter(ParameterSetName="List assets")][int]$company_id,
        [Parameter(ParameterSetName="List assets")][int]$location_id,
        [Parameter(ParameterSetName="List assets")][ValidateSet(
            "RTD",
            "Deployed",
            "Undeployable",
            "Deleted",
            "Archived",
            "Requestable"
            )][string]$status,
        [Parameter(ParameterSetName="List assets")][int]$status_id,
        [Parameter(Mandatory,ParameterSetName="Get asset by id")][int]$id,
        [Parameter(Mandatory,ParameterSetName="Get asset by asset_tag")][string]$asset_tag,
        [Parameter(Mandatory,ParameterSetName="Get asset by serial")][string]$serial,
        [Parameter(ParameterSetName="List assets by audit_due")][switch]$audit_due,
        [Parameter(ParameterSetName="List assets by audit_overdue")][switch]$audit_overdue
    )

    $uri = "$(Get-SnipeEndpoint)/hardware"

    switch ($PsCmdlet.ParameterSetName) {
        "List assets" {
            $PSBoundParameters.Keys.ForEach({
                $key = $_
                $value = $PSBoundParameters.$key

                if (([array]$PSBoundParameters.Keys)[0] -eq $key) {
                    $delimiter = "?"
                } else {
                    $delimiter = "&"
                }

                $uri = "$uri$delimiter$key=$value"
            })
        }
        "Get asset by id" {
            $uri = "$uri/$id"
        }
        "Get asset by asset_tag" {
            $uri = "$uri/bytag/$asset_tag"
        }
        "Get asset by serial" {
            $uri = "$uri/byserial/$serial"
        }
        "List assets by audit_due" {
            $uri = "$uri/audit/due"
        }
        "List assets by audit_overdue" {
            $uri = "$uri/audit/overdue"
        }
    }

    Invoke-SnipeMethod -Method "GET" -Uri $uri
}
#EndRegion './Public/Get-SnipeAssets.ps1' 88
#Region './Public/Get-SnipeCategories.ps1' 0
function Get-SnipeCategories {
    [CmdletBinding(DefaultParameterSetName="List categories")]
    param (
        [Parameter(Position=0,ParameterSetName="List categories")][string]$name,
        [Parameter(ParameterSetName="List categories")][int]$limit,
        [Parameter(ParameterSetName="List categories")][int]$offset,
        [Parameter(ParameterSetName="List categories")][string]$search,
        [Parameter(ParameterSetName="List categories")][string]$sort,
        [Parameter(ParameterSetName="List categories")][ValidateSet("asc","desc")][string]$order,
        [Parameter(ParameterSetName="List categories")][int]$category_id,
        [Parameter(ParameterSetName="List categories")][string]$category_type,
        [Parameter(ParameterSetName="List categories")][ValidateSet("true","false")][string]$use_default_eula,
        [Parameter(ParameterSetName="List categories")][ValidateSet("true","false")][string]$require_acceptance,
        [Parameter(ParameterSetName="List categories")][ValidateSet("true","false")][string]$checkin_email,
        [Parameter(Mandatory,ParameterSetName="Get category by id")][int]$id
    )

    $uri = "$(Get-SnipeEndpoint)/categories"

    switch ($PsCmdlet.ParameterSetName) {
        "List categories" {
            $PSBoundParameters.Keys.ForEach({
                $key = $_
                $value = $PSBoundParameters.$key

                if (([array]$PSBoundParameters.Keys)[0] -eq $key) {
                    $delimiter = "?"
                } else {
                    $delimiter = "&"
                }

                $uri = "$uri$delimiter$key=$value"
            })
        }
        "Get category by id" {
            $uri = "$uri/$id"
        }
    }

    Invoke-SnipeMethod -Method "GET" -Uri $uri
}
#EndRegion './Public/Get-SnipeCategories.ps1' 42
#Region './Public/Get-SnipeCompanies.ps1' 0
function Get-SnipeCompanies {
    [CmdletBinding(DefaultParameterSetName="List companies")]
    param (
        [Parameter(Position=0,ParameterSetName="List companies")][string]$name,
        [Parameter(Mandatory,ParameterSetName="Get company by id")][int]$id
    )

    $uri = "$(Get-SnipeEndpoint)/companies"

    switch ($PsCmdlet.ParameterSetName) {
        "List companies" {
            $PSBoundParameters.Keys.ForEach({
                $key = $_
                $value = $PSBoundParameters.$key

                if (([array]$PSBoundParameters.Keys)[0] -eq $key) {
                    $delimiter = "?"
                } else {
                    $delimiter = "&"
                }

                $uri = "$uri$delimiter$key=$value"
            })
        }
        "Get company by id" {
            $uri = "$uri/$id"
        }
    }

    Invoke-SnipeMethod -Method "GET" -Uri $uri
}
#EndRegion './Public/Get-SnipeCompanies.ps1' 32
#Region './Public/Get-SnipeConsumables.ps1' 0
function Get-SnipeConsumables {
    [CmdletBinding(DefaultParameterSetName="List consumables")]
    param (
        [Parameter(Position=0,ParameterSetName="List consumables")][string]$name,
        [Parameter(ParameterSetName="List consumables")][int]$limit,
        [Parameter(ParameterSetName="List consumables")][int]$offset,
        [Parameter(ParameterSetName="List consumables")][string]$search,
        [Parameter(ParameterSetName="List consumables")][string]$order_number,
        [Parameter(ParameterSetName="List consumables")][ValidateSet(
            "id",
            "name",
            "asset_tag",
            "serial",
            "model",
            "model_number",
            "last_checkout",
            "category",
            "manufacturer",
            "notes",
            "expected_checkin",
            "order_number",
            "companyName",
            "location",
            "image",
            "status_label",
            "assigned_to",
            "created_at",
            "purchase_date",
            "purchase_cost"
            )][string]$sort,
        [Parameter(ParameterSetName="List consumables")][ValidateSet("asc","desc")][string]$order,
        [Parameter(ParameterSetName="List consumables")][ValidateSet("true","false")][string]$expand,
        [Parameter(ParameterSetName="List consumables")][int]$category_id,
        [Parameter(ParameterSetName="List consumables")][int]$company_id,
        [Parameter(ParameterSetName="List consumables")][int]$manufacturer_id,
        [Parameter(Mandatory,ParameterSetName="Get consumable by id")][int]$id
    )
    
    $uri = "$(Get-SnipeEndpoint)/consumables"

    switch ($PsCmdlet.ParameterSetName) {
        "List consumables" {
            $PSBoundParameters.Keys.ForEach({
                $key = $_
                $value = $PSBoundParameters.$key

                if (([array]$PSBoundParameters.Keys)[0] -eq $key) {
                    $delimiter = "?"
                } else {
                    $delimiter = "&"
                }

                $uri = "$uri$delimiter$key=$value"
            })
        }
        "Get consumable by id" {
            $uri = "$uri/$id"
        }
    }

    Invoke-SnipeMethod -Method "GET" -Uri $uri
}
#EndRegion './Public/Get-SnipeConsumables.ps1' 63
#Region './Public/Get-SnipeDepartments.ps1' 0
function Get-SnipeDepartments {
    [CmdletBinding(DefaultParameterSetName="List departments")]
    param (
        [Parameter(Position=0,ParameterSetName="List departments")][string]$name,
        [Parameter(ParameterSetName="List departments")][int]$company_id,
        [Parameter(ParameterSetName="List departments")][int]$manager_id,
        [Parameter(ParameterSetName="List departments")][int]$location_id,
        [Parameter(Mandatory,ParameterSetName="Get department by id")][int]$id
    )

    $uri = "$(Get-SnipeEndpoint)/departments"

    switch ($PsCmdlet.ParameterSetName) {
        "List departments" {
            $PSBoundParameters.Keys.ForEach({
                $key = $_
                $value = $PSBoundParameters.$key

                if (([array]$PSBoundParameters.Keys)[0] -eq $key) {
                    $delimiter = "?"
                } else {
                    $delimiter = "&"
                }

                $uri = "$uri$delimiter$key=$value"
            })
        }
        "Get department by id" {
            $uri = "$uri/$id"
        }
    }

    Invoke-SnipeMethod -Method "GET" -Uri $uri
}
#EndRegion './Public/Get-SnipeDepartments.ps1' 35
#Region './Public/Get-SnipeFields.ps1' 0
function Get-SnipeFields {
    [CmdletBinding(DefaultParameterSetName="List fields")]
    param (
        [Parameter(Mandatory,ParameterSetName="Get field by id")][int]$id,
        [Parameter(ParameterSetName="List fields")][switch]$listField
    )

    $uri = "$(Get-SnipeEndpoint)/fields"

    switch ($PsCmdlet.ParameterSetName) {
        "Get field by id" {
            $uri = "$uri/$id"
        }
    }

    Invoke-SnipeMethod -Method "GET" -Uri $uri
}
#EndRegion './Public/Get-SnipeFields.ps1' 18
#Region './Public/Get-SnipeFieldsets.ps1' 0
function Get-SnipeFieldsets {
    [CmdletBinding(DefaultParameterSetName="List fieldsets")]
    param (
        [Parameter(Mandatory,ParameterSetName="Get fieldset by id")][int]$id,
        [Parameter(ParameterSetName="List fieldsets")][switch]$listfieldsets
    )

    $uri = "$(Get-SnipeEndpoint)/fieldsets"

    switch ($PsCmdlet.ParameterSetName) {
        "Get fieldset by id" {
            $uri = "$uri/$id"
        }
    }

    Invoke-SnipeMethod -Method "GET" -Uri $uri
}
#EndRegion './Public/Get-SnipeFieldsets.ps1' 18
#Region './Public/Get-SnipeGroups.ps1' 0
function Get-SnipeGroups {
    [CmdletBinding(DefaultParameterSetName="List groups")]
    param (
        [Parameter(Position=0,ParameterSetName="List groups")][string]$name,
        [Parameter(Mandatory,ParameterSetName="Get group by id")][int]$id
    )

    $uri = "$(Get-SnipeEndpoint)/groups"

    switch ($PsCmdlet.ParameterSetName) {
        "List groups" {
            $PSBoundParameters.Keys.ForEach({
                $key = $_
                $value = $PSBoundParameters.$key

                if (([array]$PSBoundParameters.Keys)[0] -eq $key) {
                    $delimiter = "?"
                } else {
                    $delimiter = "&"
                }

                $uri = "$uri$delimiter$key=$value"
            })
        }
        "Get group by id" {
            $uri = "$uri/$id"
        }
    }

    Invoke-SnipeMethod -Method "GET" -Uri $uri
}
#EndRegion './Public/Get-SnipeGroups.ps1' 32
#Region './Public/Get-SnipeLocations.ps1' 0
function Get-SnipeLocations {
    <#
    .SYNOPSIS
        Gets locations from Snipe-IT
    .LINK
        List locations:
        https://snipe-it.readme.io/reference/locations
    .LINK
        Get location by id:
        https://snipe-it.readme.io/reference/locations-1
    .EXAMPLE
        Get-SnipeLocation
        Returns all locations from Snipe-IT.
    .EXAMPLE
        Get-SnipeLocation -name Home
        Returns location based on name.
    .EXAMPLE
        Get-SnipeLocation -search VGS
        Returns locations that have a name that matches the string "VGS".
        Uses wildcards.
    .EXAMPLE
        Get-SnipeLocation -id 1
        Returns location based on the given id.
    #>
    [CmdletBinding(DefaultParameterSetName="List locations")]
    param (
        [Parameter(Position=0,ParameterSetName="List locations")][ValidateScript({
            $_ -in (Get-SnipeLocations).name
        })][string]$name,
        [Parameter(ParameterSetName="List locations")][int]$limit,
        [Parameter(ParameterSetName="List locations")][int]$offset,
        [Parameter(ParameterSetName="List locations")][string]$search,
        [Parameter(ParameterSetName="List locations")][string]$sort,
        [Parameter(ParameterSetName="List locations")][ValidateSet("asc","desc")][string]$order,
        [Parameter(ParameterSetName="List locations")][string]$address,
        [Parameter(ParameterSetName="List locations")][string]$address2,
        [Parameter(ParameterSetName="List locations")][string]$city,
        [Parameter(ParameterSetName="List locations")][string]$zip,
        [Parameter(ParameterSetName="List locations")][string]$country,
        [Parameter(Mandatory,ParameterSetName="Get location by id")][int]$id
    )

    $uri = "$(Get-SnipeEndpoint)/locations"

    switch ($PsCmdlet.ParameterSetName) {
        "List locations" {
            $PSBoundParameters.Keys.ForEach({
                $key = $_
                $value = $PSBoundParameters.$key

                if (([array]$PSBoundParameters.Keys)[0] -eq $key) {
                    $delimiter = "?"
                } else {
                    $delimiter = "&"
                }

                $uri = "$uri$delimiter$key=$value"
            })
        }
        "Get location by id" {
            $uri = "$uri/$id"
        }
    }

    Invoke-SnipeMethod -Method "GET" -Uri $uri
}
#EndRegion './Public/Get-SnipeLocations.ps1' 67
#Region './Public/Get-SnipeMaintenances.ps1' 0
function Get-SnipeMaintenances {
    [CmdletBinding(DefaultParameterSetName="List maintenances")]
    param (
        [Parameter(ParameterSetName="List maintenances")][int]$limit,
        [Parameter(ParameterSetName="List maintenances")][int]$offset,
        [Parameter(Position=0,ParameterSetName="List maintenances")][string]$search,
        [Parameter(ParameterSetName="List maintenances")][string]$sort,
        [Parameter(ParameterSetName="List maintenances")][string]$order,
        [Parameter(ParameterSetName="List maintenances")][int]$asset_id
    )

    $uri = "$(Get-SnipeEndpoint)/maintenances"

    switch ($PsCmdlet.ParameterSetName) {
        "List maintenances" {
            $PSBoundParameters.Keys.ForEach({
                $key = $_
                $value = $PSBoundParameters.$key

                if (([array]$PSBoundParameters.Keys)[0] -eq $key) {
                    $delimiter = "?"
                } else {
                    $delimiter = "&"
                }

                $uri = "$uri$delimiter$key=$value"
            })
        }
    }

    Invoke-SnipeMethod -Method "GET" -Uri $uri
}
#EndRegion './Public/Get-SnipeMaintenances.ps1' 33
#Region './Public/Get-SnipeManufacturers.ps1' 0
function Get-SnipeManufacturers {
    [CmdletBinding(DefaultParameterSetName="List manufacturers")]
    param (
        [Parameter(Position=0,ParameterSetName="List manufacturers")][string]$name,
        [Parameter(ParameterSetName="List manufacturers")][string]$url,
        [Parameter(ParameterSetName="List manufacturers")][string]$support_url,
        [Parameter(ParameterSetName="List manufacturers")][string]$support_phone,
        [Parameter(ParameterSetName="List manufacturers")][string]$support_email,
        [Parameter(Mandatory,ParameterSetName="Get manufacturer by id")][int]$id
    )

    $uri = "$(Get-SnipeEndpoint)/manufacturers"

    switch ($PsCmdlet.ParameterSetName) {
        "List manufacturers" {
            $PSBoundParameters.Keys.ForEach({
                $key = $_
                $value = $PSBoundParameters.$key

                if (([array]$PSBoundParameters.Keys)[0] -eq $key) {
                    $delimiter = "?"
                } else {
                    $delimiter = "&"
                }

                $uri = "$uri$delimiter$key=$value"
            })
        }
        "Get manufacturer by id" {
            $uri = "$uri/$id"
        }
    }

    Invoke-SnipeMethod -Method "GET" -Uri $uri
}
#EndRegion './Public/Get-SnipeManufacturers.ps1' 36
#Region './Public/Get-SnipeModels.ps1' 0
function Get-SnipeModels {
    [CmdletBinding(DefaultParameterSetName="List models")]
    param (
        [Parameter(Position=0,ParameterSetName="List models")][string]$search,
        [Parameter(ParameterSetName="List models")][int]$limit,
        [Parameter(ParameterSetName="List models")][int]$offset,
        [Parameter(ParameterSetName="List models")][string]$sort,
        [Parameter(ParameterSetName="List models")][ValidateSet("asc","desc")][int]$order,
        [Parameter(Mandatory,ParameterSetName="Get model by id")][int]$id
    )

    $uri = "$(Get-SnipeEndpoint)/models"

    switch ($PsCmdlet.ParameterSetName) {
        "List models" {
            $PSBoundParameters.Keys.ForEach({
                $key = $_
                $value = $PSBoundParameters.$key

                if (([array]$PSBoundParameters.Keys)[0] -eq $key) {
                    $delimiter = "?"
                } else {
                    $delimiter = "&"
                }

                $uri = "$uri$delimiter$key=$value"
            })
        }
        "Get model by id" {
            $uri = "$uri/$id"
        }
    }

    Invoke-SnipeMethod -Method "GET" -Uri $uri
}
#EndRegion './Public/Get-SnipeModels.ps1' 36
#Region './Public/Get-SnipeSuppliers.ps1' 0
function Get-SnipeSuppliers {
    [CmdletBinding(DefaultParameterSetName="List suppliers")]
    param (
        [Parameter(Position=0,ParameterSetName="List suppliers")][string]$name,
        [Parameter(ParameterSetName="List suppliers")][string]$address,
        [Parameter(ParameterSetName="List suppliers")][string]$address2,
        [Parameter(ParameterSetName="List suppliers")][string]$city,
        [Parameter(ParameterSetName="List suppliers")][string]$zip,
        [Parameter(ParameterSetName="List suppliers")][string]$country,
        [Parameter(ParameterSetName="List suppliers")][string]$fax,
        [Parameter(ParameterSetName="List suppliers")][string]$email,
        [Parameter(ParameterSetName="List suppliers")][string]$url,
        [Parameter(ParameterSetName="List suppliers")][string]$notes,
        [Parameter(Mandatory,ParameterSetName="Get supplier by id")][int]$id
    )

    $uri = "$(Get-SnipeEndpoint)/suppliers"

    switch ($PsCmdlet.ParameterSetName) {
        "List suppliers" {
            $PSBoundParameters.Keys.ForEach({
                $key = $_
                $value = $PSBoundParameters.$key

                if (([array]$PSBoundParameters.Keys)[0] -eq $key) {
                    $delimiter = "?"
                } else {
                    $delimiter = "&"
                }

                $uri = "$uri$delimiter$key=$value"
            })
        }
        "Get supplier by id" {
            $uri = "$uri/$id"
        }
    }

    Invoke-SnipeMethod -Method "GET" -Uri $uri
}
#EndRegion './Public/Get-SnipeSuppliers.ps1' 41
#Region './Public/Get-SnipeUsers.ps1' 0
function Get-SnipeUsers {
    [CmdletBinding(DefaultParameterSetName="List users")]
    param (
        [Parameter(Position=0,ParameterSetName="List users")][string]$search,
        [Parameter(ParameterSetName="List users")][int]$limit,
        [Parameter(ParameterSetName="List users")][int]$offset,
        [Parameter(ParameterSetName="List users")][string]$sort,
        [Parameter(ParameterSetName="List users")][ValidateSet("asc","desc")][string]$order,
        [Parameter(ParameterSetName="List users")][string]$first_name,
        [Parameter(ParameterSetName="List users")][string]$last_name,
        [Parameter(ParameterSetName="List users")][string]$username,
        [Parameter(ParameterSetName="List users")][string]$email,
        [Parameter(ParameterSetName="List users")][string]$employee_num,
        [Parameter(ParameterSetName="List users")][string]$state,
        [Parameter(ParameterSetName="List users")][string]$zip,
        [Parameter(ParameterSetName="List users")][string]$country,
        [Parameter(ParameterSetName="List users")][int]$group_id,
        [Parameter(ParameterSetName="List users")][int]$department_id,
        [Parameter(ParameterSetName="List users")][int]$company_id,
        [Parameter(ParameterSetName="List users")][int]$location_id,
        [Parameter(ParameterSetName="List users")][ValidateSet("true","false")][string]$deleted,
        [Parameter(ParameterSetName="List users")][ValidateSet("true","false")][string]$all,
        [Parameter(ParameterSetName="List users")][ValidateSet("0","1")][int]$ldap_import,
        [Parameter(ParameterSetName="List users")][int]$asset_count,
        [Parameter(ParameterSetName="List users")][int]$licenses_count,
        [Parameter(ParameterSetName="List users")][int]$accessories_count,
        [Parameter(ParameterSetName="List users")][int]$consumables_count,
        [Parameter(ParameterSetName="List users")][ValidateSet("0","1")][int]$remote,
        [Parameter(Mandatory,ParameterSetName="Get user by id")][int]$id
    )

    $uri = "$(Get-SnipeEndpoint)/users"

    switch ($PsCmdlet.ParameterSetName) {
        "List users" {
            $PSBoundParameters.Keys.ForEach({
                $key = $_
                $value = $PSBoundParameters.$key

                if (([array]$PSBoundParameters.Keys)[0] -eq $key) {
                    $delimiter = "?"
                } else {
                    $delimiter = "&"
                }

                $uri = "$uri$delimiter$key=$value"
            })
        }
        "Get user by id" {
            $uri = "$uri/$id"
        }
    }

    Invoke-SnipeMethod -Method "GET" -Uri $uri
}
#EndRegion './Public/Get-SnipeUsers.ps1' 56
#Region './Public/New-SnipeAccessToken.ps1' 0
function New-SnipeAccessToken {
    param (
        [string]$accessTokenPath = "$env:USERPROFILE\.creds\Snipe-IT\snipeitAccessToken.xml"
    )

    $apiKey = Read-Host "Enter Snipe-IT API key" -AsSecureString

    #Create parent folders of the access token file
    $accessTokenDir = $accessTokenPath.Substring(0, $accessTokenPath.lastIndexOf('\'))
    if (!(Test-Path $accessTokenDir)) {
        $null = New-Item -ItemType Directory $accessTokenDir
    }

    #Create access token file
    $apiKey | Export-Clixml $accessTokenPath
}
#EndRegion './Public/New-SnipeAccessToken.ps1' 17
#Region './Public/New-SnipeEndpoint.ps1' 0
function New-SnipeEndpoint {
    param (
        [string]$endpointPath = "$env:USERPROFILE\.creds\Snipe-IT\snipeitEndpoint.xml"
    )

    $pureserviceUrl = Read-Host "Enter Snipe-IT url"
    $endpoint = "$pureserviceUrl/api/v1"

    #Create parent folders of the access token file
    $endpointDir = $endpointPath.Substring(0, $endpointPath.lastIndexOf('\'))
    if (!(Test-Path $endpointDir)) {
        New-Item -ItemType Directory $endpointDir | Out-Null
    }

    #Create access token file
    $endpoint | Export-Clixml $endpointPath
}
#EndRegion './Public/New-SnipeEndpoint.ps1' 18